batframework 1.0.9a11__py3-none-any.whl → 1.1.0__py3-none-any.whl

batFramework/gui/root.py

@@ -2,227 +2,59 @@ import batFramework as bf
 from .interactiveWidget import InteractiveWidget
 from .widget import Widget
 import pygame
-from typing import Self
-import sys
-
 
 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.clip_children = False
-        self.set_debug_color("yellow")
-
-        self.show_tooltip : bool = True
-        self.tooltip = bf.gui.ToolTip("").set_visible(False)
-        self.add(self.tooltip)
-
-    def toggle_tooltip(self,value:bool)->Self:
-        self.show_tooltip = value
-        return self
-    
-    def __str__(self) -> str:
-        return "Root"
-    
-    def to_ascii_tree(self) -> str:
-        def f(w, depth):
-            prefix = " " * (depth * 4) + ("└── " if depth > 0 else "")
-            children = "\n".join(f(c, depth + 1) for c in w.children) if w.children else ""
-            return f"{prefix}{str(w)}\n{children}"
-        return f(self, 0)
+        self.focused : InteractiveWidget = self
+        self.hovered : Widget|None = self
+        self.set_debug_color("purple")
 
-    def set_parent_scene(self, parent_scene: bf.Scene) -> Self:
-        return super().set_parent_scene(parent_scene)
+    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 get_debug_outlines(self):
-        yield (self.rect, self.debug_color)
-        for child in self.children:
-            yield from child.get_debug_outlines()
-
-    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 focus_next_tab(self, widget):
-        return
-
-    def focus_prev_tab(self, widget):
-        return
-
-    def get_by_uid(self, uid: int) -> "Widget":
-        def helper(w: "Widget", uid: int) -> "Widget":
-            if w.uid == uid:
-                return w
-            for child in w.children:
-                res = helper(child, uid)
-                if res is not None:
-                    return res
-            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.dirty_shape = True
-        self.dirty_size_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 process_event(self,event):
-        if not event.consumed : self.do_handle_event_early(event)
-        if not event.consumed : super().process_event(event)
         
-    def do_handle_event_early(self, event):
-        if event.type == pygame.VIDEORESIZE and not pygame.SCALED & bf.const.FLAGS:
-            self.set_size((event.w,event.h),force=True)
-        if self.focused:
-            if event.type == pygame.KEYDOWN:
-                event.consumed = self.focused.on_key_down(event.key)
-                if not event.consumed : 
-                    event.consumed = self._handle_alt_tab(event.key)
-            elif event.type == pygame.KEYUP:
-                event.consumed = self.focused.on_key_up(event.key)
-
-        if not self.hovered or (not isinstance(self.hovered, InteractiveWidget)):
-            event.consumed = True
-            return
-
-        if event.type == pygame.MOUSEBUTTONDOWN:
-            event.consumed = self.hovered.on_click_down(event.button)
-
-        elif event.type == pygame.MOUSEBUTTONUP:
-            event.consumed = 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 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:
+    def update(self,dt:float)->None:
         super().update(dt)
-        self.update_tree()
-
-        mouse_screen = pygame.mouse.get_pos()
-        mouse_world = self.drawing_camera.screen_to_world(mouse_screen)
-        prev_hovered = self.hovered
-        self.hovered = self.top_at(*mouse_world) or None
-
-        # Tooltip logic
-        if self.hovered and self.hovered.tooltip_text:
-            self.tooltip.set_text(self.hovered.tooltip_text)
-
-            tooltip_size = self.tooltip.get_min_required_size()
-            screen_w, screen_h = self.drawing_camera.rect.size
-            tooltip_x, tooltip_y = self.drawing_camera.world_to_screen_point(mouse_world)
-
-            tooltip_x = min(tooltip_x, screen_w - tooltip_size[0])
-            tooltip_y = min(tooltip_y, screen_h - tooltip_size[1])
-            tooltip_x = max(0, tooltip_x)
-            tooltip_y = max(0, tooltip_y)
-
-            self.tooltip.set_position(tooltip_x, tooltip_y)
-            self.tooltip.fade_in()
-        else:
-            self.tooltip.fade_out()
-
-        if self.hovered == prev_hovered:
-            if isinstance(self.hovered, InteractiveWidget):
-                self.hovered.on_mouse_motion(*mouse_world)
-            return
-
-        if isinstance(prev_hovered, InteractiveWidget):
-            prev_hovered.on_exit()
-        if isinstance(self.hovered, InteractiveWidget):
-            self.hovered.on_enter()
-
-
-    def _handle_alt_tab(self,key):
-        if self.focused is None:
-            return False
-        if key != pygame.K_TAB:
-            return False
-        keys = pygame.key.get_pressed()
-        if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
-            self.focused.focus_prev_tab(self.focused)
-        else:
-            self.focused.focus_next_tab(self.focused)
-        return True
-
-    def update_tree(self):
-        # print("START updating tree")
-        self.apply_updates("pre")
-        self.apply_updates("post")
-
-        self.apply_updates("pre")
-        self.apply_updates("post")
-
-        # print("END updating tree")
-
-    def apply_pre_updates(self):
-        return 
+        self.hovered = self.top_at(*pygame.mouse.get_pos()) if self.top_at(*pygame.mouse.get_pos()) else None
+        
 
