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

batFramework/gui/shape.py

@@ -27,7 +27,7 @@ class Shape(Widget):
     def get_inner_top(self) -> float:
         return self.rect.y + self.padding[1]
 
-    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],

batFramework/gui/slider.py

@@ -1,41 +1,41 @@
 import batFramework as bf
-from .meter import Meter
+from .meter import BarMeter
 from .button import Button
 from .indicator import *
-from .meter import Meter
+from .meter import BarMeter
 from .shape import Shape
 from .interactiveWidget import InteractiveWidget
 
-
 class SliderHandle(Indicator, DraggableWidget):
     def __init__(self):
         super().__init__()
         self.set_color(bf.color.CLOUD_SHADE)
         self.old_key_repeat: tuple = (0, 0)
         self.parent : bf.ClickableWidget = self.parent
+        self.set_click_mask(1)
     def __str__(self) -> str:
         return "SliderHandle"
 
     def on_click_down(self, button: int) -> bool:
-        if not self.parent.is_enabled(): 
-            return False
-        super().on_click_down(button)
-        if button == 1:
-            self.parent.get_focus()
+        if not self.parent.is_enabled: 
             return True
-        return False
-
-    def on_exit(self) -> None:
-        self.is_hovered = False
-        self.do_on_exit()
-
+        res = super().on_click_down(button)
+        if res : 
+            self.parent.get_focus()
+        return res
+    
+    def on_exit(self):
+        before = self.is_clicked_down
+        super().on_exit()
+        self.is_clicked_down = before
+    
     def do_on_drag(
         self, drag_start: tuple[float, float], drag_end: tuple[float, float]
     ) -> None:
-        if not self.parent.is_enabled(): 
+        if not self.parent.is_enabled: 
             return
         super().do_on_drag(drag_start, drag_end)
-        m: Meter = self.parent.meter
+        m: BarMeter = self.parent.meter
         r = m.get_inner_rect()
 
         position = self.rect.centerx if self.parent.axis == bf.axis.HORIZONTAL else self.rect.centery
@@ -51,8 +51,7 @@ class SliderHandle(Indicator, DraggableWidget):
     def top_at(self, x, y):
         return Widget.top_at(self, x, y)
 
-
-class SliderMeter(Meter, InteractiveWidget):
+class SliderMeter(BarMeter, InteractiveWidget):
     def __str__(self) -> str:
         return "SliderMeter"
 
@@ -68,29 +67,25 @@ class SliderMeter(Meter, InteractiveWidget):
             size[1] = size[0]*3
         return self.resolve_size(size)
 
-    def on_click_down(self, button: int) -> True:
-        if not self.parent.is_enabled(): 
+    def on_click_down(self, button: int) -> bool:
+        if not self.parent.is_enabled: 
             return False
         if button != 1:
             return False
         
         self.parent.get_focus()
-        r = self.get_root()
-        if r:
-            pos = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
-            if self.parent.axis == bf.axis.HORIZONTAL:
-                pos = pos[0]
-            else:
-                pos = pos[1]
-            new_value = self.parent.position_to_value(pos)
-            self.parent.set_value(new_value)
+        pos = self.parent_layer.camera.screen_to_world(pygame.mouse.get_pos())
+        if self.parent.axis == bf.axis.HORIZONTAL:
+            pos = pos[0]
+        else:
+            pos = pos[1]
+        new_value = self.parent.position_to_value(pos)
+        self.parent.set_value(new_value)
         self.do_on_click_down(button)
         return True
 
-    def resolve_constraints(self, size_only = False, position_only = False):
-        return super().resolve_constraints(size_only, position_only)
-
 class Slider(Button):
+
     def __init__(self, text: str, default_value: float = 1.0) -> None:
         super().__init__(text, None)
         self.axis : bf.axis = bf.axis.HORIZONTAL
@@ -162,6 +157,7 @@ class Slider(Button):
     def set_value(self, value, no_callback: bool = False) -> Self:
         if self.meter.value != value:
             self.meter.set_value(value)
+            self.dirty_shape = True
         if self.modified_callback and (not no_callback):
             self.modified_callback(self.meter.value)
             self.handle.set_tooltip_text(str(self.get_value()))
@@ -175,7 +171,7 @@ class Slider(Button):
     def on_key_down(self, key):
         if super().on_key_down(key):
             return True
