batframework 1.0.6__py3-none-any.whl → 1.0.8a1__py3-none-any.whl

batFramework/gui/container.py

@@ -1,60 +1,173 @@
 import batFramework as bf
 from .widget import Widget
-from .layout import Layout,Column
-from .constraints import Constraint
+from .shape import Shape
+from .interactiveWidget import InteractiveWidget
+from .layout import Layout, Column
 from typing import Self
+import pygame
+from pygame.math import Vector2
 
-class Container(Widget):
-    def __init__(self, layout: Layout = Column(), *children: Widget)->None:
+
+class Container(Shape, InteractiveWidget):
+    def __init__(self, layout: Layout = None, *children: Widget) -> None:
         super().__init__()
+        self.dirty_children = False
         self.set_debug_color("green")
-        self.surface = None
         self.layout: Layout = layout
+        self.scroll = Vector2(0, 0)
+        if not self.layout:
+            self.layout = Column()
+        self.layout.set_parent(self)
+        self.add(*children)
+
+    def get_min_required_size(self):
         if self.layout:
-            self.layout.set_parent(self)
-        for child in children:
-            self.add_child(child)
+            return self.layout.get_auto_size()
+        return self.rect.size
+
+    def reset_scroll(self) -> Self:
+        self.scroll.update(0, 0)
+        self.dirty_children = True
+        return self
+
+    def set_scroll(self, value: tuple) -> Self:
+        self.scroll.update(value)
+        self.dirty_children = True
+        return self
+
+    def scrollX_by(self, x: float | int) -> Self:
+        self.scroll.x += x
+        self.dirty_children = True
+        return self
 
-    def set_padding(self,value)->Self:
+    def scrollY_by(self, y: float | int) -> Self:
+        self.scroll.y += y
+        self.dirty_children = True
+        return self
+
+    def scroll_by(self, value: tuple[float | int, float | int]) -> Self:
+        self.scroll += value
+        self.dirty_children = True
         return self
 
     def set_layout(self, layout: Layout) -> Self:
+        tmp = self.layout
         self.layout = layout
-        self.apply_constraints()
+        if self.layout != tmp:
+            self.dirty_children = True
         return self
 
-    def get_bounding_box(self):
+
+    def get_debug_outlines(self):
         yield (self.rect, self.debug_color)
+        yield (self.get_padded_rect(), self.debug_color)
+
         for child in self.children:
-            yield from child.get_bounding_box()
+            yield from child.get_debug_outlines()
+            # for data in child.get_debug_outlines():
+
+    def get_interactive_children(self) -> list[InteractiveWidget]:
+        return [
+            child for child in self.children if isinstance(child, InteractiveWidget) and child.allow_focus_to_self()
+        ]
+
+    def focus_next_child(self) -> None:
+        self.layout.focus_next_child()
+        
+    def focus_prev_child(self) -> None:
+        self.layout.focus_prev_child()
 
     def clear_children(self) -> None:
         self.children.clear()
-        self.apply_constraints()
+        self.dirty_children = True
 
-    def add_child(self, *child: Widget) -> None:
-        super().add_child(*child)
-        if self.layout:
-            self.layout.arrange()
+    def add(self, *child: Widget) -> Self:
+        super().add(*child)
+        self.dirty_children = True
+        return self
 
-    def remove_child(self, child: Widget) -> None:
-        super().remove_child(child)
-        if self.layout:
-            self.layout.arrange()
+    def remove(self, *child: Widget) -> Self:
+        super().remove(*child)
+        self.dirty_children = True
+        return self
 
-    def build(self) -> None:
-        super().build()
-        if self.layout:
-            self.layout.arrange()
+    def resolve_constraints(self) -> None:
+        super().resolve_constraints()
 