-    def apply_post_updates(self, skip_draw = False):
-        return
 
-    def draw(self, camera: bf.Camera) -> None:
-        super().draw(camera)
-        if (
-            self.parent_scene
-            and self.parent_scene.active
-            and self.focused
-            and self.focused != self
-        ):
-            clip:bool =self.focused.parent and self.focused.parent.clip_children
-            if clip:
-                old_clip = camera.surface.get_clip()
-                camera.surface.set_clip(camera.world_to_screen(self.focused.parent.rect))    
-            if clip:
-                camera.surface.set_clip(old_clip)
-            self.focused.draw_focused(camera)   
+        

batFramework/gui/shape.py

@@ -1,276 +1,86 @@
 import batFramework as bf
 from .widget import Widget
 import pygame
-from typing import Self, Iterable
-from math import ceil
 
 
 class Shape(Widget):
-    def __init__(self, size: tuple[float, float] = None, *args, **kwargs):
-        super().__init__(size=size, convert_alpha=True)
-        self.color = (0, 0, 0, 0)
-        self.border_radius: list[int] = [0]
-        self.outline_width: int = 0
-        self.outline_color: tuple[int, int, int] | str = (0, 0, 0, 255)
-        self.texture_surface = None
-        self.texture_subsize = (0, 0)
-        self.relief = 0
-        self.shadow_color: tuple[int, int, int] | str = (0, 0, 0, 255)
-        self.draw_mode = bf.drawMode.SOLID
+    def __init__(self,width:float,height:float):
+        self._color = (0,0,0,0)
+        self._border_radius:list[int] = [0] 
+        self._outline : int = 0 
+        self._outline_color : tuple[int,int,int] | str = (0,0,0,0) 
+        super().__init__(convert_alpha = True)
+        self.set_size(width,height)
 
-    def get_inner_bottom(self) -> float:
-        return self.rect.bottom - self.padding[3] - self.relief
 
-    def get_inner_height(self) -> float:
-        return self.rect.h - self.padding[1] - self.padding[3] - self.relief
-
-    def get_inner_top(self) -> float:
-        return self.rect.y + self.padding[1]
-
-    def get_local_inner_rect(self)->pygame.FRect:
-        return pygame.FRect(
-            self.padding[0],
-            self.padding[1],
-            self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.padding[1] - self.padding[3] - self.relief,
-        )
-
-    def get_inner_rect(self) -> pygame.FRect:
-        return pygame.FRect(
-            self.rect.x + self.padding[0],
-            self.rect.y + self.padding[1],
-            self.rect.w - self.padding[2] - self.padding[0],
-            self.rect.h - self.padding[1] - self.padding[3] - self.relief,
-        )
-
-    def set_shadow_color(self, color: tuple[int, int, int] | str) -> Self:
-        self.shadow_color = color
-        self.dirty_surface = True
-        return self
-
-    def set_relief(self, relief: int) -> Self:
-        if relief < 0:
-            return self
-        self.dirty_shape = self.relief != relief
-        self.relief = relief
-        return self
-
-
-
-    def set_texture(
-        self, surface: pygame.SurfaceType, subsize: tuple[int, int] | None = None
-    ) -> Self:
-        self.texture_surface = surface
-        if subsize is None:
-            subsize = (ceil(surface.get_width() / 3), ceil(surface.get_height() / 3))
-        self.texture_subsize = subsize
-        self.dirty_surface = True
-        return self
-
-    def set_draw_mode(self, mode: bf.drawMode) -> Self:
-        self.draw_mode = mode
-        self.dirty_surface = True
-        return self
-
-    def get_draw_mode(self) -> bf.drawMode:
-        return self.draw_mode
-
-    def has_alpha_color(self) -> bool:
-        return (pygame.Color(self.color).a != 255) or (
-            pygame.Color(self.outline_color).a != 255
-        )
-
-    def __str__(self) -> str:
+    def to_string_id(self)->str:
         return "Shape"
 