-        if not self.is_enabled(): 
+        if not self.is_enabled: 
             return False
         if self.axis == bf.axis.HORIZONTAL:
             if key == pygame.K_RIGHT:
@@ -196,7 +192,7 @@ class Slider(Button):
             return True
 
     def do_on_click_down(self, button) -> None:
-        if not self.is_enabled(): 
+        if not self.is_enabled: 
             return
         if button == 1:
             self.get_focus()
@@ -251,7 +247,6 @@ class Slider(Button):
         value = self.meter.min_value + position_ratio * value_range
         return round(value / self.meter.step) * self.meter.step
 
-
     def get_min_required_size(self) -> tuple[float, float]:
         """
         Calculates the minimum required size for the slider, considering the text, meter, and axis.
@@ -264,43 +259,59 @@ class Slider(Button):
         meter_width, meter_height = self.meter.resolve_size(self.meter.get_min_required_size())
 
         if self.axis == bf.axis.HORIZONTAL:
-            width = text_width + gap + meter_width
+            width = text_width + gap + meter_width 
             height = max(text_height, meter_height)
         else:
             width = max(text_width, meter_width)
             height = text_height + gap + meter_height
 
+        height += self.unpressed_relief
         return self.expand_rect_with_padding((0, 0, width, height)).size
-        
 
-    def _build_composed_layout(self, other: Shape) -> None:
+    def _build_composed_layout(self) -> None:
         """
