batframework 1.0.8a1__py3-none-any.whl → 1.0.8a2__py3-none-any.whl

batFramework/gui/constraints/constraints.py

@@ -1,378 +0,0 @@
-from ..widget import Widget
-import batFramework as bf
-import pygame
-
-
-class Constraint:
-    def __init__(self, name="Constraint", priority=0):
-        self.priority = priority
-        self.name = name
-
-    def set_priority(self, priority) -> "Constraint":
-        self.priority = priority
-        return self
-
-    def __str__(self) -> str:
-        return f"{self.name.upper()}"
-
-    def evaluate(self, parent_widget: Widget, child_widget: Widget) -> bool:
-        raise NotImplementedError("Subclasses must implement evaluate method")
-
-    def apply(self, parent_widget: Widget, child_widget: Widget = None) -> bool:
-        if not self.evaluate(parent_widget, child_widget):
-            self.apply_constraint(parent_widget, child_widget)
-            return False
-        return True
-
-    def apply_constraint(self, parent_widget: Widget, child_widget: Widget):
-        raise NotImplementedError("Subclasses must implement apply_constraint method")
-
-
-class MinWidth(Constraint):
-    def __init__(self, width: float):
-        super().__init__(name="min_width")
-        self.min_width = width
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width >= self.min_width
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_size((self.min_width,None))
-
-
-class MinHeight(Constraint):
-    def __init__(self, height: float):
-        super().__init__(name="min_height")
-        self.min_height = height
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.h >= self.min_height
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_size((None, self.min_height))
-
-
-class CenterX(Constraint):
-    def __init__(self):
-        super().__init__(name="centerx")
-
-    def evaluate(self, parent_widget, child_widget):
-        return int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0 
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_center(
-                parent_widget.get_padded_center()[0], child_widget.rect.centery
-            )
-
-
-class CenterY(Constraint):
-    def __init__(self):
-        super().__init__(name="centery")
-
-    def evaluate(self, parent_widget, child_widget):
-        return int(child_widget.rect.centery - parent_widget.get_padded_center()[1]) == 0 
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_center(
-                child_widget.rect.centerx, parent_widget.get_padded_center()[1]
-            )
-
-
-class Center(Constraint):
-    def __init__(self):
-        super().__init__(name="center")
-
-    def evaluate(self, parent_widget, child_widget):
-        return int(child_widget.rect.centerx - parent_widget.get_padded_center()[0]) == 0 and \
-        int(child_widget.rect.centery - parent_widget.get_padded_center()[1]) == 0
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_center(*parent_widget.get_padded_center())
-
-
-class PercentageWidth(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_width")
-        self.percentage: float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-
-    def __str__(self) -> str:
-        return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == round(
-            parent_widget.get_padded_width() * self.percentage
-        )
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if child_widget.autoresize_w:
-            if self.keep_autoresize:
-                print(
-                    f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
-                )
-                return
-            child_widget.set_autoresize_w(False)
-
-        child_widget.set_size(
-            (
-                round(parent_widget.get_padded_width() * self.percentage),None)
-        )
-
-class PercentageHeight(Constraint):
-    def __init__(self, percentage: float, keep_autoresize: bool = False):
-        super().__init__(name="percentage_height")
-        self.percentage: float = percentage
-        self.keep_autoresize: bool = keep_autoresize
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == round(parent_widget.get_padded_height() * self.percentage)
-
-    def __str__(self) -> str:
-        return f"{super().__str__()}.[{self.percentage*100}%,keep_autoresize={self.keep_autoresize}]"
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if child_widget.autoresize_h:
-            if self.keep_autoresize:
-                print(f"WARNING: Constraint on {child_widget} can't resize, autoresize set to True")
-                return
-            child_widget.set_autoresize_h(False)
-        child_widget.set_size((None,round(parent_widget.get_padded_height() * self.percentage)))
-
-class FillX(PercentageWidth):
-    def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1,keep_autoresize)
-        self.name = "fill_x"
-
-class FillY(PercentageHeight):
-    def __init__(self, keep_autoresize: bool = False):
-        super().__init__(1,keep_autoresize)
-        self.name = "fill_y"
-
-
-class Height(Constraint):
-    def __init__(self, height: float, keep_autoresize: bool = False):
-        if height < 0:
-            raise ValueError("height can't be negative")
-        super().__init__(name="height")
-        self.height = height
-        self.keep_autoresize: bool = keep_autoresize
-
-    def __str__(self) -> str:
-        return f"{super().__str__()}.(height={self.height})"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.height == self.height
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if child_widget.autoresize_h:
-            if self.keep_autoresize:
-                print(f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True")
-                return
-            child_widget.set_autoresize_h(False)
-        child_widget.set_size((None, self.height))
-
-
-class Width(Constraint):
-    def __init__(self, width: float, keep_autoresize: bool = False):
-        if width < 0:
-            raise ValueError("width can't be negative")
-        super().__init__(name="width")
-        self.width = width
-        self.keep_autoresize: bool = keep_autoresize
-
-    def __str__(self) -> str:
-        return f"{super().__str__()}.(width={self.width})"
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.width == self.width
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if child_widget.autoresize_w:
-            if self.keep_autoresize:
-                print(
-                    f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
-                )
-                return
-            child_widget.set_autoresize_w(False)
-        child_widget.set_size((self.width, None))
-
-
-class AspectRatio(Constraint):
-    def __init__(
-        self,
-        ratio: int | float | pygame.rect.FRectType = 1,
-        reference_axis: bf.axis = bf.axis.HORIZONTAL,
-        keep_autoresize=False,
-    ):
-        super().__init__(name="aspect_ratio")
-        self.ref_axis : bf.axis = reference_axis
-        self.keep_autoresize: bool = keep_autoresize
-
-        if isinstance(ratio, float | int):
-            self.ratio = ratio
-        elif isinstance(ratio, pygame.rect.FRect):
-            self.ratio = (ratio.w / ratio.h) if reference_axis == bf.axis.HORIZONTAL else (ratio.h / ratio.w)
-        else:
-            raise TypeError(f"Ratio must be float or FRect")
-
-    def evaluate(self, parent_widget, child_widget):
-        if self.ref_axis == bf.axis.HORIZONTAL:
-            return self.ratio == child_widget.rect.w / child_widget.rect.h
-        if self.ref_axis == bf.axis.VERTICAL:
-            return self.ratio == child_widget.rect.h / child_widget.rect.w
-
-    def apply_constraint(self, parent_widget, child_widget):
-
-        if self.ref_axis == bf.axis.VERTICAL:
-            if child_widget.autoresize_w :
-                if self.keep_autoresize:
-                    print(
-                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
-                    )
-                    return
-                child_widget.set_autoresize_w(False)
-            child_widget.set_size((child_widget.rect.h * self.ratio,None))
-        
-        if self.ref_axis == bf.axis.HORIZONTAL:
-            if child_widget.autoresize_h :
-                if self.keep_autoresize:
-                    print(
-                        f"WARNING: Constraint on {child_widget.__str__()} can't resize, autoresize set to True"
-                    )
-                    return
-                child_widget.set_autoresize_h(False)
-            print("HERE")
-            child_widget.set_size((None,child_widget.rect.w * self.ratio))
-
-class AnchorBottom(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_bottom")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.top == parent_widget.get_padded_bottom() - child_widget.rect.h
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(child_widget.rect.x,parent_widget.get_padded_bottom() - child_widget.rect.h)
-
-class AnchorBottom(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_bottom")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.top == parent_widget.get_padded_bottom() - child_widget.rect.h
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(child_widget.rect.x,parent_widget.get_padded_bottom() - child_widget.rect.h)
-
-
-
-class AnchorTopRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_topright")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.topright == parent_widget.get_padded_rect().topright
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            parent_widget.get_padded_top(),
-        )
-
-
-class AnchorBottomRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_bottomright")
-
-    def evaluate(self, parent_widget, child_widget):
-        return (
-            child_widget.rect.bottomright == parent_widget.get_padded_rect().bottomright
-        )
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            parent_widget.get_padded_bottom() - child_widget.rect.h,
-        )
-
-
-class AnchorRight(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_right")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.right == parent_widget.get_padded_right()
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w,
-            child_widget.rect.top,
-        )
-
-
-class AnchorLeft(Constraint):
-    def __init__(self):
-        super().__init__(name="anchor_left")
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.left == parent_widget.get_padded_left()
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_left(), child_widget.rect.top
-        )
-
-
-class MarginBottom(Constraint):
-    def __init__(self, margin: float):
-        super().__init__(name="margin_bottom")
-        self.margin = margin
-
-    def evaluate(self, parent_widget, child_widget):
-        return (
-            child_widget.rect.bottom == parent_widget.get_padded_bottom() - self.margin
-        )
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(child_widget.rect.x,
-            parent_widget.get_padded_bottom() - child_widget.rect.h - self.margin
-        )
-
-class MarginTop(Constraint):
-    def __init__(self, margin: float):
-        super().__init__(name="margin_top")
-        self.margin = margin
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.top == parent_widget.get_padded_top() + self.margin
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(child_widget.rect.x,parent_widget.get_padded_top() + self.margin)
-
-
-class MarginLeft(Constraint):
-    def __init__(self, margin: float):
-        super().__init__(name="margin_left")
-        self.margin = margin
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.left == parent_widget.get_padded_left() + self.margin
-
-    def apply_constraint(self, parent_widget, child_widget):
-        if not self.evaluate(parent_widget, child_widget):
-            child_widget.set_position(parent_widget.get_padded_left() + self.margin,child_widget.rect.y)
-
-
-class MarginRight(Constraint):
-    def __init__(self, margin: float):
-        super().__init__(name="margin_right")
-        self.margin = margin
-
-    def evaluate(self, parent_widget, child_widget):
-        return child_widget.rect.right == parent_widget.get_padded_right() - self.margin
-
-    def apply_constraint(self, parent_widget, child_widget):
-        child_widget.set_position(
-            parent_widget.get_padded_right() - child_widget.rect.w - self.margin,
-            child_widget.rect.y
-        )

