batframework 1.0.8a1__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/gui/layout.py

@@ -1,168 +1,81 @@
 import batFramework as bf
 from .widget import Widget
-from .constraints.constraints import *
-from typing import Self,TYPE_CHECKING
-import pygame
-
-if TYPE_CHECKING:
-    from .container import Container
+from .constraints import *
+from typing import Self
 
 class Layout:
-    def __init__(self, parent: "Container" = None):
+    def __init__(self, parent: Widget=None):
         self.parent = parent
-        self.child_constraints: list[Constraint] = []
-        self.children_rect = pygame.FRect(0, 0, 0, 0)
-
-    def set_child_constraints(self, *constraints) -> Self:
-        self.child_constraints = list(constraints)
-        self.notify_parent()
+        self.child_constraints : list[Constraint] = []
+        
+    def set_child_constraints(self,*constraints)->Self:
+        self.child_constraints = constraints
+        self.arrange()
         return self
-
-    def set_parent(self, parent: Widget):
+        
+    def set_parent(self,parent:Widget):
         self.parent = parent
-        self.notify_parent()
-
-    def notify_parent(self) -> None:
-        if self.parent:self.parent.dirty_children = True
-
-    def arrange(self) -> None:
-        return
-
-    def clamp_scroll(self)->None:
-        return
-
-    def get_raw_size(self)->tuple[float,float]:
-        return self.parent.rect.size if self.parent else 0,0
-
-    def get_auto_size(self)->tuple[float,float]:
-        return self.parent.rect.size if self.parent else 0,0
-
-    def focus_next_child(self)->None:
-        l = self.parent.get_interactive_children()
-        self.parent.focused_index = min(self.parent.focused_index + 1, len(l) - 1)
-        focused = l[self.parent.focused_index]
-        focused.get_focus()
-        self.scroll_to_widget(focused)
-
-    def focus_prev_child(self)->None:
-        l = self.parent.get_interactive_children()
-        self.parent.focused_index = max(self.parent.focused_index - 1, 0)
-        focused = l[self.parent.focused_index]
-        focused.get_focus()
-        self.scroll_to_widget(focused)
-
-    def scroll_to_widget(self,widget:Widget)->None:
-        padded = self.parent.get_padded_rect()
-        r = widget.rect
-        if padded.contains(r):return
-        clamped = r.clamp(padded)
-        dx,dy = clamped.move(-r.x,-r.y).topleft
-        self.parent.scroll_by((-dx,-dy))
-
+        self.arrange()
 
+    def arrange(self)->None:
+        raise NotImplementedError("Subclasses must implement arrange  method")
 
 class Column(Layout):
-    def __init__(self, gap: int = 0,spacing:bf.spacing = bf.spacing.MANUAL):
+    def __init__(self,gap:int=0,shrink:bool=False):
         super().__init__()
         self.gap = gap
-        self.spacing = spacing
-
-    def set_gap(self, value: float) -> Self:
-        self.gap = value
-        self.notify_parent()
-        return self
-    
-    def set_spacing(self,spacing: bf.spacing)->Self:
-        self.spacing = spacing
-        self.notify_parent()
-        return self
-
-    def get_raw_size(self)-> tuple[float,float]:
-        len_children = len(self.parent.children)
-        if not len_children : return self.parent.rect.size 
-        parent_height = sum(c.get_min_required_size()[1] for c in self.parent.children)
-        parent_width = max(c.get_min_required_size()[0] for c in self.parent.children)
-        if self.gap:
-            parent_height += (len_children - 1) * self.gap
-        target_rect = self.parent.inflate_rect_by_padding((0,0,parent_width,parent_height))
-        return target_rect.size
-    
-    def get_auto_size(self)-> tuple[float,float]:
-        target_size = list(self.get_raw_size())
-        if not self.parent.autoresize_w : target_size[0] = self.parent.rect.w
-        if not self.parent.autoresize_h : target_size[1] = self.parent.rect.h
-        return target_size
-
-    def arrange(self) -> None:
-        if not self.parent or not self.parent.children:
-            return
-        if self.child_constraints :  
-            for child in self.parent.children : child.add_constraints(*self.child_constraints)
-        self.child_rect = self.parent.get_padded_rect()
-
-        if self.parent.autoresize_w or self.parent.autoresize_h:
-            width,height = self.get_auto_size()
-            if self.parent.rect.size != (width,height):
-                self.parent.set_size((width,height))
-                self.parent.build()
-                self.arrange()
-                return
-        self.child_rect.move_ip(-self.parent.scroll.x,-self.parent.scroll.y)
-        y = self.child_rect.top
-        for child in self.parent.children :
-            child.set_position(self.child_rect.x,y)
-            y+= child.get_min_required_size()[1] + self.gap
+        self.shrink :bool = shrink
+        
+    def arrange(self)->None:
+        if not self.parent or not self.parent.children : return 
+        if self.shrink:
+            len_children = len(self.parent.children)
+            parent_height = sum(c.rect.h for c in self.parent.children)
+            parent_width = max(c.rect.w for c in self.parent.children)
+            if self.gap  : parent_height += (len_children-1) * self.gap
+            # print(self.parent.to_string(),len_children,parent_height)
+            c = self.parent.get_constraint("height")
+            if not c or c.height != parent_height : 
+                self.parent.add_constraint(ConstraintHeight(parent_height))
+            c = self.parent.get_constraint("width")
+            if not c or c.width != parent_width : 
+                self.parent.add_constraint(ConstraintWidth(parent_width))
+        current_y = self.parent.rect.top
 