-        Builds the layout for the slider, ensuring that child elements (handle and meter)
-        are resized and positioned correctly based on the slider's size and axis.
-
-        Args:
-            other (Shape): The shape object to align with the slider.
+        Builds the composed layout for the slider, including the meter and handle.
+        This method adjusts the sizes and positions of the meter and handle based on the slider's axis,
+        autoresize conditions, and spacing settings. It ensures the slider's components are properly aligned
+        and sized within the slider's padded rectangle.
         """
+        self.text_rect.size = self._get_text_rect_required_size()
+
         size_changed = False
         gap = self.gap if self.text else 0
 
         full_rect = self.text_rect.copy()
+
+
         # Resolve the meter's size based on the axis and autoresize conditions
         if self.axis == bf.axis.HORIZONTAL:
-            meter_width = self.meter.get_min_required_size()[0] if self.meter.autoresize_w else self.meter.rect.w
-            full_rect.w = max(self.get_inner_width(), meter_width + gap + self.text_rect.w)
-            self.meter.set_size((meter_width, None))
-            full_rect.h = max(self.meter.rect.h, self.text_rect.h if self.text else self.meter.rect.h)
+            meter_width,meter_height = self.meter.get_min_required_size()
+            if not self.autoresize_w:
+                meter_width = self.get_inner_width() - gap - self.text_rect.w 
+            meter_width,meter_height = self.meter.resolve_size((meter_width,meter_height))
+
+            full_rect.w = max(self.get_inner_width(), meter_width + (gap + self.text_rect.w if self.text else 0))
+            self.meter.set_size((meter_width, meter_height))
+            full_rect.h = max(meter_height, self.text_rect.h if self.text else meter_height)
+
         else:  # VERTICAL
-            meter_height = self.meter.get_min_required_size()[1] if self.meter.autoresize_h else self.meter.rect.h
-            full_rect.h = max(self.get_inner_height(), meter_height + (gap + self.text_rect.h if self.text else 0))
-            self.meter.set_size((None, meter_height))
-            full_rect.w = max(self.meter.rect.w, self.text_rect.w if self.text else self.meter.rect.w)
+            meter_width, meter_height = self.meter.get_min_required_size()
+            if not self.autoresize_h:
+                meter_height = self.get_inner_height() - gap - self.text_rect.h
+            meter_width, meter_height = self.meter.resolve_size((meter_width, meter_height))
+
+            full_rect.h =  meter_height + (gap + self.text_rect.h if self.text else 0)
+            self.meter.set_size((meter_width, meter_height))
+            full_rect.w = max(meter_width, self.text_rect.w if self.text else meter_width)
+
 
         # Inflate the rect by padding and resolve the target size
+        full_rect.h += self.unpressed_relief
         inflated = self.expand_rect_with_padding((0, 0, *full_rect.size)).size
+
         target_size = self.resolve_size(inflated)
 
+
         # Update the slider's size if it doesn't match the target size
         if self.rect.size != target_size:
             self.set_size(target_size)
@@ -314,23 +325,16 @@ class Slider(Button):
             handle_size = self.meter.get_inner_width() 
             self.handle.set_size(self.handle.resolve_size((handle_size, handle_size)))
 
-        # Align the composed elements (text and meter)
-        self._align_composed(other)
-
-        # Position the handle based on the current value
-        if self.axis == bf.axis.HORIZONTAL:
-            self.handle.set_center(self.value_to_position(self.meter.value), self.meter.rect.centery)
-        else:
-            self.handle.set_center(self.meter.rect.centerx, self.value_to_position(self.meter.value))
+        self._align_composed()
         return size_changed
-    def _align_composed(self, other: Shape):
-        if not self.text:
-            self.text_rect.size = (0,0)
 
+    def _align_composed(self):
 
-        full_rect = self.get_local_padded_rect()
+        if not self.text:
+            self.text_rect.size = (0,0)
+        full_rect = self.get_local_inner_rect()
         left_rect = self.text_rect
-        right_rect = other.rect.copy()
+        right_rect = self.meter.rect.copy()
 
 
 
@@ -381,29 +385,13 @@ class Slider(Button):
         # Push text to local, push shape to world
         self.text_rect = left_rect
         right_rect.move_ip(*self.rect.topleft)
-        other.set_position(*right_rect.topleft)
+        self.meter.set_position(*right_rect.topleft)
 
-    def _build_layout(self) -> None:
-        self.text_rect.size = self._get_text_rect_required_size()
-        return self._build_composed_layout(self.meter)
-        
+        # Position the handle based on the current value
+        if self.axis == bf.axis.HORIZONTAL:
+            self.handle.set_center(self.value_to_position(self.meter.value), self.meter.rect.centery)
+        else:
+            self.handle.set_center(self.meter.rect.centerx, self.value_to_position(self.meter.value))
 
-    def apply_pre_updates(self):
-        # Step 1: Constraints and shape/size
-        super().apply_pre_updates()
-        # Build text rect size
-        self.text_rect.size = self._get_text_rect_required_size()
-        # Compose layout for meter (but not handle position yet)
-        self._build_composed_layout(self.meter)
-        # Meter and handle may need to update their own pre-updates
-        self.meter.apply_pre_updates()
-        self.handle.apply_pre_updates()
-
-
-    def apply_post_updates(self, skip_draw: bool = False):
-        # Step 2: Final alignment and painting
-        super().apply_post_updates(skip_draw=skip_draw)
-        # Align handle to value (now that sizes are final)
-        self._align_composed(self.meter)
-        self.handle.apply_post_updates(skip_draw=skip_draw)
-        self.meter.apply_post_updates(skip_draw=skip_draw)
+    def _build_layout(self) -> None:
+        return self._build_composed_layout()

batFramework/gui/syncedVar.py

@@ -0,0 +1,49 @@
+from .widget import Widget
+from typing import Callable, Any, Self
+
+class SyncedVar:
+    def __init__(self, value=None):
+        self._value: Any = value
+        self.modify_callback: Callable[[Any], Any] | None = None
+        self._bound_widgets: set[tuple[Widget, Callable[[Any], Any]]] = set()
+
+    def set_modify_callback(self, callback : Callable[[Any], Any]) -> Self:
+        self.modify_callback = callback
+        return self
+
+    def bind_widget(self, widget: Widget, update_callback: Callable[[Any], Any]) -> Self:
+        """
+        Binds a widget to the SyncedVar. The widget must provide an update_callback
+        function that will be called whenever the value changes.
+        """
+        self._bound_widgets.add((widget, update_callback))
+        self._update_widgets()
+        return self
+
+    def unbind_widget(self, widget: Widget)->Self:
+        """
+        Unbinds a widget from the SyncedVar.
+        """
+        self._bound_widgets = {
+            (w, cb) for w, cb in self._bound_widgets if w != widget
+        }
+        return self
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, new_value):
+        if self._value != new_value:
+            self._value = new_value
+            self._update_widgets()
+        if self.modify_callback is not None:
+            self.modify_callback(new_value)
+
+    def _update_widgets(self):
+        """
+        Calls the update callback for all bound widgets.
+        """
+        for _, update_callback in self._bound_widgets:
+            update_callback(self._value)

batFramework/gui/textInput.py

@@ -72,7 +72,7 @@ class TextInput(Label, InteractiveWidget):
         return self
 
     def __str__(self) -> str:
-        return f"TextInput({repr(self.text)})"
+        return f"TextInput"
 
     def _cursor_toggle(self, value: bool | None = None):
         if value is None:

batFramework/gui/toggle.py

@@ -63,8 +63,9 @@ class Toggle(Button):
 
         return self.expand_rect_with_padding((0, 0, total_width, total_height)).size
 
-
     def _build_composed_layout(self,other:Shape):
+        size_changed = False
+        self.text_rect.size = self._get_text_rect_required_size()
 
         gap = self.gap if self.text else 0
         full_rect = self.text_rect.copy()
@@ -81,13 +82,14 @@ class Toggle(Button):
         target_size = self.resolve_size(inflated)
         if self.rect.size != target_size:
             self.set_size(target_size)
+            size_changed = True
 
         self._align_composed(other)
-        
+        return size_changed
 
     def _align_composed(self,other:Shape):
         
-        full_rect = self.get_local_padded_rect()
+        full_rect = self.get_local_inner_rect()
         left_rect = self.text_rect
         right_rect = other.rect
         gap = {
@@ -119,10 +121,8 @@ class Toggle(Button):
 
         right_rect.move_ip(*self.rect.topleft)
 
-
-
     def _build_layout(self) -> None:
-        self.text_rect.size = self._get_text_rect_required_size()
-        self._build_composed_layout(self.indicator)
+        return self._build_composed_layout(self.indicator)
+
 
 

batFramework/gui/widget.py

@@ -203,20 +203,21 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
             yield from child.get_debug_outlines()
 
     def add_constraints(self, *constraints: "Constraint") -> Self:
-        self.constraints.extend(constraints)
-        seen = set()
-        result = []
-        for c in self.constraints:
-            if not any(c == o for o in seen):
-                result.append(c)
-                seen.add(c.name)
-        self.constraints = result
+        # Add constraints without duplicates
+        existing_names = {c.name for c in self.constraints}
+        new_constraints = [c for c in constraints if c.name not in existing_names]
+        self.constraints.extend(new_constraints)
+
+        # Sort constraints by priority
         self.constraints.sort(key=lambda c: c.priority)
-        size_c = any(c.affects_size for c in constraints)
-        position_c = any(c.affects_position for c in constraints)
-        if position_c : self.dirty_position_constraints = True
-        if size_c : self.dirty_size_constraints = True
-        
+
+        # Update dirty flags based on the new constraints
+        if any(c.affects_size for c in new_constraints):
+            self.dirty_size_constraints = True
+        if any(c.affects_position for c in new_constraints):
+            self.dirty_position_constraints = True
+
+        # Clear ignored constraints
         self._constraints_to_ignore = []
 
         return self
@@ -226,8 +227,11 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         for c in self.constraints:
             if c.name in names:
                 c.on_removal(self)
-        self.constraints = [c for c in self.constraints if c.name not in names]
+        self.constraints = [c for c in self.constraints if c.name not in names]        
         self._constraints_to_ignore = []
+        self.dirty_size_constraints = True
+        self.dirty_position_constraints= True
+
         return self
 
 
@@ -319,6 +323,12 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
             return self.parent.get_root()
         return None
 
+    def get_by_tags(self,*tags: str)->list["Widget"]:
+        #use self.has_tags(*tags) for check
+        result = []
+        self.visit(lambda w: result.append(w) if w.has_tags(*tags) else None)
+        return result
+    
     def top_at(self, x: float | int, y: float | int) -> "None|Widget":
         if self.children:
             for child in reversed(self.children):
@@ -388,7 +398,7 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
         return True if size changed
         """
         new_size = tuple(map(int, self.rect.size))
