data-sourcerer 0.1.0__py3-none-any.whl

sourcerer/presentation/screens/main/mixins/resize_containers_watcher_mixin.py

@@ -0,0 +1,144 @@
+import time
+
+from textual.events import MouseMove, MouseUp
+
+from sourcerer.presentation.screens.main.messages.resizing_rule import (
+    ResizingRuleSelect,
+    ResizingRuleRelease,
+    ResizingRuleMove,
+)
+from sourcerer.presentation.screens.main.widgets.resizing_rule import (
+    ResizingRule,
+    MoveEvent,
+)
+from sourcerer.presentation.settings import MIN_SECTION_DIMENSION
+
+
+class ResizeContainersWatcherMixin:
+    """
+    Watches and handles the resizing of containers in a user interface.
+
+    The ResizeContainersWatcher class provides functionality to manage and respond
+    to events related to resizing operations. It handles events for selecting,
+    moving, and releasing resizing rules, ensuring that the resizing operation is
+    properly executed and the state is consistently maintained. This class also
+    manages interactions like dragging and concludes resizing tasks when necessary.
+
+    Class should be used as a mixin in classes that require resizing functionality
+    and is inherited from textual App.
+    """
+
+    required_methods = ["query_one", "refresh"]
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        for method in cls.required_methods:
+            if not hasattr(cls, method) or not callable(getattr(cls, method)):
+                raise TypeError(f"Class {cls.__name__} must implement method {method}")
+
+    def __init__(self, *args, **kwargs):
+        self.active_resizing_rule: ResizingRule | None = None
+
+    def on_resizing_rule_select(self, event: ResizingRuleSelect) -> None:
+        """
+        Handle the selection of a resizing rule by updating the active resizing rule.
+        Called when the user press a resizing rule.
+
+        Arguments:
+            event (ResizingRuleSelect): The event containing the resizing rule id.
+        """
+        self.active_resizing_rule = self.query_one(f"#{event.id}")  # type: ignore
+
+    def on_resizing_rule_release(self, _: ResizingRuleRelease) -> None:
+        """
+        Handle the release (completion) of the resizing rule.
+
+        This method is responsible for resetting the active resizing rule
+        back to None when a resizing operation is concluded. It ensures
+        that the system correctly cleans up and transitions out of the
+        resizing state.
+
+        Arguments:
+            _: The `ResizingRuleRelease` object that represents the
+               event or the logic related to ending the resizing operation.
+        """
+        self.active_resizing_rule = None
+
+    def on_resizing_rule_move(self, event: ResizingRuleMove) -> None:
+        """
+        Handles the resizing of components during a move event and updates their styles
+        accordingly. This method adjusts the width or height of the components involved
+        based on the orientation and the delta value from the event, ensuring minimum
+        dimensions are maintained. Refreshes the display after updating the styles.
+
+        Arguments:
+            event (ResizingRuleMove): The event containing the resizing rule details.
+        """
+
+        prev_component = self.query_one(f"#{event.previous_component_id}")  # type: ignore
+        next_component = self.query_one(f"#{event.next_component_id}")  # type: ignore
+
+        dimension = "width" if event.orientation == "vertical" else "height"
+
+        previous_component_dimension = (
+            getattr(prev_component.styles, dimension).value + event.delta
+        )
+        next_component_dimension = (
+            getattr(next_component.styles, dimension).value - event.delta
+        )
+
+        if (
+            previous_component_dimension < MIN_SECTION_DIMENSION
+            or next_component_dimension < MIN_SECTION_DIMENSION
+        ):
+            return
+
+        setattr(prev_component.styles, dimension, f"{previous_component_dimension}%")
+        setattr(next_component.styles, dimension, f"{next_component_dimension}%")
+
+        self.refresh()  # type: ignore
+
+    def on_mouse_move(self, event: MouseMove) -> None:
+        """
+        Handles mouse movement events to manage resizing operations based on the active resizing
+        rule. The function determines the change in position (delta) either horizontally or
+        vertically, depending on the orientation of the active resizing rule. If the resizing
+        rule is active and dragging is occurring, it updates the position accordingly.
+
+        Arguments:
+            event (MouseMove): The event containing the mouse movement details.
+        """
+
+        if not self.active_resizing_rule or not self.active_resizing_rule.dragging:
+            return
+
+        try:
+            delta = (
+                event.delta_x
+                if self.active_resizing_rule.orientation == "vertical"
+                else event.delta_y
+            )
+        except AttributeError:
+            return  # No delta
+
+        self.active_resizing_rule.position = MoveEvent(
+            timestamp=time.time(), delta=delta
+        )
+
+    def on_mouse_up(self, _: MouseUp) -> None:
+        """
+        Handles the mouse-up event during a resizing rule interaction.
+
+        This method is invoked when the mouse-up event is detected. It checks if
+        there is an active resizing rule in operation. If such a rule exists, the
+        method ensures proper cleanup activities are performed and then clears the
+        active resizing rule, resetting it to None.
+
+        Arguments:
+            _: The `MouseUp` object that represents the mouse-up event.
+        """
+        if not self.active_resizing_rule:
+            return
+        self.active_resizing_rule.cleanup()
+        self.active_resizing_rule = None