batFramework/gui/dialogueBox.py

@@ -1,96 +0,0 @@
-from .label import Label
-import batFramework as bf
-from typing import Self
-
-
-class DialogueBox(Label):
-    def __init__(self) -> None:
-        self.cursor_position: float = 0.0
-        self.text_speed: float = 20.0
-        self.message_queue: list[str] = []
-        self.is_over: bool = True
-        self.is_paused: bool = False
-        self.set_autoresize(False)
-        self.set_alignment(bf.alignment.LEFT)
-        super().__init__("")
-
-    def pause(self)->Self:
-        self.is_paused = True
-        return self
-    
-    def resume(self)->Self:
-        self.is_paused = False
-        return self
-
-    def set_text_speed(self, speed: float) -> Self:
-        self.text_speed = speed
-        return self
-
-    def cut_text_to_width(self, text: str) -> list[str]:
-        w = self.get_padded_width()
-        if text == "" or not self.font_object or  w < self.font_object.point_size:
-            return [text]
-        left = 0
-        for index in range(len(text)):
-            width = self.font_object.size(text[left:index])[0]
-            
-            if width > w:
-                cut_point_start = index - 1
-                cut_point_end = index - 1
-                last_space = text.rfind(' ', 0, cut_point_start)
-                last_nline = text.rfind('\n', 0, cut_point_start)
-
-                if last_space != -1 or last_nline!= -1:  # space was found !:
-                    cut_point_start = max(last_space,last_nline)
-                    cut_point_end = cut_point_start + 1
-                res = [text[:cut_point_start].strip()]
-                res.extend(self.cut_text_to_width(text[cut_point_end:].strip()))
-                return res
-            elif text[index] == '\n':
-                left = index
-        return [text]
-
-    def paint(self)->None:
-        if self.font_object and self.message_queue :
-            message = self.message_queue.pop(0)
-            message = "\n".join(self.cut_text_to_width(message))
-            self.message_queue.insert(0,message)
-        super().paint()
- 
-    def say(self, message: str) ->Self:
-        self.message_queue.append(message)
-        self.is_over = False
-        return self
-    
-    def is_queue_empty(self) -> bool:
-        return not self.message_queue
-
-    def is_current_message_over(self) -> bool:
-        return self.is_over
-
-    def clear_queue(self) -> Self:
-        self.message_queue.clear()
-        self.next_message()
-        return self
-
-    def next_message(self) -> Self:
-        if self.message_queue:
-            self.message_queue.pop(0)
-        self.cursor_position = 0
-        self.set_text("")
-        return self
-
-    def skip_current_message(self)->Self:
-        self.cursor_position = len(self.message_queue[0])
-        self.dirty_shape = True
-
-    def do_update(self, dt):
-        if not self.message_queue or self.is_paused:
-            return
-        if not self.is_over and self.cursor_position == len(self.message_queue[0]):
-            self.is_over = True
-            return
-        self.cursor_position = min(
-            self.cursor_position + self.text_speed * dt, len(self.message_queue[0])
-        )
-        self.set_text(self.message_queue[0][: int(self.cursor_position)])