-    def set_color(self, color: tuple[int, int, int] | str) -> Self:
-        self.color = color
-        self.dirty_surface = True
+    def set_color(self,color:tuple[int,int,int]|str) -> "Frame":
+        self._color = color
+        self.build()
         return self
 
-    def set_outline_color(self, color: tuple[int, int, int] | str) -> Self:
-        self.outline_color = color
-        self.dirty_surface = True
+    def set_outline_color(self,color:tuple[int,int,int]|str) -> "Frame":
+        self._outline_color = color
+        self.build()
         return self
 
-    def set_border_radius(self, value: int | list[int]) -> Self:
-        if isinstance(value, int):
-            self.border_radius = [value]
+    def set_border_radius(self,value:int|list[int]) -> "Frame":
+        if isinstance(value,int):
+            self._border_radius = [value]
         else:
-            self.border_radius = value
-        self.dirty_surface = True
+            self._border_radius = value
+        self.build()
         return self
-
-    def set_outline_width(self, value: int) -> Self:
-        self.outline_width = value
-        self.dirty_surface = True
+        
+    def set_outline_width(self,value:int) -> "Frame":
+        self._outline = value
+        self.build()
         return self
-
-    def paint(self) -> None:
-        if self.draw_mode == bf.drawMode.TEXTURED:
-            self._paint_textured()
-            return
-        if self.border_radius == [0]:
-            self._paint_shape()
-            if self.outline_width:
-                self._paint_outline()
+        
+    def build(self)->None:
+        if self.surface.get_size() != self.get_size_int():
+            self.surface = pygame.Surface(self.get_size_int())
+            if self.convert_alpha :
+                self.surface = self.surface.convert_alpha()
+                self.surface.fill((0,0,0,0))
+            if self.parent :
+                self.parent.children_modified()
+        if self._border_radius == [0]:
+            self._build_shape()    
+            if self._outline : self._build_outline()
         else:
-            self._paint_rounded_shape()
-            if self.outline_width:
-                self._paint_rounded_outline()
+            self._build_rounded_shape()
+            if self._outline : self._build_rounded_outline()
 