+        for child in self.parent.children:
+            child.set_position(self.parent.rect.x,current_y)
+            current_y += child.rect.h + self.gap
+            for c in self.child_constraints:
+                if not child.has_constraint(c.name):
+                    child.add_constraint(c)
+            
 class Row(Layout):
-    def __init__(self, gap: int = 0,spacing: bf.spacing=bf.spacing.MANUAL):
+    def __init__(self, gap: int = 0, shrink: bool = False):
         super().__init__()
         self.gap = gap
-        self.spacing = spacing
-
-    def set_gap(self, value: float) -> Self:
-        self.gap = value
-        self.notify_parent()
-        return self
-    
-    def set_spacing(self,spacing: bf.spacing)->Self:
-        self.spacing = spacing
-        self.notify_parent()
-        return self
-
-
-    def get_raw_size(self) -> tuple[float, float]:
-        len_children = len(self.parent.children)
-        if not len_children: return self.parent.rect.size
-        parent_width = sum(c.get_min_required_size()[0] for c in self.parent.children)
-        parent_height = max(c.get_min_required_size()[1] for c in self.parent.children)
-        if self.gap:
-            parent_width += (len_children - 1) * self.gap
-        target_rect = self.parent.inflate_rect_by_padding((0, 0, parent_width, parent_height))
-
-        return target_rect.size
-
-    def get_auto_size(self) -> tuple[float, float]:
-        target_size = list(self.get_raw_size())
-        if not self.parent.autoresize_w: target_size[0] = self.parent.rect.w
-        if not self.parent.autoresize_h: target_size[1] = self.parent.rect.h
-        return target_size
+        self.shrink = shrink
 
     def arrange(self) -> None:
-        if not self.parent or not self.parent.children:
+        if not self.parent:
             return
-        if self.child_constraints:
-            for child in self.parent.children: child.add_constraints(*self.child_constraints)
-        self.child_rect = self.parent.get_padded_rect()
-
-        if self.parent.autoresize_w or self.parent.autoresize_h:
-            width, height = self.get_auto_size()
-            if self.parent.rect.size != (width, height):
-                self.parent.set_size((width, height))
-                self.parent.build()
-                self.arrange()
-                return
-        self.child_rect.move_ip(-self.parent.scroll.x, -self.parent.scroll.y)
-        x = self.child_rect.left
+        if self.shrink and self.parent.children:
+            len_children = len(self.parent.children)
+            parent_width = sum(c.rect.w for c in self.parent.children)
+            parent_height = max(c.rect.h for c in self.parent.children)
+            if self.gap:
+                parent_width += (len_children - 1) * self.gap
+
+            c = self.parent.get_constraint("width")
+            if not c or c.width != parent_width:
+                self.parent.add_constraint(ConstraintWidth(parent_width))
+            c = self.parent.get_constraint("height")
+            if not c or c.height != parent_height:
+                self.parent.add_constraint(ConstraintHeight(parent_height))
+
+        current_x = self.parent.rect.left
         for child in self.parent.children:
-            child.set_position(x, self.child_rect.y)
-            x += child.get_min_required_size()[0] + self.gap
+            child.set_position(current_x,self.parent.rect.y)
+            current_x += child.rect.w + self.gap
+            for c in self.child_constraints:
+                if not child.has_constraint(c.name):
+                    child.add_constraint(c)

batFramework/gui/root.py

@@ -3,123 +3,58 @@ from .interactiveWidget import InteractiveWidget
 from .widget import Widget
 import pygame
 
-
 class Root(InteractiveWidget):
-    def __init__(self, camera) -> None:
+    def __init__(self):
         super().__init__()
-        self.is_root = True
-        self.drawing_camera: bf.Camera = camera
-        self.visible = False
+        self.surface = None
+        self.set_root()
         self.rect.size = pygame.display.get_surface().get_size()