batFramework/gui/draggableWidget.py

@@ -1,38 +0,0 @@
-from .interactiveWidget import InteractiveWidget
-import batFramework as bf
-import pygame
-
-
-class DraggableWidget(InteractiveWidget):
-    def __init__(self, *args, **kwargs) -> None:
-        self.drag_action = bf.Action("dragging").add_mouse_control(1).set_holding()
-
-        self.drag_start = None
-        self.offset = None
-        super().__init__(*args, **kwargs)
-
-    def do_process_actions(self, event: pygame.Event) -> None:
-        self.drag_action.process_event(event)
-
-    def do_reset_actions(self) -> None:
-        self.drag_action.reset()
-
-    def do_on_drag(self,drag_start:tuple[float,float],drag_end: tuple[float,float])->None:
-        self.set_position(drag_end[0]-self.offset[0],drag_end[1]-self.offset[1])
-
-    def update(self, dt: float):
-        if self.drag_action.active and self.is_clicked_down:
-            r = self.get_root()
-            x, y = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
-            if self.drag_start == None and self.drag_action.active:
-                self.offset = x-self.rect.x,y-self.rect.y
-                self.drag_start = x,y
-                return
-            else:
-                self.do_on_drag(self.drag_start,(x,y))
-                return
-        else:
-            self.drag_start = None
-            self.offset = None
-            self.is_clicked_down = False
-        super().update(dt)