-    def _paint_textured(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        if self.texture_surface is None:
-            return
-        w, h = self.surface.get_size()
-        sw, sh = self.texture_surface.get_size()
-        sub = self.texture_subsize
 
-        # center
-        center_surface = self.texture_surface.subsurface((sub[0], sub[1], *sub))
-        top_surface = self.texture_surface.subsurface((sub[0], 0, *sub))
-        bottom_surface = self.texture_surface.subsurface((sub[0], sh - sub[1], *sub))
-        left_surface = self.texture_surface.subsurface((0, sub[1], *sub))
-        right_surface = self.texture_surface.subsurface((sw - sub[0], sub[1], *sub))
+    def _build_shape(self)->None:
+        self.surface.fill(self._color)
 
-        lst = []
-        for y in range(sub[1], h + 1 - sub[1] * 2, sub[1]):
-            for x in range(sub[0], w + 1 - sub[0] * 2, sub[0]):
-                lst.append((center_surface, (x, y)))
-
-        w_remainder = w % sub[0]
-        h_remainder = h % sub[1]
-        fix_x = ((w // sub[0]) - 1) * sub[0]
-        fix_y = ((h // sub[1]) - 1) * sub[1]
-
-        if (w > sub[0]) and (w_remainder > 0):
-            # Center : Fix gaps on the x axis
-            h_portion = center_surface.subsurface(0, 0, w_remainder, sub[1])
-            for y in range(sub[1], h - sub[1] * 2, sub[1]):
-                lst.append((h_portion, (fix_x, y)))
-
-            # Fix partial gaps on the top
-
-            t_portion = top_surface.subsurface(0, 0, w_remainder, sub[1])
-            lst.append((t_portion, (fix_x, 0)))
-
-            # Fix partial gaps on the bottom
-            b_portion = bottom_surface.subsurface(0, 0, w_remainder, sub[1])
-            lst.append((b_portion, (fix_x, h - sub[1] - 1)))
-
-        if (h > sub[1]) and (h_remainder > 0):
-            # Center : Fix gaps on the y axis
-            v_portion = center_surface.subsurface(0, 0, sub[0], h_remainder)
-            for x in range(sub[0], w - sub[0] * 2, sub[0]):
-                lst.append((v_portion, (x, fix_y)))
-
-            # Fix partial gaps on the left
-            l_portion = left_surface.subsurface(0, 0, sub[0], h_remainder)
-            lst.append((l_portion, (0, fix_y)))
-
-            # Fix partial gaps on the right
-            r_portion = right_surface.subsurface(0, 0, sub[0], h_remainder)
-            lst.append((r_portion, (w - sub[0] - 1, fix_y)))
-
-        # fix corner gap
-        if h > sub[1] or w > sub[0]:
-            corner_portion = center_surface.subsurface(
-                0,
-                0,
-                w_remainder if w_remainder else sub[0],
-                h_remainder if h_remainder else sub[1],
-            )
-            if w_remainder == 0:
-                fix_x -= sub[0]
-            if h_remainder == 0:
-                fix_y -= sub[1]
-            lst.append((corner_portion, (fix_x - 1, fix_y - 1)))
-
-        # borders
-        lst.extend(
-            [(top_surface, (x, 0)) for x in range(sub[0], w + 1 - sub[0] * 2, sub[0])]
-            + [
-                (bottom_surface, (x, h - sub[1] - 1))
-                for x in range(sub[0], w + 1 - sub[0] * 2, sub[0])
-            ]
-            + [
-                (left_surface, (0, y))
-                for y in range(sub[1], h + 1 - sub[1] * 2, sub[1])
-            ]
-            + [
-                (right_surface, (w - sub[0] - 1, y))
-                for y in range(sub[1], h + 1 - sub[1] * 2, sub[1])
-            ]
-            + [
-                (self.texture_surface.subsurface((0, 0, *sub)), (0, 0)),
-                (
-                    self.texture_surface.subsurface((sw - sub[0], 0, *sub)),
-                    (w - sub[0] - 1, 0),
-                ),
-                (
-                    self.texture_surface.subsurface((0, sh - sub[1], *sub)),
-                    (0, h - sub[1] - 1),
-                ),
-                (
-                    self.texture_surface.subsurface((sw - sub[0], sh - sub[1], *sub)),
-                    (w - sub[0] - 1, h - sub[1] - 1),
-                ),
-            ]
+    def _build_rounded_shape(self)->None:
+        self.surface.fill((0,0,0,0))
+        pygame.draw.rect(
+            self.surface,
+            self._color,
+            (0,0,*self.rect.size),
+            0,
+            *self._border_radius
         )
 
-        self.surface.fblits(lst)
-
-    def _get_elevated_rect(self) -> pygame.FRect:
-        return pygame.FRect(0, 0, self.rect.w, self.rect.h - self.relief)
-
-    def _get_base_rect(self) -> pygame.FRect:
-        return pygame.FRect(0, self.rect.h - self.relief, self.rect.w, self.relief)
-
-    def _paint_shape(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        if self.relief!=0:
-            self.surface.fill(self.shadow_color, self._get_base_rect())
-            self.surface.fill(self.color, self._get_elevated_rect())
-        else:
-            self.surface.fill(self.color, self._get_elevated_rect())
-
-    def _paint_rounded_shape(self) -> None:
-        self.surface.fill((0, 0, 0, 0))
-        e = self._get_elevated_rect()
-        if self.relief != 0:
-            b = e.copy()
-            b.bottom = self.rect.h
-            pygame.draw.rect(self.surface, self.shadow_color, b, 0, *self.border_radius)
-            pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
-        else:
-            pygame.draw.rect(self.surface, self.color, e, 0, *self.border_radius)
-
-    def _paint_outline(self) -> None:
+    def _build_outline(self)->None:
         pygame.draw.rect(
             self.surface,
-            self.outline_color,
-            self._get_elevated_rect(),
-            self.outline_width,
+            self._outline_color,
+            (0,0,*self.rect.size),
+            self._outline
         )
-
-    def _paint_rounded_outline(self) -> None:
-        e = self._get_elevated_rect()
-        b = e.copy()
-        b.h += e.bottom - b.bottom
-
+    
+    def _build_rounded_outline(self)->None:
         pygame.draw.rect(
             self.surface,
-            self.outline_color,
-            e,
-            self.outline_width,
-            *self.border_radius,
+            self._outline_color,
+            (0,0,*self.rect.size),
+            self._outline,
+            *self._border_radius
         )
-        if self.relief:
-            pygame.draw.rect(
-                self.surface,
-                self.outline_color,
-                b,
-                self.outline_width,
-                *self.border_radius,
-            )