-        if self.surface.size == new_size:
+        if self.surface.get_size() == new_size:
             return False
         
         old_alpha = self.surface.get_alpha()
@@ -485,7 +495,6 @@ class Widget(bf.Drawable, metaclass=WidgetMeta):
             self.dirty_shape = False
             self.dirty_surface = True
 
-
         if self.dirty_position_constraints:
             self.resolve_constraints(position_only=True)
 

batFramework/sceneLayer.py

@@ -47,7 +47,7 @@ class SceneLayer:
                 self.entities_to_remove.add(e)
 
     def process_event(self,event:pygame.Event):
-        if event.type == pygame.VIDEORESIZE:
+        if event.type == pygame.VIDEORESIZE and not pygame.SCALED & bf.const.FLAGS:
             self.camera.set_size(bf.const.RESOLUTION)
 
         for e in self.entities.values():

batFramework/utils.py

@@ -151,69 +151,6 @@ class Utils:
         else:
             pygame.draw.circle(dest_surf, inside_color, center, radius)
 
-    @staticmethod
-    def animate_move(entity:"Entity", start_pos : tuple[float,float], end_pos:tuple[float,float])->Callable[[float],None]:
-        """
-        Creates a function to animate the movement of an entity from start_pos to end_pos.
-
-        Args:
-            entity (Entity): The entity to move.
-            start_pos (tuple[float, float]): The starting position of the entity.
-            end_pos (tuple[float, float]): The ending position of the entity.
-
-        Returns:
-            Callable[[float], None]: A function that updates the entity's position based on a progression value (0 to 1).
-        """
-        def func(x):
-            entity.set_center(start_pos[0]+(end_pos[0]-start_pos[0])*x,start_pos[1]+(end_pos[1]-start_pos[1])*x)
-        return func
-    
-    def animate_move_to(entity: "Entity", end_pos: tuple[float, float]) -> Callable[[float], None]:
-        """
-        Creates a function to animate the movement of an entity to a specified end position, capturing the start position at the start of the animation.
-
-        Args:
-            entity (Entity): The entity to move.
-            end_pos (tuple[float, float]): The target position of the entity.
-
-        Returns:
-            Callable[[float], None]: A function that updates the entity's position based on a progression value (0 to 1).
-        """
-
-        # Start position will be captured once when the animation starts
-        start_pos = [None]
-
-        def update_position(progression: float):
-            if start_pos[0] is None:
-                start_pos[0] = entity.rect.center  # Capture the start position at the start of the animation
-
-            # Calculate new position based on progression
-            new_x = start_pos[0][0] + (end_pos[0] - start_pos[0][0]) * progression
-            new_y = start_pos[0][1] + (end_pos[1] - start_pos[0][1]) * progression
-
-            # Set the entity's new position
-            entity.set_center(new_x, new_y)
-
-        return update_position
-
-    @staticmethod
-    def animate_alpha(entity:"Drawable", start : int, end:int)->Callable[[float],None]:
-        """
-        Creates a function to animate the alpha (transparency) of a drawable entity between a start and end value.
-
-        Args:
-            entity (Drawable): The entity to animate.
-            start (int): The starting alpha value (0 to 255).
-            end (int): The ending alpha value (0 to 255).
-
-        Returns:
-            Callable[[float], None]: A function that updates the entity's alpha based on a progression value (0 to 1).
-        """
-        def func(x):
-            entity.set_alpha(int(pygame.math.clamp(start+(end-start)*x,0,255)))
-        return func
-    
-
 
     @staticmethod
     def random_color(min_value: int = 0, max_value: int = 255) -> tuple[int, int, int]:
