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

batFramework/gui/dialogueBox.py

@@ -1,99 +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 __str__(self) -> str:
-        return "DialogueBox"
-
-    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,40 +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,74 +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.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 "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 = range_min
-        self.max_value = 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 = 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)
-
-    def _build_content(self) -> None:
-        width = self.get_padded_width() * self.get_ratio()
-        self.content.set_size((width, self.get_padded_height()))
-        self.content.rect.topleft = self.get_padded_rect().topleft
-
-    def build(self) -> None:
-        super().build()
-        self._build_content()

batFramework/gui/radioButton.py

@@ -1,84 +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 __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
-
-        if self.radio_variable:
-            self.radio_variable.update_buttons()
-        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 set_modify_callback(self, callback) -> Self:
-        self.modify_callback = callback
-        return self
-
-    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) -> Self:
-        if value == self.value:
-            return
-        self.value = value
-        if self.modify_callback:
-            self.modify_callback(value)
-        self.update_buttons()
-        return self
-
-    def update_buttons(self):
-        _ = [b.set_value(b.radio_value == self.value, False) for b in self.buttons]

batFramework/gui/slider.py

@@ -1,240 +0,0 @@
-import batFramework as bf
-from .meter import Meter
-from .button import Button
-from .indicator import *
-from .meter import Meter
-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
-    def __str__(self) -> str:
-        return "SliderHandle"
-
-    def on_click_down(self, button: int) -> None:
-        if not self.parent.is_enabled(): 
-            return
-        super().on_click_down(button)
-        if button == 1:
-            self.parent.get_focus()
-
-    def on_exit(self) -> None:
-        self.is_hovered = False
-        self.do_on_exit()
-
-    def do_on_drag(
-        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
-    ) -> None:
-        if not self.parent.is_enabled(): 
-            return
-        super().do_on_drag(drag_start, drag_end)
-        m: Meter = self.parent.meter
-        r = m.get_padded_rect()
-        position = self.rect.centerx
-        self.rect.clamp_ip(r)
-        # Adjust handle position to value
-        new_value = self.parent.position_to_value(position)
-        self.parent.set_value(new_value)
-        self.rect.centerx = self.parent.value_to_position(new_value)
-
-    def top_at(self, x, y):
-        return Widget.top_at(self, x, y)
-
-
-class SliderMeter(Meter, InteractiveWidget):
-    def __str__(self) -> str:
-        return "SliderMeter"
-
-    def on_click_down(self, button: int) -> None:
-        if not self.parent.is_enabled(): 
-            return
-        if button == 1:
-            self.parent.get_focus()
-            r = self.get_root()
-            if r:
-                pos = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())[0]
-                self.parent.set_value(self.parent.position_to_value(pos))
-        self.do_on_click_down(button)
-
-class Slider(Button):
-    def __init__(self, text: str, default_value: float = 1.0) -> None:
-        super().__init__(text, None)
-        self.gap: float | int = 0
-        self.spacing: bf.spacing = bf.spacing.MANUAL
-        self.modified_callback = None
-        self.meter: SliderMeter = SliderMeter()
-        self.handle = SliderHandle()
-        self.add(self.meter, self.handle)
-        self.meter.set_debug_color(bf.color.RED)
-        self.set_value(default_value, True)
-
-    def set_visible(self, value: bool) -> Self:
-        self.handle.set_visible(value)
-        self.meter.set_visible(value)
-        return super().set_visible(value)
-
-    def __str__(self) -> str:
-        return "Slider"
-
-    def set_gap(self, value: int | float) -> Self:
-        value = max(0, value)
-        self.gap = value
-        return self
-
-    def do_on_get_focus(self) -> None:
-        super().do_on_get_focus()
-        self.old_key_repeat = pygame.key.get_repeat()
-        pygame.key.set_repeat(200, 50)
-
-    def do_on_lose_focus(self) -> None:
-        super().do_on_lose_focus()
-        pygame.key.set_repeat(*self.old_key_repeat)
-
-    def set_spacing(self, spacing: bf.spacing) -> Self:
-        if spacing == self.spacing:
-            return self
-        self.spacing = spacing
-        self.dirty_shape = True
-        return self
-
-    def set_modify_callback(self, callback) -> Self:
-        self.modified_callback = callback
-        return self
-
-    def set_range(self, range_min: float, range_max: float) -> Self:
-        self.meter.set_range(range_min, range_max)
-        self.dirty_shape = True
-        return self
-
-    def set_step(self, step: float) -> Self:
-        self.meter.set_step(step)
-        self.dirty_shape = True
-        return self
-
-    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)
-        return self
-
-    def get_value(self) -> float:
-        return self.meter.get_value()
-
-    def do_on_key_down(self, key):
-        if not self.is_enabled(): 
-            return
-        if key == pygame.K_RIGHT:
-            self.set_value(self.meter.get_value() + self.meter.step)
-        elif key == pygame.K_LEFT:
-            self.set_value(self.meter.get_value() - self.meter.step)
-
-    def do_on_click_down(self, button) -> None:
-        if not self.is_enabled(): 
-            return
-        if button == 1:
-            self.get_focus()
-
-    def value_to_position(self, value: float) -> float:
-        """
-        Converts a value to a position on the meter, considering the step size.
-        """
-        rect = self.meter.get_padded_rect()
-        value_range = self.meter.get_range()
-        value = round(value / self.meter.step) * self.meter.step
-        position_ratio = (value - self.meter.min_value) / value_range
-        return (
-            rect.left
-            + (self.handle.rect.w / 2)
-            + position_ratio * (rect.width - self.handle.rect.w)
-        )
-
-    def position_to_value(self, position: float) -> float:
-        """
-        Converts a position on the meter to a value, considering the step size.
-        """
-        handle_half = self.handle.rect.w / 2
-        rect = self.meter.get_padded_rect()
-        position = max(rect.left + handle_half, min(position, rect.right - handle_half))
-
-        position_ratio = (position - rect.left - handle_half) / (
-            rect.width - self.handle.rect.w
-        )
-        value_range = self.meter.get_range()
-        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]:
-        gap = self.gap if self.text else 0
-        if not self.text_rect:
-            self.text_rect.size = self._get_text_rect_required_size()
-        w, h = self.text_rect.size
-        return self.inflate_rect_by_padding((0, 0, w + gap + self.meter.get_min_required_size()[1], h)).size
-
-    def _build_layout(self) -> None:
-
-        gap = self.gap if self.text else 0
-        self.text_rect.size = self._get_text_rect_required_size()
-
-        #right part size
-        meter_width = self.text_rect.h * 10
-        if not self.autoresize_w:
-            meter_width = self.get_padded_width() - self.text_rect.w - gap
-        right_part_height = min(self.text_rect.h, self.font_object.point_size)
-        self.meter.set_size_if_autoresize((meter_width,right_part_height))
-        self.handle.set_size_if_autoresize((None,right_part_height))
-
-
-        #join left and right
-        joined_rect = pygame.FRect(
-            0, 0, self.text_rect.w + gap + meter_width, self.text_rect.h
-        )
-
-        if self.autoresize_h or self.autoresize_w:
-            target_rect = self.inflate_rect_by_padding(joined_rect)
-            if not self.autoresize_w:
-                target_rect.w = self.rect.w
-            if not self.autoresize_h:
-                target_rect.h = self.rect.h
-            if self.rect.size != target_rect.size:
-                self.set_size(target_rect.size)
-                self.build()
-                return
-
-        # ------------------------------------ size is ok
-        
-
-        offset = self._get_outline_offset() if self.show_text_outline else (0,0)
-        padded_rect = self.get_padded_rect()
-        padded_relative = padded_rect.move(-self.rect.x, -self.rect.y)
-
-        self.align_text(joined_rect, padded_relative.move( offset), self.alignment)
-        self.text_rect.midleft = joined_rect.midleft
-
-        if self.text:
-            match self.spacing:
-                case bf.spacing.MAX:
-                    gap = padded_relative.right - self.text_rect.right - self.meter.rect.w
-                case bf.spacing.MIN:
-                    gap = 0
-
-        # place meter
-
-        pos = self.text_rect.move(
-                self.rect.x + gap -offset[0],
-                self.rect.y + (self.text_rect.h / 2) - (right_part_height / 2) -offset[1],
-            ).topright
-        self.meter.rect.topleft = pos
-        # place handle
-
-        x = self.value_to_position(self.meter.value)
-        r = self.meter.get_padded_rect()
-        self.handle.set_center(x, r.centery)
-
-        # self.handle.set_center(x,self.rect.top)

