batframework 1.0.9a10__py3-none-any.whl → 1.0.10__py3-none-any.whl

batFramework/gui/draggableWidget.py

@@ -1,44 +0,0 @@
-from .interactiveWidget import InteractiveWidget
-import batFramework as bf
-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):
-        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_pos: tuple[float, float], drag_end_pos: tuple[float, float]
-    ) -> None:
-        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):
-        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]*5
-        super().update(dt)

batFramework/gui/meter.py

@@ -1,96 +0,0 @@
-import math
-import batFramework as bf
-from .shape import Shape
-from typing import Self
-
-
-def custom_top_at(self, x, y):
-    if Shape.top_at(self, x, y) == self:
-        return self.parent
-    return None
-
-class Meter(Shape):
-    def __init__(self, min_value: float = 0, max_value: float = 1, step: float = 0.1):
-        super().__init__()
-        self.min_value, self.max_value = min_value, max_value
-        self.step = step
-        self.snap: bool = False
-        self.value = self.max_value
-        self.set_debug_color("pink")
-
-    def __str__(self) -> str:
-        return "Meter"
-
-    def set_step(self, step: float) -> Self:
-        self.step = step
-        self.set_value(self.value)
-        return self
-
-    def set_range(self, range_min: float, range_max: float) -> Self:
-        if range_min >= range_max:
-            return self
-        self.min_value = range_min
-        self.max_value = range_max
-        self.dirty_shape = True
-
-    def set_value(self, value: float) -> Self:
-        value = max(self.min_value, min(self.max_value, value))
-        value = round(value / self.step) * self.step
-        self.value = round(value,10)
-        self.dirty_shape = True
-        return self
-
-    def get_value(self) -> float:
-        return self.value
-
-    def get_range(self) -> float:
-        return self.max_value - self.min_value
-
-    def get_ratio(self) -> float:
-        return (self.value-self.min_value) / (self.max_value - self.min_value)
-
-
-class BarMeter(Meter):
-    def __init__(self, min_value: float = 0, max_value: float = 1, step: float = 0.1):
-        super().__init__(min_value, max_value, step)
-        self.axis: bf.axis = bf.axis.HORIZONTAL
-        self.content = Shape((0, 0)).set_color(bf.color.BLUE)
-        self.content.set_debug_color("cyan")
-        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
-        self.add(self.content)
-        self.set_padding(4)
-        self.set_color("gray20")
-        self.set_outline_width(1)
-        self.set_outline_color(bf.color.BLACK)
-        self.set_debug_color("pink")
-
-    def __str__(self) -> str:
-        return "BarMeter"
-
-    def set_axis(self,axis:bf.axis)->Self:
-        self.axis = axis
-        self.dirty_shape = True
-        return self
-
-    def _build_content(self) -> None:
-        padded = self.get_inner_rect()
-        ratio = self.get_ratio()
-
-        self.content.set_border_radius(*[round(b/2) for b in self.border_radius])
-
-        if self.axis == bf.axis.HORIZONTAL:
-            width = (padded.width- self.outline_width *2) * ratio 
-            self.content.set_size((width, padded.height - self.outline_width*2))
-            self.content.rect.topleft = padded.move(self.outline_width, self.outline_width).topleft
-
-        else:  # vertical
-            height = (padded.height - self.outline_width * 2) * ratio
-            self.content.set_size((padded.width - self.outline_width * 2, height))
-            self.content.rect.bottomleft = (
-                padded.move(self.outline_width,-self.outline_width).bottomleft 
-            )
-            self.content.rect.height = math.ceil(self.content.rect.height)
-
-    def build(self) -> None:
-        self._build_content()
-        super().build()

batFramework/gui/radioButton.py

