batframework 1.0.8a7__py3-none-any.whl → 1.0.8a8__py3-none-any.whl

batFramework/gui/image.py

@@ -1,59 +1,23 @@
 import batFramework as bf
 from .widget import Widget
-from .shape import Shape
 import pygame
-from typing import Self
-
-
-class Image(Shape):
-    def __init__(
-        self,
-        path: str = None,
-        convert_alpha=True,
-    ):
-        self.original_surface = None
-        super().__init__(convert_alpha=convert_alpha)
-        if path is not None:
-            self.from_path(path)
-
-    def __str__(self) -> str:
-        return "Image"
-
-    def paint(self) -> None:
-        super().paint()
-        if self.original_surface is None:
-            return
-        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
-        target_size = padded.size
-        if self.original_surface.get_size() != target_size:
-            self.surface.blit(pygame.transform.scale(self.original_surface, target_size), padded.topleft)
-        else:
-            self.surface.blit(self.original_surface, padded.topleft)
-
-    def build(self) -> None:
-        if self.original_surface is not None:
-            self.set_size_if_autoresize(
-                self.inflate_rect_by_padding((0,0,*self.original_surface.get_size())).size
-            )
-        super().build()
-
-
-    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
-        size = self.original_surface.get_size()
-        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()
-        self.set_size(size)
-
-        self.dirty_surface = True
-        return self
+class Image(Widget):
+	def __init__(self,data:pygame.Surface|str,size:None|tuple[int,int]=None,convert_alpha=True):
+		super().__init__(False)
+		self.surface = None
+		if isinstance(data,str):
+			path = bf.utils.get_path(data)
+			self.original_surface=pygame.image.load(path)
+		elif isinstance(data,pygame.Surface):
+			self.original_surface = data
+			
+		if convert_alpha:	self.original_surface = self.original_surface.convert_alpha()
+		if not size : size = self.original_surface.get_size()
+		self.set_size(*size)
+
+
+	def build(self)->None:
+		if not self.surface or self.surface.get_size() != self.get_size_int():
+			self.surface = pygame.transform.scale(self.original_surface,self.get_size_int())
+			
+            

batFramework/gui/indicator.py

@@ -1,57 +1,40 @@
 from .shape import Shape
-from typing import Any, Self
+from typing import Any
 import pygame
-from .widget import Widget
-from .interactiveWidget import InteractiveWidget
-from .draggableWidget import DraggableWidget
-import batFramework as bf
-
+# from .constraints import ConstraintAspectRatio
 
 class Indicator(Shape):
-    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 __init__(self,width:int|float= 10,height:int|float=10)->None:
+        super().__init__(width,height)
 
-    def to_string_id(self) -> str:
+    def to_string_id(self)->str:
         return "Indicator"
 
-    def set_value(self, value: Any) -> None:
+    def set_value(self,value:Any)->None:
         pass
 
-    def get_value(self) -> Any:
+    def get_value(self)->Any:
         pass
 
-    def top_at(self, x, y):
-        return None
+    def _build_indicator(self)->None:
+        pass
+    
+    def build(self)->None:
+        super().build()
+        self._build_indicator()
 
 
 class ToggleIndicator(Indicator):
-    def __init__(self, default_value: bool) -> None:
-        self.value: bool = default_value
-        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
+    def __init__(self,default_value:bool)->None:
+        self.value:bool = default_value
+        super().__init__(20,20)
         # self.add_constraint(ConstraintAspectRatio(1))
 
-    def set_callback(self, callback) -> Self:
-        self.callback = callback
-        return self
-
-    def set_value(self, value: bool) -> None:
+    def set_value(self,value)->None:
         self.value = value
-        if self.callback:
-            self.callback(value)
-        self.dirty_surface = True
+        self.set_color("green" if value else "red")
+        self.build()
 
-    def get_value(self) -> bool:
+    def get_value(self)->bool:
         return self.value
-
-    def top_at(self, x: float, y: float) -> "None|Widget":
-        r = super().top_at(x, y)
-        if r is self:
-            return None
-        return r
+# 

batFramework/gui/interactiveWidget.py

@@ -1,201 +1,22 @@
 from .widget import Widget
-from typing import Self
-from typing import TYPE_CHECKING
-import pygame
-from math import cos
-
-if TYPE_CHECKING:
-    from .container import Container
-import batFramework as bf
-
-def children_has_focus(widget):
-    if isinstance(widget,InteractiveWidget) and widget.is_focused:
-        return True
-    for child in widget.children:
-        if children_has_focus(child):
-            return True
-    return False
-
 
 class InteractiveWidget(Widget):
-    def __init__(self, *args, **kwargs) -> None:
-        self.is_focused: bool = False
-        self.is_hovered: bool = False
-        self.is_clicked_down: bool = False
-        self.focused_index = 0
+    def __init__(self,*args,**kwargs):
+        super().__init__(convert_alpha = True)
         self.focusable = True
-        super().__init__(*args, **kwargs)
-
-    def set_focusable(self, value: bool) -> Self:
-        self.focusable = value
-        return self
-
-    def allow_focus_to_self(self) -> bool:
-        return self.visible
+        self.is_focused : bool = False
 