sourcerer/presentation/screens/main/styles.tcss

@@ -0,0 +1,32 @@
+
+StorageListSidebar {
+  width: 20%;
+}
+
+StorageContent {
+  width: 80%;
+}
+
+#controls {
+  height: auto;
+  align-horizontal: center;
+
+  & > Button {
+    border: solid $primary;
+    width: 10;
+    content-align-horizontal: center;
+  }
+}
+
+#header {
+  height: 3;
+  width: 100%;
+  color: white;
+  padding: 1 1 0 1;
+}
+
+Rule {
+  color: $background-lighten-3;
+  padding: 0 0;
+  margin: 0 0;
+}

sourcerer/presentation/screens/main/widgets/gradient.py

@@ -0,0 +1,45 @@
+from textual.widgets import Static
+from rich.text import Text
+
+
+def hex_to_rgb(hex_color: str):
+    """
+    Convert a hex color string to an RGB tuple.
+    """
+    hex_color = hex_color.lstrip("#")
+    return tuple(int(hex_color[i : i + 2], 16) for i in (0, 2, 4))
+
+
+def generate_gradient_text(text: str, start_color: str, end_color: str) -> Text:
+    """
+    Generate a gradient text effect by blending two colors across the text.
+    """
+    start_rgb = hex_to_rgb(start_color)
+    end_rgb = hex_to_rgb(end_color)
+
+    gradient_text = Text()
+
+    for i, char in enumerate(text):
+        if len(text) > 1:
+            blend = i / (len(text) - 1)
+        else:
+            blend = 0
+
+        r = int(start_rgb[0] + (end_rgb[0] - start_rgb[0]) * blend)
+        g = int(start_rgb[1] + (end_rgb[1] - start_rgb[1]) * blend)
+        b = int(start_rgb[2] + (end_rgb[2] - start_rgb[2]) * blend)
+
+        color = f"#{r:02x}{g:02x}{b:02x}"
+        gradient_text.append(char, style=color)
+
+    return gradient_text
+
+
+class GradientWidget(Static):
+
+    def on_mount(self):
+        """
+        Generate a gradient text effect for the widget's content.
+        """
+        gradient = generate_gradient_text(str(self.renderable), "#9E53E0", "#FFA656")
+        self.update(gradient)

sourcerer/presentation/screens/main/widgets/resizing_rule.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass
+
+from textual.events import MouseDown, MouseUp
+from textual.reactive import reactive
+from textual.widgets import Rule
+
+from sourcerer.presentation.screens.main.messages.resizing_rule import (
+    ResizingRuleMove,
+    ResizingRuleSelect,
+    ResizingRuleRelease,
+)
+
+
+@dataclass
+class MoveEvent:
+    timestamp: float
+    delta: int
+
+
+class ResizingRule(Rule, can_focus=True):
+    dragging: reactive[bool] = reactive(False)
+    position: reactive[MoveEvent | None] = reactive(None)
+
+    def __init__(self, prev_component_id, next_component_id, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not kwargs.get("id"):
+            raise ValueError("ResizingRule must have an id")
+        self.prev_component_id = prev_component_id
+        self.next_component_id = next_component_id
+
+    def on_mouse_down(self, _: MouseDown) -> None:
+        """Start dragging when the separator is clicked."""
+        self.dragging = True
+        self.post_message(ResizingRuleSelect(id=self.id))  # type: ignore
+
+    def on_mouse_up(self, _: MouseUp) -> None:
+        """Stop dragging when mouse is released."""
+        self.cleanup()
+
+    def watch_position(self):
+        """
+        Watch for changes in the position and post a ResizingRuleMove message if dragging is active.
+        """
+        if not self.dragging:
+            return
+
+        if self.position is None:
+            return
+
+        self.post_message(
+            ResizingRuleMove(
+                delta=self.position.delta,
+                previous_component_id=self.prev_component_id,
+                next_component_id=self.next_component_id,
+                orientation=self.orientation,
+            )
+        )
+
+    def cleanup(self):
+        """
+        Resets the dragging state and position, and posts a ResizingRuleRelease message to signal the end of a resize
+        operation.
+        """
+        self.dragging = False
+        self.position = None
+
+        self.post_message(ResizingRuleRelease(id=self.id))  # type: ignore