batFramework/gui/meter.py

@@ -1,76 +0,0 @@
-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.content = Shape((0, 0)).set_color(bf.color.BLUE)
-        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
-        self.add(self.content)
-        self.set_padding(1)
-        self.set_outline_width(1)
-        self.set_outline_color(bf.color.BLACK)
-        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:
-            print(
-                f"[Warning] : minimum value {range_min} is greater than or equal to maximum value {range_max}"
-            )
-            return self
-        self.min_value, self.max_value = range_min, range_max
-        self.dirty_shape = True
-
-    def get_debug_outlines(self):
-        yield from super().get_debug_outlines()
-        yield from self.content.get_debug_outlines()
-
-    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 = value
-        self.dirty_surface = 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.max_value - self.min_value)
-
-    def _build_content(self) -> None:
-        width = (self.get_padded_width() * self.get_ratio())
-        self.content.set_size((width, self.get_padded_height()))
-        self.content.set_position(*self.get_padded_rect().topleft)
-
-    def build(self) -> None:
-        super().build()
-        self._build_content()

batFramework/gui/radioButton.py

@@ -1,62 +0,0 @@
-import batFramework as bf
-from typing import Self,Any,Callable
-from .toggle import Toggle
-
-class RadioVariable:...
-
-class RadioButton(Toggle):
-    def __init__(self, text: str, radio_value:Any = 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.radio_variable : RadioVariable = None
-
-    def set_radio_value(self,value:Any)->Self:
-        self.radio_value = value
-        self.update_radio()
-        return self
-    
-    def set_text(self, text: str) -> Self:
-        flag = False
-        if self.value == self.text or self.value is None: flag = True
-        super().set_text(text)
-        if flag:
-            self.set_radio_value(self.text)
-        return self
-
-    def click(self) -> None:
-        if self.radio_variable is None: return
-        self.radio_variable.set_value(self.radio_value)
-
-class RadioVariable:
-    def __init__(self)->None:
-        self.buttons : list[RadioButton] = []
-        self.value = None
-        self.modify_callback : Callable[[Any],] = None
-
-    def link(self,*buttons:RadioButton)->Self:
-        if not buttons : return self
-        for b in buttons : 
-            b.radio_variable = self
-        self.buttons.extend(buttons)
-        
-        if self.value is None:
-            self.set_value(buttons[0].radio_value)
-        else:
-            self.update_buttons() 
-        return self
-
-    def unlink(self,*buttons)->Self:
-        for b in self.buttons:
-            if b in buttons:
-                b.radio_variable = None
-        self.buttons = [b for b in self.buttons if b not in buttons]
-        return self
-
-    def set_value(self,value:Any):
-        if value == self.value: return
-        self.value = value
-        if self.modify_callback :self.modify_callback(value)
-        self.update_buttons() 
-
-    def update_buttons(self):
-        _ = [b.set_value(b.radio_value == self.value,False) for b in self.buttons]