@@ -306,7 +243,7 @@ class Utils:
         # Draw the filled triangle
         pygame.draw.polygon(surface, color, points,width=width)
 
-    def draw_arc_by_points(surface, color, start_pos, end_pos, tightness=0.5, width=1, resolution=0.5):
+    def draw_arc_by_points(surface, color, start_pos, end_pos, tightness=0.5, width=1, resolution=0.5,antialias:bool=False):
         """
         Draw a smooth circular arc connecting start_pos and end_pos.
         `tightness` controls curvature: 0 is straight line, 1 is semicircle, higher = more bulge.
@@ -327,6 +264,8 @@ class Utils:
         p1 = pygame.Vector2(end_pos)
         chord = p1 - p0
         if chord.length_squared() == 0:
+            if antialias:
+                return pygame.draw.aacircle(surface, color, p0, width // 2)
             return pygame.draw.circle(surface, color, p0, width // 2)
 
         # Midpoint and perpendicular
@@ -361,5 +300,7 @@ class Utils:
                 center.x + math.cos(a) * r,
                 center.y + math.sin(a) * r
             ))
-
+        if antialias:
+            return pygame.draw.aalines(surface, color, False, points)
+    
         return pygame.draw.lines(surface, color, False, points, width)

{batframework-1.0.9a8.dist-info → batframework-1.0.9a10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: batframework
-Version: 1.0.9a8
+Version: 1.0.9a10
 Summary: Pygame framework for making games easier.
 Author-email: Turan Baturay <baturayturan@gmail.com>
 License: MIT License