py10x-universe 0.1.3__py3-none-any.whl

ui_10x/rio/widgets/message_box.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import ui_10x.platform_interface as i
+import ui_10x.rio.components as rio_components
+from ui_10x.rio.component_builder import Widget
+
+# noinspection PyCompatibility
+from . import (
+    Application,
+    Dialog,
+    HBoxLayout,
+    Label,
+    PushButton,
+    Style,
+    VBoxLayout,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class Separator(Widget, i.Separator):
+    s_component_class = rio_components.Separator
+    s_forced_kwargs = {}
+
+
+class MessageBox(i.MessageBox):
+    @classmethod
+    def _dialog(cls, parent: Widget, title: str, message: str, icon: Style.StandardPixmap, on_close: Callable[[Any], None]) -> bool | None:
+        style = Application.style()
+        if icon == Style.StandardPixmap.SP_MESSAGEBOXQUESTION:
+            buttons = [
+                PushButton(style.standard_icon(Style.StandardPixmap.SP_DIALOGYESBUTTON.value), 'Yes', on_press=lambda: dlg.on_accept()),
+                PushButton(style.standard_icon(Style.StandardPixmap.SP_DIALOGNOBUTTON.value), 'No', on_press=lambda: dlg.on_reject()),
+            ]
+        else:
+            buttons = [PushButton(style.standard_icon(Style.StandardPixmap.SP_DIALOGOKBUTTON.value), 'Ok', on_press=lambda: dlg.on_accept())]
+        children = (
+            Label(title, align_x=0.5, align_y=0, style='heading1'),
+            Separator(),
+            HBoxLayout(
+                PushButton(style.standard_icon(icon.value), '', style='plain-text', is_sensitive=False, align_y=0, align_x=0, grow_x=False),
+                Label(message, align_y=0, overflow='wrap', grow_x=True),
+            ),
+            Separator(),
+            HBoxLayout(*buttons),
+        )
+        dlg = Dialog(
+            parent=parent, title=title, children=children, on_accept=lambda: on_close(dlg.accepted), on_reject=lambda: on_close(dlg.accepted)
+        )
+        dlg.set_layout(VBoxLayout())
+        return dlg.show() if on_close else dlg.exec()
+
+    @classmethod
+    def question(cls, parent: Widget, title: str, message: str, on_close: Callable[[Any], None]) -> bool:
+        return cls._dialog(parent=parent, title=title, message=message, icon=Style.StandardPixmap.SP_MESSAGEBOXQUESTION, on_close=on_close)
+
+    @classmethod
+    def warning(cls, parent: Widget, title: str, message: str, on_close: Callable[[Any], None]):
+        return cls._dialog(parent=parent, title=title, message=message, icon=Style.StandardPixmap.SP_MESSAGEBOXWARNING, on_close=on_close)
+
+    @classmethod
+    def information(cls, parent: Widget, title: str, message: str, on_close: Callable[[Any], None]):
+        return cls._dialog(parent=parent, title=title, message=message, icon=Style.StandardPixmap.SP_MESSAGEBOXINFORMATION, on_close=on_close)
+
+    @classmethod
+    def is_yes_button(cls, sb) -> bool:
+        return sb

ui_10x/rio/widgets/scroll_area.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from core_10x.named_constant import Enum
+
+import rio
+import ui_10x.platform_interface as i
+from ui_10x.rio.component_builder import Widget
+
+
+class SCROLL(Enum):
+    OFF = 'never'
+    ON = 'always'
+    AS_NEEDED = 'auto'
+
+
+class ScrollArea(Widget, i.ScrollArea):
+    s_component_class = rio.ScrollContainer
+
+    def set_widget(self, w: Widget):
+        self.set_children([w])
+
+    def set_horizontal_scroll_bar_policy(self, h):
+        self._set_scrollbar_policy('scroll_x', h)
+
+    def set_vertical_scroll_bar_policy(self, h):
+        self._set_scrollbar_policy('scroll_y', h)
+
+    def _set_scrollbar_policy(self, scroll: Literal['scroll_x', 'scroll_y'], policy: SCROLL):
+        self[scroll] = policy.label

ui_10x/rio/widgets/spacer.py

@@ -0,0 +1,6 @@
+import rio
+from ui_10x.rio.component_builder import Widget
+
+
+class Spacer(Widget):
+    s_component_class = rio.Spacer

ui_10x/rio/widgets/splitter.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from core_10x.named_constant import Enum
+
+import ui_10x.platform_interface as i
+import ui_10x.rio.components as rio_components
+from ui_10x.rio.component_builder import Widget
+
+
+class Direction(Enum):
+    VERTICAL = 'vertical'
+    HORIZONTAL = 'horizontal'
+
+
+Horizontal = Direction.HORIZONTAL
+
+
+class Splitter(Widget, i.Splitter):
+    s_component_class = rio_components.Splitter
+    s_pass_children_in_kwargs = True
+
+    def _make_kwargs(self, **kwargs):
+        kwargs = super()._make_kwargs(**kwargs)
+        if kwargs['direction'] == Horizontal.label:
+            del kwargs['align_y']
+            kwargs['grow_y'] = True
+        kwargs['child_proportions'] = []
+        return kwargs
+
+    def __init__(self, direction: Direction = Horizontal, **kwargs):
+        super().__init__(**kwargs | dict(direction=direction.label))
+
+    def add_widget(self, widget: Widget):
+        self.add_children(widget)
+        self['child_proportions'].append(1)
+
+    def set_handle_width(self, width: int):
+        self['handle_size'] = width
+
+    def set_stretch_factor(self, widget_index: int, factor: int):
+        self['child_proportions'][widget_index] = factor  # TODO: normalize?
+
+    def replace_widget(self, widget_index: int, widget: Widget):
+        self.get_children()[widget_index] = widget
+        self.force_update()

ui_10x/rio/widgets/text_edit.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import rio
+import ui_10x.platform_interface as i
+from ui_10x.rio.component_builder import Widget
+
+
+class TextEdit(Widget, i.TextEdit):
+    s_component_class = rio.MultiLineTextInput
+
+    def _make_kwargs(self, **kwargs):
+        kw = super()._make_kwargs(**kwargs)
+        handler = self.focus_out_event
+        if handler.__func__ != TextEdit.focus_out_event:  # do not set unless implemented
+            kw['on_lose_focus'] = self.callback(handler)
+        # TODO: test clipboard interactions
+        return kw
+
+    def to_plain_text(self) -> str:
+        return self['text']
+
+    def set_plain_text(self, text: str):
+        self['text'] = text
+
+    def set_read_only(self, readonly: bool):
+        self['is_sensitive'] = not readonly
+
+    def focus_out_event(self, event): ...

ui_10x/rio/widgets/tree.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from functools import partial
+
+import ui_10x.platform_interface as i
+import ui_10x.rio.components as rio_components
+from ui_10x.rio.component_builder import Widget
+
+
+class TreeItem(Widget, i.TreeItem):
+    __slots__ = ('handlers',)
+    s_component_class = rio_components.RioTreeItem
+    s_pass_children_in_kwargs = True
+
+    def __init__(self, parent: TreeWidget | TreeItem, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        parent[self.s_children_attr] = parent[self.s_children_attr] + [self]
+        self.handlers = parent.handlers
+        for name, callback in self.handlers.items():
+            self[name.replace('_item_', '_')] = partial(callback, self)
+
+    def set_expanded(self, expanded: bool):
+        self['is_expanded'] = expanded
+
+    # noinspection PyMethodOverriding
+    def set_text(self, col: int, text: str):
+        super().set_text(text)
+
+    # noinspection PyMethodOverriding
+    def set_tool_tip(self, col: int, text: str):
+        super().set_tool_tip(text)
+
+
+class TreeWidget(Widget, i.TreeWidget):
+    __slots__ = ('handlers',)
+    s_component_class = rio_components.RioTreeView
+    s_default_kwargs = dict(selection_mode='single')
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.handlers = {}
+
+    def set_column_count(self, col_count: int):
+        """Set the number of columns in the tree widget."""
+        assert col_count in [1, 2], 'col_count must be 1 or 2'
+        self['col_count'] = col_count
+
+    def set_header_labels(self, labels: list):
+        """Set the header labels for each column."""
+        self['header_labels'] = labels
+
+    def top_level_item_count(self) -> int:
+        """Return the number of top-level items."""
+        return len(self.get_children())
+
+    def top_level_item(self, i: int) -> TreeItem:
+        """Return the top-level item at index i."""
+        return self.get_children()[i]
+
+    def resize_column_to_contents(self, col: int):
+        """Adjust the width of the specified column (placeholder)."""
+        pass
+
+    def item_expanded_connect(self, bound_method):
+        self.handlers['on_item_expand'] = self.callback(bound_method)
+
+    def item_clicked_connect(self, bound_method):
+        # self.handlers['on_item_double_press'] = bound_method
+        self.handlers['on_item_press'] = self.callback(bound_method)
+
+    def item_pressed_connect(self, bound_method):
+        self.handlers['on_item_press'] = bound_method
+
+    def item_changed_connect(self, bound_method):
+        raise NotImplementedError
+
+    def edit_item(self, item: TreeItem, col: int):
+        """Start editing the specified item in the given column (placeholder)."""
+        # self.component.start_editing(item, col)
+        raise NotImplementedError
+
+    def open_persistent_editor(self, item: TreeItem, col: int):
+        """Open a persistent editor for the specified item and column (placeholder)."""
+        # self.component.open_persistent_editor(item, col)
+        raise NotImplementedError
+
+    def add_top_level_item(self, item: TreeItem):
+        """Add a top-level item to the tree (helper method)."""
+        self.get_children().append(item)

ui_10x/rio/widgets/unit_tests/test_button.py

@@ -0,0 +1,101 @@
+import asyncio
+
+import rio.testing.browser_client
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import PushButton
+
+
+async def test_button_comprehensive() -> None:
+    """Test PushButton with comprehensive client-widget interaction verification."""
+    widget = PushButton('Click Me')
+    find_button_text = 'document.querySelector(".rio-button .rio-text").children[0].innerText'
+
+    clicked_calls = []
+
+    def clicked_handler():
+        clicked_calls.append(True)
+
+    widget.clicked_connect(clicked_handler)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # 1) Verify client shows widget value
+        assert widget['content'] == 'Click Me'
+        client_text = await test_client.execute_js(find_button_text)
+        assert client_text == 'Click Me'
+
+        # 2) Modify client value (user clicking button)
+        await test_client.click(10, 10)  # Click on the button
+
+        # 3) Verify widget reflects client value (click handler called)
+        assert len(clicked_calls) == 1
+        assert clicked_calls[0] is True
+
+        # Test another click
+        await test_client.click(10, 10)
+        assert len(clicked_calls) == 2
+
+
+async def test_button_disabled_interaction() -> None:
+    """Test PushButton disabled state blocks user interaction."""
+    widget = PushButton('Test Button')
+
+    clicked_calls = []
+
+    def clicked_handler():
+        clicked_calls.append(True)
+
+    widget.clicked_connect(clicked_handler)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial enabled state - clicks should work
+        await test_client.click(10, 10)
+        assert len(clicked_calls) == 1
+
+        # Disable widget
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+        assert not widget['is_sensitive']
+
+        # Test that clicks are blocked when disabled
+        await test_client.click(10, 10)
+        assert len(clicked_calls) == 1  # No additional calls
+
+        # Re-enable widget
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+        assert widget['is_sensitive']
+
+        # Test that clicks work again
+        await test_client.click(10, 10)
+        assert len(clicked_calls) == 2
+
+
+async def test_button_basic_functionality() -> None:
+    """Test PushButton basic functionality."""
+    widget = PushButton('Test Button')
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial state
+        assert widget['content'] == 'Test Button'
+        assert widget['is_sensitive']
+
+        # Test enabled/disabled state with timeout protection
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+        assert not widget['is_sensitive']
+
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+        assert widget['is_sensitive']
+
+        # Test flat style changes with timeout protection
+        assert not await test_client.execute_js('document.querySelector(".rio-buttonstyle-plain-text")')
+        widget.set_flat(True)
+        await test_client.wait_for_refresh()
+        assert await test_client.execute_js('document.querySelector(".rio-buttonstyle-plain-text")')

ui_10x/rio/widgets/unit_tests/test_button_group.py

@@ -0,0 +1,33 @@
+import asyncio
+
+import rio.testing.browser_client
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets.button_group import ButtonGroup, RadioButton
+
+
+async def test_button_group() -> None:
+    group = ButtonGroup()
+    btn1 = RadioButton(label='A', value='A')
+    btn2 = RadioButton(label='B', value='B')
+    group.add_button(btn1, 0)
+    group.add_button(btn2, 1)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(group)) as test_client:
+        await asyncio.sleep(0.5)
+        # Initially, nothing selected
+        assert group.checked_id() == -1
+
+        # Select first button
+        btn1.set_checked(True)
+        await test_client.wait_for_refresh()
+        assert group.checked_id() == 0
+
+        # Select second button
+        btn2.set_checked(True)
+        await test_client.wait_for_refresh()
+        assert group.checked_id() == 1
+
+        # Deselect second button
+        btn2.set_checked(False)
+        await test_client.wait_for_refresh()
+        assert group.checked_id() == -1

ui_10x/rio/widgets/unit_tests/test_calendar.py

@@ -0,0 +1,114 @@
+import asyncio
+from datetime import date
+
+import dateutil.parser
+import rio.testing
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import CalendarWidget
+
+find_selected_date = (
+    'document.querySelector(".rio-calendar-selected-day").textContent + " " + document.querySelector(".rio-calendar-year-month-display").textContent'
+)
+
+
+async def verify_content(widget, test_client):
+    selected_date = await test_client.execute_js(find_selected_date)
+
+    assert dateutil.parser.parse(selected_date).date() == widget.selected_date()
+
+
+async def test_calendar_comprehensive() -> None:
+    """Test CalendarWidget with comprehensive client-widget interaction verification."""
+    widget = CalendarWidget()
+    test_date = date(2024, 6, 15)
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # 1) Verify client shows widget value (initial state)
+        assert widget.selected_date() == date.today()
+
+        # Verify client shows the expected date
+        await verify_content(widget, test_client)
+
+        # 2) Modify widget value and verify client reflects it
+        widget.set_selected_date(test_date)
+        await test_client.wait_for_refresh()
+        assert widget.selected_date() == test_date
+
+        # Verify client shows the expected date
+        await verify_content(widget, test_client)
+
+        # Test another date change
+        new_date = date(2024, 8, 20)
+        widget.set_selected_date(new_date)
+        await test_client.wait_for_refresh()
+        assert widget.selected_date() == new_date
+
+        # Verify client shows the new expected date
+        await verify_content(widget, test_client)
+
+
+async def test_calendar_disabled_interaction() -> None:
+    """Test CalendarWidget disabled state."""
+    widget = CalendarWidget()
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial enabled state
+        assert widget['is_sensitive']
+
+        # Disable widget
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+        assert not widget['is_sensitive']
+        await verify_content(widget, test_client)
+
+        # Test that date changes still work (programmatic changes are allowed)
+        widget.set_selected_date(date(2024, 12, 25))
+        await test_client.wait_for_refresh()
+        assert widget.selected_date() == date(2024, 12, 25)
+
+        # Verify client shows the expected date even when disabled
+        await verify_content(widget, test_client)
+
+        # Re-enable widget
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+        assert widget['is_sensitive']
+
+        # Test that date changes continue to work
+        widget.set_selected_date(date(2024, 1, 1))
+        await test_client.wait_for_refresh()
+        assert widget.selected_date() == date(2024, 1, 1)
+
+        # Verify client shows the final expected date
+        await verify_content(widget, test_client)
+
+
+async def test_calendar_basic_functionality() -> None:
+    """Test CalendarWidget basic functionality."""
+    widget = CalendarWidget()
+
+    async with rio.testing.DummyClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial state
+        assert widget is not None
+        assert widget['is_sensitive']
+
+        # Test date setting
+        test_date = date(2024, 3, 10)
+        widget.set_selected_date(test_date)
+        await test_client.wait_for_refresh()
+        assert widget.selected_date() == test_date
+
+        # Test enabled/disabled state
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+        assert not widget['is_sensitive']
+
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+        assert widget['is_sensitive']

ui_10x/rio/widgets/unit_tests/test_checkbox.py

@@ -0,0 +1,109 @@
+import asyncio
+
+import rio.testing
+from ui_10x.rio.component_builder import DynamicComponent
+from ui_10x.rio.widgets import CheckBox
+
+
+async def test_checkbox_comprehensive() -> None:
+    """Test CheckBox with comprehensive client-widget interaction verification."""
+    widget = CheckBox('Check me')
+    find_checkbox = 'document.querySelector("input[type=\'checkbox\']")'
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # 1) Verify client shows widget value (unchecked initially)
+        assert not widget.is_checked()
+        client_checked = await test_client.execute_js(find_checkbox + '.checked')
+        assert client_checked is False
+
+        # 2) Modify client value (user clicking checkbox)
+        await test_client.execute_js(find_checkbox + '.click();')
+        await asyncio.sleep(0.5)  # Wait for event processing
+
+        # 3) Verify widget reflects client value
+        assert widget.is_checked()
+        client_checked = await test_client.execute_js(find_checkbox + '.checked')
+        assert client_checked is True
+
+        # Test widget changes propagate to client
+        widget.set_checked(False)
+        await test_client.wait_for_refresh()
+        client_checked = await test_client.execute_js(find_checkbox + '.checked')
+        assert client_checked is False
+        assert not widget.is_checked()
+
+        # Test another client interaction
+        await test_client.execute_js(find_checkbox + '.click();')
+        await asyncio.sleep(0.5)
+        assert widget.is_checked()
+
+
+async def test_checkbox_disabled_interaction() -> None:
+    """Test CheckBox disabled state blocks user interaction."""
+    widget = CheckBox('Test Checkbox')
+    find_checkbox = 'document.querySelector("input[type=\'checkbox\']")'
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial enabled state - clicks should work
+        await test_client.execute_js(find_checkbox + '.click();')
+        await asyncio.sleep(0.5)
+        assert widget.is_checked()
+
+        # Disable widget
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+
+        # Verify client shows disabled state
+        client_disabled = await test_client.execute_js(find_checkbox + '.disabled')
+        assert client_disabled is True
+
+        # Test that clicks are blocked when disabled
+        initial_checked = widget.is_checked()
+        await test_client.execute_js(find_checkbox + '.click();')
+        await asyncio.sleep(0.5)
+        assert widget.is_checked() == initial_checked  # State should not change
+
+        # Re-enable widget
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()
+
+        # Verify client shows enabled state
+        client_disabled = await test_client.execute_js(find_checkbox + '.disabled')
+        assert client_disabled is False
+
+        # Test that clicks work again
+        await test_client.execute_js(find_checkbox + '.click();')
+        await asyncio.sleep(0.5)
+        assert not widget.is_checked()  # Should toggle
+
+
+async def test_checkbox_basic_functionality() -> None:
+    """Test CheckBox basic functionality without client interaction."""
+    widget = CheckBox('Test Checkbox')
+
+    async with rio.testing.BrowserClient(lambda: DynamicComponent(widget)) as test_client:
+        await asyncio.sleep(0.5)
+
+        # Test initial state
+        assert not widget.is_checked()
+
+        # Test checking
+        widget.set_checked(True)
+        await test_client.wait_for_refresh()
+        assert widget.is_checked()
+
+        # Test unchecking
+        widget.set_checked(False)
+        await test_client.wait_for_refresh()
+        assert not widget.is_checked()
+
+        # Test enabled/disabled state
+        widget.set_enabled(False)
+        await test_client.wait_for_refresh()
+
+        widget.set_enabled(True)
+        await test_client.wait_for_refresh()