@@ -1,35 +0,0 @@
-import batFramework as bf
-from typing import Self, Any, Callable
-from .toggle import Toggle
-from .syncedVar import SyncedVar
-
-
-class RadioButton(Toggle):
-    def __init__(self, text: str = "", radio_value: Any = None, synced_var: SyncedVar = None) -> None:
-        super().__init__(text, None, False)
-        self.radio_value: Any = radio_value if radio_value is not None else text if text else None
-        self.synced_var : SyncedVar = None
-        if synced_var:
-            self.link(synced_var)
-
-    def link(self,synced_var:SyncedVar)->Self:
-        self.synced_var = synced_var
-        synced_var.bind_widget(self,self._update_state)
-        return self
-
-    def __str__(self) -> str:
-        return f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
-
-    def set_radio_value(self, value: Any) -> Self:
-        self.radio_value = value
-        return self
-
-    def set_value(self, value : bool, do_callback=False):
-        super().set_value(value, do_callback)
-        if value : self.synced_var.value = self.radio_value
-
-    def _update_state(self, synced_value: Any) -> None:
-        """
-        Updates the state of the RadioButton based on the synced variable's value.
-        """
-        self.set_value(self.radio_value == synced_value, False)

batFramework/gui/selector.py

@@ -1,250 +0,0 @@
-import batFramework as bf
-import pygame
-from typing import Self,Callable,Any
-from .button import Button
-from .indicator import ArrowIndicator
-from .clickableWidget import ClickableWidget
-from .widget import Widget
-
-class MyArrow(ArrowIndicator,ClickableWidget):
-    def top_at(self,x,y):
-        return Widget.top_at(self,x,y)
-
-    def get_focus(self):
-        return self.parent.get_focus()
-
-class Selector(Button):
-    def __init__(self,options:list[str]=None,default_value:str=None,allow_cycle:bool=False):
-        super().__init__('')
-        self.allow_cycle = allow_cycle
-        self.current_index = 0
-        self.on_modify_callback : Callable[[str,int],Any] = None
-        self.options = options if options else []
-        self.gap : int = 2
-        text_value = ""
-
-        
-        if not (default_value is not None and default_value in self.options): 
-            default_value = options[0]
-            
-        text_value = default_value  
-        self.current_index = self.options.index(default_value)
-
-        self.left_indicator : MyArrow = (MyArrow(bf.direction.LEFT)
-            .set_color((0,0,0,0)).set_arrow_color(self.text_color)
-            .set_callback(lambda : self.set_by_index(self.get_current_index()-1))
-        )
-
-        self.right_indicator:MyArrow =(MyArrow(bf.direction.RIGHT)
-            .set_color((0,0,0,0)).set_arrow_color(self.text_color)
-            .set_callback(lambda : self.set_by_index(self.get_current_index()+1))
-        )
-        
-        self.add(self.left_indicator,self.right_indicator)
-        self.set_clip_children(False)
-        self.set_text(text_value)
-
-    def __str__(self):
-        return f"Selector[{self.options[self.current_index]}]"
-
-    def set_gap(self,value:int)->Self:
-        self.gap = value
-        self.dirty_shape = True
-        return self
-    
-    def set_arrow_color(self,color)->Self:
-        self.left_indicator.set_arrow_color(color)
-        self.right_indicator.set_arrow_color(color)
-        return self
-
-    def disable(self):
-        super().disable()
-        self.left_indicator.disable()
-        self.right_indicator.disable()
-        return self
-    
-    def enable(self):
-        super().enable()
-        self.right_indicator.enable()
-        self.left_indicator.enable()
-        index = self.current_index
-        if not self.allow_cycle:
-            if index == 0:
-                self.left_indicator.disable()
-            else:
-                self.left_indicator.enable()
-            if index == len(self.options)-1:
-                self.right_indicator.disable()
-            else:
-                self.right_indicator.enable()
-
-
-        return self
-
-    def set_tooltip_text(self, text):
-        self.left_indicator.set_tooltip_text(text)
-        self.right_indicator.set_tooltip_text(text)
-        return super().set_tooltip_text(text)
-
-    def get_min_required_size(self) -> tuple[float, float]:
-        """
-        Calculates the minimum size required for the selector, including text and indicators.
-        """
-
-        # Calculate the maximum size needed for the text
-        old_text = self.text
-        max_text_size = (0, 0)
-        for option in self.options:
-            self.text = option
-            text_size = self._get_text_rect_required_size()
-            max_text_size = max(max_text_size[0], text_size[0]), max(max_text_size[1], text_size[1])
-        self.text = old_text
-
-        # Ensure total_height is always an odd integer
-        total_height = max(self.font_object.get_height()+1, max_text_size[1] * 1.5)
-        total_height += self.unpressed_relief
-        total_height += max(self.right_indicator.outline_width,self.left_indicator.outline_width)
-
-        # Calculate total width and height
-        total_width = (
-            total_height*2+
-            max_text_size[0] +  # Text width
-            self.gap * 2      # Gaps between text and indicators
-        )
-        # Inflate by padding at the very end
-        final_size = self.expand_rect_with_padding((0, 0, total_width, total_height)).size
-
-        return final_size
-
-    def _align_content(self):
-        """
-        Builds the selector layout (places and resizes the indicators)
-        """
-
-        # return
-        # Step 1: Calculate the padded area for positioning
-        padded = self.get_inner_rect()
-
-    
-        # left_size = self.left_indicator.rect.size
-        right_size = self.right_indicator.rect.size
-
-        indicator_height = padded.h
-
-        self.left_indicator.set_size((indicator_height,indicator_height))
-        self.right_indicator.set_size((indicator_height,indicator_height))
-
-
-        # Step 3: Position indicators
-        self.left_indicator.set_position(padded.left, None)
-        self.left_indicator.set_center(None, padded.centery)
-
-        self.right_indicator.set_position(padded.right - right_size[0], None)
-        self.right_indicator.set_center(None, padded.centery)
-
-    def apply_post_updates(self, skip_draw = False):
-        super().apply_post_updates(skip_draw)
-        self._align_content()
-
-    def get_current_index(self)->int:
-        return self.current_index
-
-    def set_allow_cycle(self,value:bool)->Self:
-        if value == self.allow_cycle: return self
-        self.allow_cycle = value
-        self.dirty_surface = True
-        return self
-
-    def set_text_color(self,color)->Self:
-        super().set_text_color(color)
-        self.left_indicator.set_arrow_color(color)
-        self.right_indicator.set_arrow_color(color)
-        return self
-
-    def set_modify_callback(self,function:Callable[[str,int],Any]):
-        """
-        the function will receive the value and the index 
-        """
-        self.on_modify_callback = function
-        return self
-
-    def set_by_index(self,index:int)->Self:
-        if self.allow_cycle:
-            index = index%len(self.options)
-        else:
-            index = max(min(len(self.options)-1,index),0)
-    
-        if index == self.current_index:
-            return self
-
-        self.current_index = index
-        self.set_text(self.options[self.current_index])
-        if self.on_modify_callback:
-            self.on_modify_callback(self.options[self.current_index],self.current_index)
-        if not self.allow_cycle:
-            if index == 0:
-                self.left_indicator.disable()
-            else:
-                self.left_indicator.enable()
-            if index == len(self.options)-1:
-                self.right_indicator.disable()
-            else:
-                self.right_indicator.enable()
-        return self
-
-    def paint(self):
-        super().paint()
-        self.left_indicator.show()
-        self.right_indicator.show()
-        if not self.allow_cycle and self.current_index == 0:
-            self.left_indicator.hide()
-        elif not self.allow_cycle and self.current_index== len(self.options)-1:
-            self.right_indicator.hide()
-            
-    def set_by_value(self,value:str)->Self:
-        if not self.is_enabled : return
-        if value not in self.options : return self
-        index = self.options.index(value)
-        self.set_by_index(index)
-        return self
-
-    def on_key_down(self, key: int) -> bool:
-        if not self.is_enabled:
-            return False
-
-        key_actions = {
-            pygame.K_RIGHT: self.right_indicator,
-            pygame.K_SPACE: self.right_indicator,
-            pygame.K_LEFT: self.left_indicator
-        }
-
-        indicator = key_actions.get(key)
-        if indicator and indicator.visible and indicator.is_enabled:
-            indicator.on_click_down(1)
-            return True
-
-        return False
-
-    def on_key_up(self, key: int) -> bool:
-        if not self.is_enabled:
-            return False
-
-        key_actions = {
-            pygame.K_RIGHT: self.right_indicator,
-            pygame.K_SPACE: self.right_indicator,
-            pygame.K_LEFT: self.left_indicator
-        }
-
-        indicator = key_actions.get(key)
-        if indicator and indicator.visible and indicator.is_enabled:
-            indicator.on_click_up(1)
-            return True
-
-        return False
-    
-    def do_on_click_down(self, button) -> None:
-        if self.is_enabled and button == 1:
-            if not self.get_focus():
-                return True
-        return False
-