-    def get_focus(self) -> bool:
-        if self.focusable and ((r := self.get_root()) is not None):
-            r.focus_on(self)
-            if self.parent and isinstance(self.parent, InteractiveWidget):
-                self.parent.set_focused_child(self)
-            return True
-        return False
+    def get_focus(self)->bool:
+        if self.parent is None or not self.focusable: return False
+        self.get_root().focus_on(self)
 
-    def lose_focus(self) -> bool:
-        if self.is_focused and ((r := self.get_root()) is not None):
-            r.focus_on(None)
-            return True
-        return False
-
-    def set_parent(self, parent: Widget) -> Self:
-        if parent is None and children_has_focus(self):
-            self.get_root().clear_focused()
-            # pass focus on
-
-        return super().set_parent(parent)
-
-    def on_get_focus(self) -> None:
+    def on_get_focus(self)->None:
         self.is_focused = True
-        self.do_on_get_focus()
 
-    def on_lose_focus(self) -> None:
+    def on_lose_focus(self)->None:
         self.is_focused = False
-        self.do_on_lose_focus()
-
-    def focus_next_tab(self, previous_widget):
-
-        if previous_widget != self and self.visible:
-            if (
-                isinstance(self, InteractiveWidget)
-                and not isinstance(self, bf.Container)
-                and self.allow_focus_to_self()
-            ):
-                self.focus_next_sibling()
-                return
-            i_children = [
-                c
-                for c in self.children
-                if isinstance(c, InteractiveWidget) and c.visible
-            ]
-            if i_children:
-                index = i_children.index(previous_widget)
-                if index < len(i_children) - 1:
-
-                    i_children[index + 1].get_focus()
-                    return
-
-        if self.parent:
-            self.parent.focus_next_tab(self)
-
-    def focus_prev_tab(self, previous_widget):
-        if previous_widget != self and self.visible:
-            if (
-                isinstance(self, InteractiveWidget)
-                and not isinstance(self, bf.Container)
-                and self.allow_focus_to_self()
-            ):
-                self.get_focus()
-                return
-            i_children = [
-                c
-                for c in self.children
-                if isinstance(c, InteractiveWidget) and c.visible
-            ]
-
-            if i_children:
-                index = i_children.index(previous_widget)
-                if index > 0:
-                    i_children[index - 1].get_focus()
-                    return
-
-        if self.parent:
-            self.parent.focus_prev_tab(self)
-
-    def focus_next_sibling(self) -> None:
-        if isinstance(self.parent, bf.Container):
-            self.parent.focus_next_child()
-
-    def focus_prev_sibling(self) -> None:
-        if isinstance(self.parent, bf.Container):
-            self.parent.focus_prev_child()
-
-    def on_key_down(self, key) -> bool:
-        if key == pygame.K_DOWN:
-            self.focus_next_sibling()
-        elif key == pygame.K_UP:
-            self.focus_prev_sibling()
-        elif key == pygame.K_TAB and self.parent:
-            keys = pygame.key.get_pressed()
-            if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
-
-                self.focus_prev_tab(self)
-            else:
-                self.focus_next_tab(self)
-
-        else:
-
-            return self.do_on_key_down(key)
-
-        return False
-
-    def on_key_up(self, key) -> bool:
-        return self.do_on_key_up(key)
-
-    def do_on_key_down(self, key) -> bool:
-        return False
-
-    def do_on_key_up(self, key) -> bool:
-        return False
-
-    def do_on_get_focus(self) -> None:
-        pass
-
-    def do_on_lose_focus(self) -> None:
-        pass
-
-    def on_click_down(self, button: int) -> bool:
-        self.is_clicked_down = True
-        return self.do_on_click_down(button)
-
-    def on_click_up(self, button: int) -> bool:
-        self.is_clicked_down = False
-        return self.do_on_click_up(button)
-
-    def do_on_click_down(self, button: int) -> bool:
-        return False
-
-    def do_on_click_up(self, button: int) -> bool:
-        return False
-
-    def on_enter(self) -> None:
-        self.is_hovered = True
-        self.do_on_enter()
-
-    def on_exit(self) -> None:
-        self.is_hovered = False
-        self.is_clicked_down = False
-        self.do_on_exit()
-
-    def do_on_enter(self) -> None:
-        pass
-
-    def do_on_exit(self) -> None:
-        pass
-
-    def on_mouse_motion(self, x, y) -> None:
-        self.do_on_mouse_motion(x, y)
-
-    def do_on_mouse_motion(self, x, y) -> None:
-        pass
-
-    def set_focused_child(self, child: "InteractiveWidget"):
-        pass
-
-    def draw_focused(self, camera: bf.Camera) -> None:
-        delta = 4 + ((2 * cos(pygame.time.get_ticks() / 100)) // 2) * 2
-        pygame.draw.rect(
-            camera.surface,
-            "white",
-            self.rect.move(-camera.rect.x, -camera.rect.y),#.inflate(delta, delta),
-            1,
-        )
+        
+    def lose_focus(self)->bool:
+        if self.is_focused and self.parent is not None:
+            self.get_root().focus_on(None)
+