batFramework/gui/style.py

@@ -1,10 +0,0 @@
-from .widget import Widget
-
-
-class Style:
-
-    def __init__(self):
-        pass
-
-    def apply(self, widget: Widget):
-        pass

batFramework/gui/styleManager.py

@@ -1,48 +0,0 @@
-from ..utils import Singleton
-from .widget import Widget
-
-
-class Style:
-    def __init__(self):
-        pass
-
-    def apply(self, widget: Widget):
-        pass
-
-
-class StyleManager(metaclass=Singleton):
-    def __init__(self):
-        self.styles: list[Style] = []
-        self.widgets: set[Widget] = set()
-        self.lookup: dict[Widget, bool] = {}
-
-    def register_widget(self, widget: Widget):
-        if widget in self.widgets:
-            return
-        self.widgets.add(widget)
-        self.lookup[widget] = False
-        self.update()
-
-    def refresh_widget(self, widget: Widget):
-        if widget in self.widgets:
-            self.lookup[widget] = True
-            self.update()
-
-    def remove_widget(self, widget: Widget):
-        if widget not in self.widgets:
-            return
-        self.widgets.remove(widget)
-        self.lookup.pop(widget)
-
-    def add(self, style: Style):
-        self.styles.append(style)
-        self.lookup = {key: False for key in self.lookup}
-        self.update()
-
-    def update(self):
-        for widget in self.widgets:
-            if self.lookup[widget]:
-                continue
-            for style in self.styles:
-                style.apply(widget)
-            self.lookup[widget] = True