-    def apply_constraints(self) -> None:
-        super().apply_constraints()
-        if self.layout:
-            self.layout.arrange()
+    def __str__(self) -> str:
+        return f"Container({self.uid},{len(self.children)})"
+
+    def top_at(self, x: float | int, y: float | int) -> "None|Widget":
+        if self.visible and self.rect.collidepoint(x, y):
+            if self.children:
+                for child in reversed(self.children):
+                    r = child.top_at(x,y)
+                    if r is not None:
+                        return r
+            return self
+        return None
+
+    def get_focus(self) -> bool:
+        res = super().get_focus()
+        if not res:
+            return False
+        l = l = self.get_interactive_children()
+        if not l:
+            return True
+        self.focused_index = min(self.focused_index, len(l))
+        return l[self.focused_index].get_focus()
+
+    def set_focused_child(self, child: InteractiveWidget) -> bool:
+        l = self.get_interactive_children()
+        i = l.index(child)
+        if i >= 0:
+            self.focused_index = i
+            return True
+        return False
+
+    def allow_focus_to_self(self) -> bool:
+        return len(self.get_interactive_children()) != 0
+
+    def draw(self, camera: bf.Camera) -> None:
+        constraints_down = False
+        if self.dirty_shape:
+            self.dirty_constraints = True
+            self.dirty_children = True
+            self.dirty_surface = True
+            self.build()
+            for child in self.children:
+                child.dirty_constraints = True
+            self.dirty_shape = False
+
+        if self.dirty_constraints:
+            if self.parent and self.parent.dirty_constraints:
+                self.parent.visit_up(self.selective_up)
+            else:
+                constraints_down = True
+
+        if self.dirty_children:
+            if self.layout:
+                self.layout.arrange()
+            self.dirty_children = False
+
+        if constraints_down:
+            self.visit(lambda c: c.resolve_constraints())
+
+        if self.dirty_surface:
+            self.paint()
+            self.dirty_surface = False
+
+
+        bf.Entity.draw(self, camera)
+
+        if self.clip_children:
+            new_clip = camera.world_to_screen(self.get_padded_rect())
+            old_clip = camera.surface.get_clip()
+            new_clip = new_clip.clip(old_clip)
+            camera.surface.set_clip(new_clip)
+        # Draw children with adjusted positions
+        _ = [child.draw(camera) for child in sorted(self.children, key=lambda c: c.render_order)]
 
-    def to_string_id(self) -> str:
-        return f"Container({self.uid},{len(self.children)},{[c.to_string() for c in self.constraints]})"
+        if self.clip_children:
+            camera.surface.set_clip(old_clip)
 
-    def children_modified(self)->None:
-        self.apply_all_constraints()
-        super().children_modified()

batFramework/gui/debugger.py

@@ -13,12 +13,13 @@ class Debugger(Label):
         self.static_data: dict = {}
         self.dynamic_data: dict = {}
         self.refresh_rate = 10
-        self.refresh_counter : float = 0
-        self.render_order = 99
-        self.set_uid("debugger")
+        self.refresh_counter: float = 0
+        self.add_tags("debugger")
+        self.set_visible(False)
+
+    # def get_debug_outlines(self):
+    #     yield None
 
-    def get_bounding_box(self):
-        yield None
     def to_string_id(self) -> str:
         return "Debugger"
 
@@ -34,14 +35,14 @@ class Debugger(Label):
         self.dynamic_data[key] = func
         self.update_text()
 
-    def remove_static(self,key)->bool:
+    def remove_static(self, key) -> bool:
         try:
             self.static_data.pop(key)
             return True
         except KeyError:
             return False
 
-    def remove_dynamic(self,key)->bool:
+    def remove_dynamic(self, key) -> bool:
         try:
             self.dynamic_data.pop(key)
             return True
@@ -50,9 +51,13 @@ class Debugger(Label):
 
     def set_parent_scene(self, scene) -> Self:
         super().set_parent_scene(scene)
+        self.set_render_order(99)
         self.update_text()
         return self
 
+    def set_text(self, text: str) -> Self:
+        return super().set_text(text)
+
     def update_text(self) -> None:
         if not self.parent_scene:
             return
@@ -69,7 +74,7 @@ class Debugger(Label):
     def update(self, dt: float) -> None:
         if not self.parent_scene:
             return
-        if self.parent_scene.get_sharedVar("debugging_mode") != 1:
+        if self.parent_scene.get_sharedVar("debug_mode") != bf.debugMode.DEBUGGER:
             self.set_visible(False)
             return
         self.set_visible(True)
@@ -79,33 +84,45 @@ class Debugger(Label):
             self.update_text()
 
 
-class BasicDebugger(Debugger):
-    def __init__(self):
-        super().__init__()
+    def __str__(self)->str:
+        return "Debugger"
+    # def top_at(self,x,y):
+        # return None
 
+class FPSDebugger(Debugger):
     def do_when_added(self):
