batframework 1.0.9a8__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/constants.py

@@ -49,4 +49,3 @@ class Constants:
     @staticmethod
     def set_fps_limit(value: int):
         Constants.FPS = value
-        print("FPS limit to : ", value)

batFramework/gui/__init__.py

@@ -7,7 +7,7 @@ from .draggableWidget import DraggableWidget
 from .clickableWidget import ClickableWidget
 from .root import Root
 from .shape import Shape
-from .meter import Meter
+from .meter import BarMeter
 from .label import Label
 from .tooltip import ToolTip
 from .animatedLabel import AnimatedLabel
@@ -18,7 +18,8 @@ from .layout import *
 from .container import Container
 from .indicator import *
 from .toggle import Toggle
-from .radioButton import RadioButton, RadioVariable
+from .syncedVar import SyncedVar
+from .radioButton import RadioButton
 from .slider import Slider
 from .selector import Selector
 import batFramework.gui.constraints as constraints

batFramework/gui/clickableWidget.py

@@ -11,16 +11,18 @@ class ClickableWidget(Shape, InteractiveWidget):
     def __init__(self, callback: Callable[[],Any] = None, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.callback = callback
-        self.is_pressed: bool = False
-        self.enabled: bool = True
+        self.is_pressed: bool = False # the state where the button is being held down (releasing will trigger callback)
+        self.is_enabled: bool = True # 
         self.hover_cursor = bf.const.DEFAULT_HOVER_CURSOR
         self.click_cursor = bf.const.DEFAULT_CLICK_CURSOR
+
         self.click_down_sound = None
         self.click_up_sound = None
         self.get_focus_sound = None
         self.lose_focus_sound = None
-        self.pressed_relief: int = 1
-        self.unpressed_relief: int = 2
+
+        self.pressed_relief: int = 1    # Depth effect height when pressed
+        self.unpressed_relief: int = 2  # Depth effect height when released (default)
         self.silent_focus: bool = False
         self.set_debug_color("cyan")
         self.set_relief(self.unpressed_relief)
@@ -98,18 +100,15 @@ class ClickableWidget(Shape, InteractiveWidget):
         return True
 
     def enable(self) -> Self:
-        self.enabled = True
+        self.is_enabled = True
         self.dirty_surface = True
         return self
 
     def disable(self) -> Self:
-        self.enabled = False
+        self.is_enabled = False
         self.dirty_surface = True
         return self
 
-    def is_enabled(self) -> bool:
-        return self.enabled
-
     def set_callback(self, callback: Callable[[],Any]) -> Self:
         self.callback = callback
         return self
@@ -134,7 +133,7 @@ class ClickableWidget(Shape, InteractiveWidget):
         return f"ClickableWidget"
 
     def click(self, force=False) -> None:
-        if not self.enabled and not force:
+        if not self.is_enabled and not force:
             return False
         if self.callback is not None:
             self.callback()
@@ -154,33 +153,36 @@ class ClickableWidget(Shape, InteractiveWidget):
         return self.do_on_key_down(key)
         
 
-    def on_click_down(self, button) -> None:
-        if super().on_click_down(button):
-            return True
-        if self.enabled and button == 1:
-            if not self.get_focus():
-                return False
-            self.is_pressed = True
-            if self.click_down_sound:
-                bf.AudioManager().play_sound(self.click_down_sound)
-            pygame.mouse.set_cursor(self.click_cursor)
-            self.set_relief(self.pressed_relief)
+    def on_click_down(self, button) -> bool:
+        if button < 1 or button > 5 : return False
+        self.is_clicked_down[button-1] = True
+        if self.is_enabled and button == 1:
+            if self.get_focus():
+                self.is_pressed = True
+                if self.click_down_sound:
+                    bf.AudioManager().play_sound(self.click_down_sound)
+                pygame.mouse.set_cursor(self.click_cursor)
+                self.set_relief(self.pressed_relief)
+                self.do_on_click_down(button)
             return True
         return False
 
-    def on_click_up(self, button) -> None:
-        if super().on_click_up(button):
-            return True
-        if self.enabled and button == 1 and self.is_pressed:
+    def on_click_up(self, button):
+        if button < 1 or button > 5 : return False
+        self.is_clicked_down[button-1] = False
+        if self.is_enabled and button == 1 and self.is_pressed:
             self.is_pressed = False
             if self.click_up_sound:
                 bf.AudioManager().play_sound(self.click_up_sound)
             self.set_relief(self.unpressed_relief)
-            return self.click()
+            self.click()
+            self.do_on_click_up(button)
+            return True
         return False
-    
+
+
     def on_enter(self) -> None:
-        if not self.enabled:
+        if not self.is_enabled:
             return
         super().on_enter()
         self.dirty_surface = True
@@ -192,7 +194,6 @@ class ClickableWidget(Shape, InteractiveWidget):
             self.set_relief(self.unpressed_relief)
         self.is_pressed = False
         self.dirty_surface = True
-
         pygame.mouse.set_cursor(bf.const.DEFAULT_CURSOR)
 
     def on_lose_focus(self):
@@ -218,7 +219,7 @@ class ClickableWidget(Shape, InteractiveWidget):
             self.rect.h - self.unpressed_relief - self.padding[1] - self.padding[3],
         )
 