-        self.focused: InteractiveWidget | None = self
-        self.hovered: Widget | None = self
-        self.set_debug_color("yellow")
-        self.set_render_order(999)
-        self.clip_children = False
+        self.focused : InteractiveWidget = self
+        self.hovered : Widget|None = self
+        self.set_debug_color("purple")
 
-    def __str__(self) -> str:
-        return "Root"
+    def to_string(self)->str:
+         return "ROOT"
 
-    def get_focused(self) -> Widget | None:
+    def get_focused(self)->Widget|None:
         return self.focused
 
-    def get_hovered(self) -> Widget | None:
+    def get_hovered(self)->Widget|None:
         return self.hovered
+         
+    def to_string_id(self)->str:
+        return "ROOT"
 
-    def clear_focused(self) -> None:
-        self.focus_on(None)
-
-    def clear_hovered(self) -> None:
-        if isinstance(self.hovered, InteractiveWidget):
-            self.hovered.on_exit()
-        self.hovered = None
-
-    def focus_on(self, widget: InteractiveWidget | None) -> None:
-        if widget == self.focused : return
-        if widget and not widget.allow_focus_to_self():
-            return
-        if self.focused is not None:
+    def focus_on(self,widget:InteractiveWidget)->None:
+        if self.focused is not None: 
             self.focused.on_lose_focus()
-        if widget is None:
+        if widget is None :
             self.focused = self
             return
-        self.focused = widget
+        self.focused= widget
         self.focused.on_get_focus()
 
-    def get_by_tags(self,*tags)->list[Widget]:
-        res = []
-        def getter(w:Widget):
-            nonlocal res
-            if any(t in w.tags for t in tags):
-                res.append(w)
-        self.visit(getter)
-        return res
-
-    def get_by_uid(self,uid:int)->Widget:
-        def helper(w: Widget,uid):
-            if w.uid == uid:
-                return w
-            for child in w.children:
-                res = helper(child,uid)
-                if res : 
-                    return child
-                
-            return None
-        return helper(self,uid)
-
-    def set_size(self, size: tuple[float, float], force: bool = False) -> "Root":
-        if not force:
-            return self
-        self.rect.size = size
-        # self.build(resolve_constraints=True)
+    def set_size(self,width:float,height:float,force:bool=False)->"Root":
+        if not force :  return self
+        self.rect.size = width,height
+        self.build(apply_constraints=True)
         return self
-
-
-    def do_handle_event(self, event):
-        # if event.type == pygame.VIDEORESIZE:
-        #     self.set_size(event.w, event.h, force=True)
-        #     return True
-        if self.focused:
-            if event.type == pygame.KEYDOWN:
-                self.focused.on_key_down(event.key)
-            if event.type == pygame.KEYUP:
-                self.focused.on_key_up(event.key)
-        elif not self.hovered or not isinstance(self.hovered, InteractiveWidget):
-            return
-        if event.type == pygame.MOUSEBUTTONDOWN:
-            self.hovered.on_click_down(event.button)
-        elif event.type == pygame.MOUSEBUTTONUP:
-            self.hovered.on_click_up(event.button)
-
-
-    def do_on_click_down(self, button: int) -> None:
-        if button == 1:
-            self.clear_focused()
-
-    def top_at(self, x: float | int, y: float | int) -> "None|Widget":
-        if self.children:
-            for child in reversed(self.children):
-                r = child.top_at(x, y)
-                if r is not None:
-                    return r
-        return self if self.rect.collidepoint(x, y) else None
-
-    def update(self, dt: float) -> None:
+        
+    def build(self,apply_constraints:bool=False)->None:
+        if apply_constraints : self.apply_all_constraints()
+        for child in self.children : 
+            child.build()
+    
+    def do_handle_event(self,event):
+        if event.type == pygame.VIDEORESIZE:
+            self.set_size(event.w,event.h,force=True)
+            return True
+        return False
+
+    def update(self,dt:float)->None:
         super().update(dt)
-        old = self.hovered
-        transposed = self.drawing_camera.screen_to_world(pygame.mouse.get_pos())
-        self.hovered = self.top_at(*transposed) if self.top_at(*transposed) else None
-        if old == self.hovered and isinstance(self.hovered, InteractiveWidget):
-            self.hovered.on_mouse_motion(*transposed)
-            return
-        if old and isinstance(old, InteractiveWidget):
-            old.on_exit()
-        if self.hovered and isinstance(self.hovered, InteractiveWidget):
-            self.hovered.on_enter()
-
-    def draw(self, camera: bf.Camera) -> int:
-        super().draw(camera)
-        if self.focused and self.focused!=self:
-            self.focused.draw_focused(camera)
+        self.hovered = self.top_at(*pygame.mouse.get_pos()) if self.top_at(*pygame.mouse.get_pos()) else None
+        
 
 
+