-        if not self.parent_scene or  not self.parent_scene.manager:
+        if not self.parent_scene or not self.parent_scene.manager:
             print("Debugger could not link to the manager")
             return
         manager_link = self.parent_scene.manager
-        parent_scene = self.parent_scene
-        self.add_static("Resolution", 'x'.join(str(i) for i in bf.const.RESOLUTION))
+        self.add_dynamic("FPS", lambda: str(round(manager_link.get_fps())))
+
+
+class BasicDebugger(FPSDebugger):
+    def do_when_added(self):
+        if not self.parent_scene or not self.parent_scene.manager:
+            print("Debugger could not link to the manager")
+            return
         self.add_dynamic(
-            "FPS", lambda: str(round(manager_link.get_fps()))
+            "Resolution", lambda: "x".join(str(i) for i in bf.const.RESOLUTION)
         )
+        super().do_when_added()
+        parent_scene = self.parent_scene
+
         self.add_dynamic("Mouse", pygame.mouse.get_pos)
         self.add_dynamic(
             "World",
-            lambda: convert_to_int(*parent_scene.camera.convert_screen_to_world(
-                *pygame.mouse.get_pos())
+            lambda: convert_to_int(
+                *parent_scene.camera.screen_to_world(pygame.mouse.get_pos())
             ),
         )
         self.add_dynamic(
             "Hud",
-            lambda: convert_to_int(*parent_scene.hud_camera.convert_screen_to_world(
-                *pygame.mouse.get_pos())
+            lambda: convert_to_int(
+                *parent_scene.hud_camera.screen_to_world(pygame.mouse.get_pos())
             ),
         )
-        self.add_dynamic("W. Ent.",lambda : parent_scene.get_world_entity_count())
-        self.add_dynamic("H. Ent.",lambda : parent_scene.get_hud_entity_count())
-        
+        self.add_dynamic("W. Ent.", lambda: parent_scene.get_world_entity_count())
+        self.add_dynamic("H. Ent.", lambda: parent_scene.get_hud_entity_count())
+
+        self.add_dynamic("Hover",lambda : str(parent_scene.root.hovered) if parent_scene.root.hovered else None)

batFramework/gui/dialogueBox.py

@@ -1,70 +1,96 @@
-from .label import Label 
+from .label import Label
 import batFramework as bf
 from typing import Self
+
+
 class DialogueBox(Label):
-    def __init__(self)->None:
-        self.cursor_position :float = 0.0
-        self.text_speed :float = 20.0
-        self.message_queue : list[str]= [] 
-        self.is_over : bool = True
+    def __init__(self) -> None:
+        self.cursor_position: float = 0.0
+        self.text_speed: float = 20.0
+        self.message_queue: list[str] = []
+        self.is_over: bool = True
+        self.is_paused: bool = False
+        self.set_autoresize(False)
+        self.set_alignment(bf.alignment.LEFT)
         super().__init__("")
 
-        self.set_autoresize(False)
-        self.set_alignment(bf.Alignment.LEFT)
+    def pause(self)->Self:
+        self.is_paused = True
+        return self
+    
+    def resume(self)->Self:
+        self.is_paused = False
+        return self
 
-    def set_text_speed(self,speed:float)->Self:
+    def set_text_speed(self, speed: float) -> Self:
         self.text_speed = speed
         return self
 
-    def cut_text_to_width(self,text:str)->list[str]:
-        if text == '' or self.get_content_width() < 1 or not self._font_object : return ['']
-        
+    def cut_text_to_width(self, text: str) -> list[str]:
+        w = self.get_padded_width()
+        if text == "" or not self.font_object or  w < self.font_object.point_size:
+            return [text]
+        left = 0
         for index in range(len(text)):
+            width = self.font_object.size(text[left:index])[0]
             
-            width = self._font_object.size(text[:index])[0]
-            if width > self.get_content_width():
-                cut_point_start = index-1
-                cut_point_end = index-1
-                last_space = text.rfind(' ',0,cut_point_start)
-                if last_space != -1 : # space was found !:
-                    cut_point_start = last_space
-                    cut_point_end = last_space+1
-                    
+            if width > w:
+                cut_point_start = index - 1
+                cut_point_end = index - 1
+                last_space = text.rfind(' ', 0, cut_point_start)
+                last_nline = text.rfind('\n', 0, cut_point_start)
+
+                if last_space != -1 or last_nline!= -1:  # space was found !:
+                    cut_point_start = max(last_space,last_nline)
+                    cut_point_end = cut_point_start + 1
                 res = [text[:cut_point_start].strip()]
-                res.extend(self.cut_text_to_width(text[cut_point_end:].strip()))  
-                return res 
-        return [text]  
-        
-    def say(self,message:str):
-        message = '\n'.join(self.cut_text_to_width(message))
-        self.message_queue.append(message)
+                res.extend(self.cut_text_to_width(text[cut_point_end:].strip()))
+                return res
+            elif text[index] == '\n':
+                left = index
+        return [text]
 
+    def paint(self)->None:
+        if self.font_object and self.message_queue :
+            message = self.message_queue.pop(0)
+            message = "\n".join(self.cut_text_to_width(message))
+            self.message_queue.insert(0,message)
+        super().paint()
+ 
+    def say(self, message: str) ->Self:
+        self.message_queue.append(message)
         self.is_over = False
-
-    def is_queue_empty(self)->bool:
+        return self
+    
+    def is_queue_empty(self) -> bool:
         return not self.message_queue
 
-    def is_current_message_over(self)->bool:
+    def is_current_message_over(self) -> bool:
         return self.is_over
 
-    def clear_queue(self)->None:
+    def clear_queue(self) -> Self:
         self.message_queue.clear()
         self.next_message()
+        return self
 
-    def next_message(self)->None:
+    def next_message(self) -> Self:
         if self.message_queue:
             self.message_queue.pop(0)
         self.cursor_position = 0
         self.set_text("")
+        return self
+
+    def skip_current_message(self)->Self:
+        self.cursor_position = len(self.message_queue[0])
+        self.dirty_shape = True
 
-    def do_update(self,dt):
-        if not self.message_queue : return
+    def do_update(self, dt):
+        if not self.message_queue or self.is_paused:
+            return
         if not self.is_over and self.cursor_position == len(self.message_queue[0]):
-            self.is_over = True 
-        else:
-            self.cursor_position = min(
-                self.cursor_position +  self.text_speed * dt,
-                len(self.message_queue[0])
-            )
-            self.set_text(self.message_queue[0][:int(self.cursor_position)])
-            
+            self.is_over = True
+            return
+        self.cursor_position = min(
+            self.cursor_position + self.text_speed * dt, len(self.message_queue[0])
+        )
+        self.set_text(self.message_queue[0][: int(self.cursor_position)])

batFramework/gui/draggableWidget.py

@@ -0,0 +1,38 @@
+from .interactiveWidget import InteractiveWidget
+import batFramework as bf
+import pygame
+
+
+class DraggableWidget(InteractiveWidget):
+    def __init__(self, *args, **kwargs) -> None:
+        self.drag_action = bf.Action("dragging").add_mouse_control(1).set_holding()
+
+        self.drag_start = None
+        self.offset = None
+        super().__init__(*args, **kwargs)
+
+    def do_process_actions(self, event: pygame.Event) -> None:
+        self.drag_action.process_event(event)
+
+    def do_reset_actions(self) -> None:
+        self.drag_action.reset()
+
+    def do_on_drag(self,drag_start:tuple[float,float],drag_end: tuple[float,float])->None:
+        self.set_position(drag_end[0]-self.offset[0],drag_end[1]-self.offset[1])
+
+    def update(self, dt: float):
+        if self.drag_action.active and self.is_clicked_down:
+            r = self.get_root()
+            x, y = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
+            if self.drag_start == None and self.drag_action.active:
+                self.offset = x-self.rect.x,y-self.rect.y
+                self.drag_start = x,y
+                return
+            else:
+                self.do_on_drag(self.drag_start,(x,y))
+                return
+        else:
+            self.drag_start = None
+            self.offset = None
+            self.is_clicked_down = False
+        super().update(dt)

batFramework/gui/image.py

@@ -1,42 +1,47 @@
 import batFramework as bf
 from .widget import Widget
 import pygame
+from typing import Self
 
 
 class Image(Widget):
     def __init__(
         self,
-        data: pygame.Surface | str | None = None,
-        size: None | tuple[int, int] = None,
+        path: str = None,
         convert_alpha=True,
     ):
-        self.dirty : bool = False
         self.original_surface = None
-        self.surface = None
-        super().__init__(convert_alpha)
-        if data:
-            self.set_image(data,size)
+        super().__init__(convert_alpha = convert_alpha)
+        if path is not None:
+            self.from_path(path)
 
-    def build(self) -> None:
-        if self.original_surface and (
-            (not self.surface or self.surface.get_size() != self.get_size_int()) 
-            or self.dirty
-        ) :
-            self.surface = pygame.transform.scale(
-                self.original_surface, self.get_size_int()
-            )
+    def paint(self) -> None:
+        super().paint()
+        self.surface.fill((0,0,0,0 if self.convert_alpha else 255))
+        if self.rect.size != self.original_surface.get_size():
+            self.surface.blit(pygame.transform.scale(self.original_surface,self.rect.size),(0,0))
+        else:
+            self.surface.blit(self.original_surface,(0,0))
 
-    def set_image(
-        self, data: pygame.Surface | str, size: None | tuple[int, int] = None
-    ):
-        if isinstance(data, str):
-            tmp = bf.ResourceManager().get_image(data,self.convert_alpha)
-        elif isinstance(data, pygame.Surface):
-            tmp= data
-            if self.convert_alpha:
-                tmp = tmp.convert_alpha()
-        if tmp != self.original_surface: self.dirty = True
+
+    def from_path(self,path:str)->Self:
+        tmp = bf.ResourceManager().get_image(path,self.convert_alpha)
+        if tmp is None:
+            return self
         self.original_surface = tmp
-        if not size and self.original_surface:
-            size = self.original_surface.get_size()
-        self.set_size(*size)
+        size = self.original_surface.get_size()
+        if not self.autoresize_h : size[0] = None
+        if not self.autoresize_h : size[1] = None
+        self.set_size(size)
+        self.dirty_surface = True
+        return self
+
+    def from_surface(self,surface: pygame.Surface)->Self:
+        if surface is None : return self
+        self.original_surface = surface
+        size = self.original_surface.get_size()
+        if not self.autoresize_h : size[0] = None
+        if not self.autoresize_h : size[1] = None
+        self.set_size(size)
+        self.dirty_surface = True
+        return self

batFramework/gui/indicator.py

@@ -1,13 +1,18 @@
 from .shape import Shape
-from typing import Any
+from typing import Any, Self
 import pygame
-
-# from .constraints import ConstraintAspectRatio
+from .widget import Widget
+from .interactiveWidget import InteractiveWidget
+from .draggableWidget import DraggableWidget
+import batFramework as bf
 
 
 class Indicator(Shape):
-    def __init__(self, width: int | float = 10, height: int | float = 10) -> None:
-        super().__init__(width, height)
+    def __init__(self, size: tuple[int | float] = (10, 10)) -> None:
+        super().__init__(size)
+        self.debug_color = "magenta"
+        self.set_outline_width(1)
+        self.set_outline_color("black")
 
     def to_string_id(self) -> str:
         return "Indicator"
@@ -18,29 +23,38 @@ class Indicator(Shape):
     def get_value(self) -> Any:
         pass
 
-    def _build_indicator(self) -> None:
-        pass
 
-    def build(self) -> None:
-        super().build()
-        self._build_indicator()
+    def top_at(self, x, y):
+        return None
 
 
 class ToggleIndicator(Indicator):
     def __init__(self, default_value: bool) -> None:
         self.value: bool = default_value
-        super().__init__(20, 20)
+        self.callback = lambda val : self.set_color("green" if val else "red")
+        super().__init__((20, 20))
+        self.set_value(default_value)
 
-        #TODO aspect ratio would be good right about here
+        # TODO aspect ratio would be good right about here
         # self.add_constraint(ConstraintAspectRatio(1))
 
-    def set_value(self, value) -> None:
+    def set_callback(self, callback) -> Self:
+        self.callback = callback
+        return self
+
+    def set_value(self, value: bool) -> None:
         self.value = value
-        self.set_color("green" if value else "red")
-        self.build()
+        if self.callback:
+            self.callback(value)
+        self.dirty_surface = True
 
     def get_value(self) -> bool:
         return self.value
 
     def top_at(self, x: float, y: float) -> "None|Widget":
-        return None
+        r = super().top_at(x, y)
+        if r is self:
+            return None
+        return r
+
+