kvex.widgets.buttonbar

  1"""Home of `XButtonBar`."""
  2
  3from typing import Optional, Callable
  4from functools import partial
  5from .layouts import XFrame, XBox
  6from .dropdown import XDropDown
  7from .spinner import XSpinner, XSpinnerOption
  8from ..colors import THEME_NAMES
  9
 10
 11class XButtonBar(XFrame):
 12    """A bar of buttons nested in two layers."""
 13
 14    def __init__(
 15        self,
 16        *,
 17        category_subtheme: Optional[str] = None,
 18        dropdown_subtheme: Optional[str] = None,
 19        nested_subtheme: Optional[str] = None,
 20        **kwargs,
 21    ):
 22        """Initialize the class.
 23
 24        Args:
 25            category_subtheme: Subtheme of category buttons.
 26            dropdown_subtheme: Subtheme of dropdown.
 27            nested_subtheme: Subtheme of nested buttons.
 28        """
 29        super().__init__(**kwargs)
 30        self._category_subtheme = category_subtheme
 31        self._dropdown_subtheme = dropdown_subtheme
 32        self._nested_subtheme = nested_subtheme
 33        self._names: dict[list[str]] = dict()
 34        self._spinners: dict[XSpinner] = dict()
 35        self._callbacks: dict[str, Callable] = dict()
 36        self._box = XBox()
 37        self.add_widget(self._box)
 38        self.register_event_type("on_select")
 39
 40    def _dropdown_factory(self, *args, **kwargs):
 41        return XDropDown(*args, subtheme_name=self._dropdown_subtheme, **kwargs)
 42
 43    def add_category(self, category: str, /, *, display_as: Optional[str] = None):
 44        """Add a category for buttons.
 45
 46        Args:
 47            category: Category name, used for callbacks.
 48            display_as: Button text, defaults to the capitalized category name.
 49        """
 50        if category in self._names:
 51            raise ValueError(f"Category {category!r} already in use.")
 52        if display_as is None:
 53            display_as = category.capitalize()
 54        spinner = XSpinner(
 55            text=display_as,
 56            dropdown_cls=self._dropdown_factory,
 57            option_cls=XButtonBarSpinnerOption,
 58            subtheme_name=self._category_subtheme,
 59        )
 60        self._spinners[category] = spinner
 61        self._box.add_widget(spinner)
 62        self._names[category] = []
 63        spinner.bind(on_select=partial(self._on_spinner_select, category))
 64
 65    def add_button(
 66        self,
 67        category: str,
 68        name: str,
 69        /,
 70        callback: Optional[Callable] = None,
 71        *,
 72        display_as: Optional[str] = None,
 73    ):
 74        """Add a button in a category.
 75
 76        Args:
 77            category: Category name, used for callbacks.
 78            name: Button name, used for callbacks.
 79            callback: Callback when button is pressed.
 80            display_as: Button text, defaults to a the button name formatted.
 81        """
 82        if category not in self._names:
 83            self.add_category(category)
 84        if display_as is None:
 85            display_as = name.replace("_", " ").capitalize()
 86        spinner = self._spinners[category]
 87        with self.app.subtheme_context(self._nested_subtheme):
 88            spinner.values.append(display_as)
 89        self._names[category].append(name)
 90        self._callbacks[f"{category}.{name}"] = callback
 91
 92    def get_button(
 93        self,
 94        category: str,
 95        button: Optional[str] = None,
 96    ) -> XDropDown | XSpinnerOption:
 97        """Get the XSpinnerOption button or XDropDown if no button specified."""
 98        spinner = self._spinners[category]
 99        if not button:
100            return spinner
101        idx = self._names[category].index(button)
102        return spinner._dropdown.container.children[-idx - 1]
103
104    def set_callback(self, category: str, button: str, callback: Callable, /):
105        """Change a callback."""
106        self._callbacks[f"{category}.{button}"] = callback
107
108    def on_select(self, category: str, button: str):
109        """Called when a button is pressed."""
110        pass
111
112    def _on_spinner_select(self, category, w, index, text):
113        button = self._names[category][index]
114        callback = self._callbacks.get(f"{category}.{button}")
115        if callback:
116            callback()
117        self.dispatch("on_select", category, button)
118
119    def add_theme_selectors(
120        self,
121        *,
122        category: str = "Themes",
123        prefix: str = "Change to: ",
124        suffix: str = "",
125    ):
126        """Add theme selection buttons."""
127        for tname in THEME_NAMES:
128            self.add_button(
129                "theme",
130                tname,
131                display_as=f"{prefix}{tname.capitalize()}{suffix}",
132                callback=lambda *a, t=tname: self.app.set_theme(t),
133            )
134
135
136class XButtonBarSpinnerOption(XSpinnerOption):
137    """SpinnerOption."""
138
139    def __init__(self, *args, **kwargs):
140        """Initialize the class."""
141        kwargs |= dict(
142            halign="left",
143            valign="middle",
144            padding=(10, 0),
145            height="32dp",
146        )
147        super().__init__(*args, **kwargs)
148        self.bind(size=self.on_size)
149
150    def on_size(self, w, size):
151        """Fix text size to widget size for alignment."""
152        self.text_size = size
153
154
155__all__ = (
156    "XButtonBar",
157    "XButtonBarSpinnerOption",
158)