-    def get_local_padded_rect(self) -> pygame.FRect:
+    def get_local_inner_rect(self) -> pygame.FRect:
         return pygame.FRect(
             self.padding[0],
             self.padding[1] + (self.unpressed_relief - self.pressed_relief if self.is_pressed else 0),
@@ -237,7 +238,7 @@ class ClickableWidget(Shape, InteractiveWidget):
 
     def paint(self) -> None:
         super().paint()
-        if not self.enabled:
+        if not self.is_enabled:
             self._paint_disabled()
         elif self.is_hovered:
             self._paint_hovered()

batFramework/gui/container.py

@@ -41,25 +41,19 @@ class Container(Shape, InteractiveWidget):
     def scrollX_by(self, x: float | int) -> Self:
         if x == 0:
             return self
-        self.scroll.x += x
-        self.clamp_scroll()
-        self.dirty_layout = True
+        self.set_scroll((self.scroll.x + x, self.scroll.y))
         return self
 
     def scrollY_by(self, y: float | int) -> Self:
         if y == 0:
             return self
-        self.scroll.y += y
-        self.clamp_scroll()
-        self.dirty_layout = True
+        self.set_scroll((self.scroll.x, self.scroll.y + y))
         return self
 
     def scroll_by(self, value: tuple[float | int, float | int]) -> Self:
         if value[0] == 0 and value[1] == 0:
             return self
-        self.scroll += value
-        self.clamp_scroll()
-        self.dirty_layout = True
+        self.set_scroll((self.scroll.x + value[0], self.scroll.y + value[1]))
         return self
 
     def clamp_scroll(self) -> Self:
@@ -77,9 +71,7 @@ class Container(Shape, InteractiveWidget):
         new_x = min(max(self.scroll.x, 0), max_scroll_x)
         new_y = min(max(self.scroll.y, 0), max_scroll_y)
 
-        if self.scroll.x != new_x or self.scroll.y != new_y:
-            self.scroll.x = new_x
-            self.scroll.y = new_y
+        self.set_scroll((new_x, new_y))
         return self
 
     def set_layout(self, layout: Layout) -> Self:
@@ -93,7 +85,10 @@ class Container(Shape, InteractiveWidget):
         return self
 
     def get_interactive_children(self) -> list[InteractiveWidget]:
-        return [child for child in self.children if isinstance(child, InteractiveWidget) and not isinstance(child,Container) and child.allow_focus_to_self()]
+        return [child for child in self.get_layout_children() if isinstance(child, InteractiveWidget) and not isinstance(child,Container) and child.allow_focus_to_self()]
+
+    def get_layout_children(self)->list[Widget]:
+        return self.children
 
     def clear_children(self) -> None:
         self.children.clear()
@@ -202,5 +197,5 @@ class Container(Shape, InteractiveWidget):
         if self.dirty_surface and not skip_draw:
             self.paint()
             self.dirty_surface = False
-  
+
 

batFramework/gui/draggableWidget.py

@@ -5,33 +5,40 @@ import pygame
 
 class DraggableWidget(InteractiveWidget):
     def __init__(self, *args, **kwargs) -> None:
-
         self.drag_start = None
         self.offset = None
+        self.click_mask = [True,False,False,False,False]
+        self.is_dragged : bool = False # the widget is following the mouse AND the mouse is in the widget
+        self.is_dragged_outside : bool = False # the widget is following the mouse BUT the mouse is NOT in the widget
         super().__init__(*args, **kwargs)
+    
+    def set_click_mask(self,b1=0,b2=0,b3=0,b4=0,b5=0):
+        self.click_mask = [b1,b2,b3,b4,b5]
 
     def on_click_down(self, button):
-        if super().on_click_down(button)==False:
-            return button == 1 # capture event
+        super().on_click_down(button)
+        return any(i==j and i== True for i,j in zip(self.is_clicked_down,self.click_mask))
     
     def do_on_drag(
-        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
+        self, drag_start_pos: tuple[float, float], drag_end_pos: tuple[float, float]
     ) -> None:
-        self.set_position(drag_end[0] - self.offset[0], drag_end[1] - self.offset[1])
-
+        new_pos = drag_end_pos[0] - self.offset[0], drag_end_pos[1] - self.offset[1]
+        if self.rect.topleft != new_pos:
+            self.set_position(*new_pos)
 
     def update(self, dt: float):
-        if self.is_clicked_down and pygame.mouse.get_pressed(3)[0]:
-            r = self.get_root()
-            x, y = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
-            if self.drag_start == None and self.is_clicked_down:
+        self.is_dragged_outside = any(i==j and i== True for i,j in zip(pygame.mouse.get_pressed(5),self.click_mask))
+        self.is_dragged = any(i==j and i== True for i,j in zip(self.is_clicked_down,self.click_mask))
+
+        if self.is_dragged and self.is_dragged_outside:
+            x, y = self.parent_layer.camera.screen_to_world(pygame.mouse.get_pos())
+            if self.drag_start == None:
                 self.offset = x - self.rect.x, y - self.rect.y
                 self.drag_start = x, y
             else:
                 self.do_on_drag(self.drag_start, (x, y))
-                
         else:
             self.drag_start = None
             self.offset = None
-            self.is_clicked_down = False
+            self.is_clicked_down = [False]*5
         super().update(dt)

batFramework/gui/indicator.py

@@ -68,61 +68,44 @@ class ArrowIndicator(Indicator):
         self.direction : bf.direction = direction
         self.arrow_color = bf.color.WHITE
         self.line_width : int = 1
-        self.angle : float  = 45
-        self.spread : float = None 
-        self.draw_stem : bool = True
-        
-    def set_draw_stem(self,value:bool)->Self:
-        self.draw_stem = value
-        self.dirty_surface = False
-        return self
-
-    def set_spread(self,value:float)->Self:
-        self.spread = value
-        self.dirty_surface = True
-        return self
 
-    def set_angle(self,value:float)->Self:
-        self.angle = value
-        self.dirty_surface = True
-        return self
-        
     def set_arrow_color(self,color)-> Self:
         self.arrow_color = color
         self.dirty_surface = True
         return self
 
-    def set_direction(self,direction:bf.direction)->Self:
+    def set_arrow_direction(self,direction:bf.direction)->Self:
         self.direction = direction
         self.dirty_surface = True
         return self
 
-    def set_line_width(self,value:int)->Self:
+    def set_arrow_line_width(self,value:int)->Self:
         self.line_width = value
         self.dirty_surface = True
         return self
         
     def paint(self):
         super().paint()
-        r = self.get_local_padded_rect()
+        r = self.get_local_inner_rect()
         size = min(r.width, r.height)
         if size %2 == 0:
             size -= 1
         r.width = size
         r.height = size
+
+        #pixel alignment
         if (self.padding[1]+self.padding[3] )%2 ==0:
             r.height-=1
         if (self.padding[0]+self.padding[2] )%2 ==0:
             r.width-=1
-        r.center = self.get_local_padded_rect().center
-        # r.inflate_ip(3,3)
-        # r.normalize()
-        # r.move_ip(-self.rect.left,-self.rect.right)
+        r.center = self.get_local_inner_rect().center
+
         bf.utils.draw_triangle(
             surface = self.surface,
             color = self.arrow_color,
             rect =r,
             direction = self.direction,
+            width = self.line_width
 
         )
         

batFramework/gui/interactiveWidget.py

@@ -18,10 +18,11 @@ def children_has_focus(widget)->bool:
 
 
 class InteractiveWidget(Widget):
+    __focus_effect_cache = {}
     def __init__(self, *args, **kwargs) -> None:
         self.is_focused: bool = False
         self.is_hovered: bool = False
-        self.is_clicked_down: bool = False
+        self.is_clicked_down: list[bool] = [False]*5
         self.focused_index = 0
         self.focusable = True
         super().__init__(*args, **kwargs)
@@ -136,13 +137,13 @@ class InteractiveWidget(Widget):
     
     def on_key_down(self, key) -> bool:
         """
-        return True to stop event progpagation
+        return True to stop event propagation
         """
         return self.do_on_key_down(key)
 
     def on_key_up(self, key) -> bool:
         """
-        return True to stop event progpagation
+        return True to stop event propagation
         """
         return self.do_on_key_up(key)
 
@@ -154,42 +155,37 @@ class InteractiveWidget(Widget):
 
     def do_on_key_down(self, key) -> bool:
         """
-        return True to stop event progpagation
+        return True to stop event propagation
         """
         return False
 
     def do_on_key_up(self, key) -> bool:
         """
-        return True to stop event progpagation
+        return True to stop event propagation
         """
         return False
 
-
     def on_click_down(self, button: int) -> bool:
         """
-        return True to stop event progpagation
+        return True to stop event propagation
         """
-        self.is_clicked_down = True
+        if button < 1 or button > 5 : return False
+        self.is_clicked_down[button-1] = True
         return self.do_on_click_down(button)
 
     def on_click_up(self, button: int) -> bool:
         """
-        return True to stop event progpagation
+        return True to stop event propagation
         """
-        self.is_clicked_down = False
+        if button < 1 or button > 5 : return False
+        self.is_clicked_down[button-1] = False
         return self.do_on_click_up(button)
 
-    def do_on_click_down(self, button: int) -> bool:
-        """
-        return True to stop event progpagation
-        """
-        return False
+    def do_on_click_down(self, button: int) -> None:
+        return 
 
-    def do_on_click_up(self, button: int) -> bool:
-        """
-        return True to stop event progpagation
-        """
-        return False
+    def do_on_click_up(self, button: int) -> None:
+        return 
 
     def on_enter(self) -> None:
         self.is_hovered = True
@@ -197,7 +193,7 @@ class InteractiveWidget(Widget):
 
     def on_exit(self) -> None:
         self.is_hovered = False
-        self.is_clicked_down = False
+        self.is_clicked_down = [False]*5
         self.do_on_exit()
 
     def do_on_enter(self) -> None:
@@ -226,12 +222,18 @@ class InteractiveWidget(Widget):
         # Shrink for inner pulsing border
         inner = screen_rect.inflate(-delta, -delta)
         inner.topleft = 0,0
-        surface = pygame.Surface(inner.size)
+        inner.w = round(inner.w)
+        inner.h = round(inner.h)
+
+        surface = InteractiveWidget.__focus_effect_cache.get(inner.size)
+        if surface is None:
+            surface = pygame.Surface(inner.size)
+            InteractiveWidget.__focus_effect_cache[inner.size] = surface
+
         surface.set_colorkey((0,0,0))
         pygame.draw.rect(surface, "white", inner, 2, *self.border_radius)
-        pygame.draw.rect(surface, "black", inner.inflate(-16,0), 2)
-        pygame.draw.rect(surface, "black", inner.inflate(0,-16), 2)
+        pygame.draw.rect(surface, "black", inner.inflate(-1 * min(16,inner.w*0.75),0), 2)
+        pygame.draw.rect(surface, "black", inner.inflate(0,-1 * min(16,inner.h*0.75)), 2)
         inner.center = screen_rect.center
         camera.surface.blit(surface,inner)
 
-        # pygame.draw.rect(camera.surface, "white", inner, 2, *self.border_radius)

batFramework/gui/label.py

@@ -273,7 +273,7 @@ class Label(Shape):
             # return True
 
         self.text_rect.size = self._get_text_rect_required_size()
-        padded = self.get_local_padded_rect()
+        padded = self.get_local_inner_rect()
         self.align_text(self.text_rect, padded, self.alignment)
         return ret
 
@@ -312,7 +312,7 @@ class Label(Shape):
         # clip surface
         
         old = self.surface.get_clip()
-        self.surface.set_clip(self.get_local_padded_rect())
+        self.surface.set_clip(self.get_local_inner_rect())
         self.surface.fblits(l)
         self.surface.set_clip(old)
         
@@ -338,7 +338,6 @@ class Label(Shape):
         return size_changed
         
         
-
     def paint(self) -> None:
         super().paint()
         if self.font_object: