jbqt 0.1.1__py3-none-any.whl

jbqt/widgets/__init__.py

@@ -0,0 +1,16 @@
+"""Collection of widget exports"""
+
+from jbqt.widgets.chip_button import ChipButton
+from jbqt.widgets.chips import ChipsWidget
+from jbqt.widgets.multiselect import MultiSelectComboBox
+from jbqt.widgets.simple import ClickableLabel, LongIntSpinBox
+from jbqt.widgets.toast import Toast
+
+__all__ = [
+    "ChipButton",
+    "ChipsWidget",
+    "MultiSelectComboBox",
+    "ClickableLabel",
+    "LongIntSpinBox",
+    "Toast",
+]

jbqt/widgets/chip_button.py

@@ -0,0 +1,204 @@
+from re import Pattern
+from typing import Callable
+
+from PyQt6.QtCore import Qt, QEvent, QObject
+from PyQt6.QtGui import QKeyEvent
+from PyQt6.QtWidgets import (
+    QHBoxLayout,
+    QLineEdit,
+    QPushButton,
+    QFrame,
+    QWidget,
+)
+
+from jbqt.common import consts
+from jbqt.common.consts import STYLES, COLORS
+from jbqt.models import IChipButton
+from jbqt.widgets.simple import ClickableLabel
+from jbqt.dialogs import InputDialog
+from jbqt.widgets.widget_utils import (
+    debug_scroll_pos,
+    preserve_scroll,
+)
+
+
+class ChipButton(IChipButton):
+    def __init__(
+        self,
+        tag: str,
+        on_update: Callable,
+        on_remove: Callable,
+        use_weight: bool = False,
+        weight_re: Pattern = None,
+        debug: bool = False,
+    ):
+        super().__init__()
+
+        self._tag = tag
+        self.weight: float = 1.0
+        self.use_weight: bool = use_weight
+
+        if use_weight:
+            weight_re = weight_re or consts.TAG_RE
+
+        if weight_re:
+            tag_match = weight_re.search(tag)
+
+            if tag_match:
+                re_tag, weight = tag_match.groups()
+                self._tag = re_tag
+                self.weight = float(weight)
+
+        self.on_update = on_update
+        self.on_remove = on_remove
+        self.installEventFilter(self)
+
+        # Layout for the tag button
+        # self.frame = QFrame(self, Qt.WindowType.ToolTip)
+        self.frame = QFrame()
+        frame_layout = QHBoxLayout(self.frame)
+        frame_layout.setSpacing(5)
+        frame_layout.setContentsMargins(10, 0, 10, 0)
+
+        self.tag_label = ClickableLabel(tag)
+        self.tag_label.setFixedHeight(24)
+        self.tag_label.clicked.connect(self.toggle_edit_mode)
+
+        self.weight_button: QPushButton = None
+
+        if use_weight:
+            self.weight_button = QPushButton(consts.ICONS.CODE(), "")
+            self.weight_button.clicked.connect(self.apply_weight)
+            self.weight_button.setFixedWidth(24)
+
+        self.remove_button = QPushButton(consts.ICONS.TRASH(), "")
+        self.remove_button.clicked.connect(lambda: self.on_remove(self))
+        self.remove_button.setFixedWidth(24)
+        self.remove_button.setStyleSheet(STYLES.BG_DARK_RED)
+
+        self.edit_line = QLineEdit(self)
+        self.edit_line.hide()
+
+        self.confirm_btn = QPushButton(consts.ICONS.CIRCLE_CHECK(COLORS.WHITE), "")
+        self.confirm_btn.clicked.connect(self.edit_tag)
+        self.confirm_btn.setFixedWidth(24)
+        self.confirm_btn.setStyleSheet(STYLES.BG_DARK_GREEN)
+        self.confirm_btn.hide()
+
+        self.cancel_btn = QPushButton(consts.ICONS.CIRCLE_TIMES(), "")
+        self.cancel_btn.clicked.connect(self.cancel)
+        self.cancel_btn.setFixedWidth(24)
+        self.cancel_btn.setStyleSheet(STYLES.BG_DARK_RED)
+        self.cancel_btn.hide()
+
+        self.widgets = [
+            self.tag_label,
+            self.edit_line,
+            self.confirm_btn,
+            self.cancel_btn,
+            self.weight_button,
+            self.remove_button,
+        ]
+        self.input_widgets = [self.edit_line, self.confirm_btn, self.cancel_btn]
+        for widget in self.widgets:
+            if widget:
+                frame_layout.addWidget(widget)
+
+        # Main layout
+        self.main_layout = QHBoxLayout(self)
+        self.main_layout.addWidget(self.frame)
+        self.main_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+        # Apply styling to the frame
+        self.frame.setStyleSheet(
+            f"""
+            QFrame {{
+                border: 1px solid #AAA;
+                border-radius: 10px;
+                background-color: #343439;
+                max-height: 36px;
+            }}
+            QLabel {{
+                border: none;
+            }}
+            QPushButton {{
+                {STYLES.BG_GRAY}   
+            }}
+        """
+        )
+        self.setLayout(self.main_layout)
+
+    @property
+    def text(self) -> str:
+        if self.weight == 1:
+            return self._tag
+        return f"({self._tag}){self.weight:g}"
+
+    @text.setter
+    def text(self, value: str) -> None:
+        self._tag = value
+
+    def eventFilter(self, obj: QObject, event: QKeyEvent) -> bool:
+        focus = consts.GlobalRefs.app.focusWidget()
+        """ if event.type() == QEvent.Type.KeyPress:
+            print("focus", focus) """
+        if event.type() == QEvent.Type.KeyPress and focus == self.edit_line:
+            match event.key():
+                case Qt.Key.Key_Return | Qt.Key.Key_Enter:
+                    self.edit_tag()
+                case Qt.Key.Key_Escape:
+                    self.cancel()
+        return super().eventFilter(obj, event)
+
+    def toggle_hidden(self, hide: bool = True) -> None:
+        for widget in self.widgets:
+            is_input = widget in self.input_widgets
+
+            if hide == is_input:
+                widget.hide()
+            else:
+                widget.show()
+
+    def cancel(self) -> None:
+        self.toggle_hidden()
+
+    def toggle_edit_mode(self):
+        self.edit_line.setText(self._tag)
+        self.edit_line.setMinimumWidth(self.tag_label.width() + 10)
+        self.toggle_hidden(False)
+
+    def emit_update(self, text: str = None, weight: float = None) -> None:
+        text = text or self._tag
+        if weight is None:
+            weight = self.weight
+        if weight == "":
+            self.on_remove(self)
+            return
+        prev_text = self.text
+        self._tag = text
+        self.weight = weight
+        self.tag_label.setText(self.text)
+        self.on_update(prev_text, self.text)
+
+    def update_weight(self, weight: float) -> None:
+        self.emit_update(weight=weight)
+
+    @preserve_scroll
+    def edit_tag(self, *_):
+        text = self.edit_line.text()
+        self.toggle_hidden()
+
+        self.emit_update(text=text)
+
+    def apply_weight(self):
+        weight_dialog = InputDialog(
+            parent=self,
+            title="Tag Weight",
+            msg_str=f"Enter weight for `{self.text}`:",
+            input_type=float,
+            minimum=0,
+            maximum=2,
+            singleStep=0.1,
+            value=self.weight,
+        )
+        weight_dialog.connect(self.update_weight)
+        weight_dialog.exec()

jbqt/widgets/chips.py

@@ -0,0 +1,232 @@
+from re import Pattern
+
+from PyQt6.QtCore import Qt, pyqtSignal, QObject, QEvent
+from PyQt6.QtGui import QKeyEvent
+from PyQt6.QtWidgets import (
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+    QComboBox,
+)
+
+import jb_utils as utils
+from jbqt.common import consts
+from jbqt.models import IChipsWidget
+from jbqt.widgets.chip_button import ChipButton
+from jbqt.widgets.multiselect import MultiSelectComboBox
+from jbqt.widgets.widget_utils import debug_scroll_pos
+
+
+class ChipsWidget(IChipsWidget):
+    valuesChanged = pyqtSignal(list)
+
+    def __init__(
+        self,
+        chips=None,
+        data: dict = None,
+        path: str = "",
+        label: str = "",
+        weight_re: Pattern = None,
+        use_weight: bool = False,
+        debug: bool = False,
+    ):
+        super().__init__()
+        self.values = chips or []
+        # Main layout
+        main_layout = QVBoxLayout()
+        self.debug = debug
+        if label:
+            main_layout.addWidget(QLabel(label))
+        self.installEventFilter(self)
+
+        self.use_weight = use_weight
+        if use_weight:
+            weight_re = weight_re or consts.TAG_RE
+
+        self.weight_re = weight_re
+        self.options = data
+        self.data = data or {}
+        self.data_path = path
+        self.list_widget: QComboBox | MultiSelectComboBox = None
+
+        if data is not None:
+            if isinstance(data, dict):
+                if path:
+                    self.options = utils.get_nested(self.data, path, [])
+
+                self.list_widget = MultiSelectComboBox(
+                    data=self.options, selected=self.values
+                )
+                self.list_widget.selectedChanged.connect(
+                    self.handle_multiselect_change
+                )
+
+            elif isinstance(data, list):
+                self.list_widget = QComboBox()
+
+                # self.list_widget.addItems(self.options)
+                for option in self.options:
+                    self.list_widget.addItem(option)
+                init_value = self.values[0] if self.values else ""
+                self.list_widget.setCurrentText(init_value)
+                self.list_widget.currentTextChanged.connect(
+                    self.handle_multiselect_change
+                )
+            self.valuesChanged.connect(self.update_multiselect)
+            main_layout.addWidget(self.list_widget)
+
+        # Scroll area for the chips
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+
+        # Widget inside the scroll area to hold the buttons
+        self.chip_widget = QWidget()
+        self.chip_layout = QHBoxLayout(self.chip_widget)
+        self.chip_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
+
+        # Add existing chips as buttons
+        self.set_items(emit=False)
+
+        scroll_area.setWidget(self.chip_widget)
+
+        # Layout for the input and add button
+        input_layout = QHBoxLayout()
+        self.input_field = QLineEdit(self)
+        self.add_button = QPushButton("Add", self)
+        self.add_button.clicked.connect(self.add_chip)
+
+        self.clear_button = QPushButton(consts.ICONS.TRASH("darkred"), "", self)
+        self.clear_button.clicked.connect(self.remove_all)
+        # self.clear_button.setStyleSheet("color: red")
+
+        input_layout.addWidget(self.input_field)
+        input_layout.addWidget(self.add_button)
+        input_layout.addWidget(self.clear_button)
+
+        main_layout.addWidget(scroll_area)
+        main_layout.addLayout(input_layout)
+
+        self.setLayout(main_layout)
+
+    def eventFilter(self, obj: QObject, event: QKeyEvent) -> bool:
+        focus = consts.GlobalRefs.app.focusWidget()
+
+        if event.type() == QEvent.Type.KeyPress and focus == self.input_field:
+            match event.key():
+                case Qt.Key.Key_Return | Qt.Key.Key_Enter:
+                    self.add_chip()
+        return super().eventFilter(obj, event)
+
+    def get_unweight_chip(self, tag: str) -> str:
+        if self.weight_re and self.weight_re.search(tag):
+            return self.weight_re.search(tag).groups()[0]
+        return tag
+
+    def get_chip_list(self, tags: list[str]) -> list[str]:
+        return [self.get_unweight_chip(tag) for tag in tags]
+
+    def same_values(self, values: list[str]) -> bool:
+        return set(self.get_chip_list(values)) == set(
+            self.get_chip_list(self.values)
+        )
+
+    def handle_multiselect_change(self, selections: list[str] | str) -> None:
+        if isinstance(selections, str):
+            selections = [selections]
+
+        selections = utils.dedupe_list(selections)
+        if self.same_values(selections):
+            return
+
+        # self.values = selections
+        self.set_items(selections, debug=True)
+
+    def update_multiselect(self, values: list[str]) -> None:
+        if isinstance(self.list_widget, MultiSelectComboBox):
+            self.list_widget.set_selected(values, emit=False)
+        else:
+            value = values[0] if values else ""
+            self.list_widget.setCurrentText(value)
+
+    def clear_widgets(self) -> None:
+        while self.chip_layout.count():
+            widget = self.chip_layout.takeAt(0).widget()
+            if widget is not None:
+                widget.deleteLater()
+
+    def set_items(
+        self, values: list[str] = None, emit: bool = True, debug: bool = False
+    ) -> None:
+        self.clear_widgets()
+        # TODO: Temp fix for weighted/custom tags and incoming multiselect values
+        if values:
+            tags = self.get_tag_list(self.values)
+            for value in values:
+                if value not in tags:
+                    self.values.append(value)
+
+            self.values = utils.dedupe_list(self.values)
+        self.values = [value for value in self.values if value]
+        for item in self.values:
+            if not consts.GlobalRefs.debug_set:
+                debug = True
+                consts.GlobalRefs.debug_set = True
+            else:
+                debug = False
+            chip_button = ChipButton(
+                item,
+                self.update_chip,
+                self.remove_chip,
+                debug=debug,
+                weight_re=self.weight_re,
+                use_weight=self.use_weight,
+            )
+            """ chip_button.setToolTip(
+                f"Tag Count: {consts.TAG_COUNTS.get(item, "N/A")}"
+            ) """
+
+            self.chip_layout.addWidget(chip_button)
+
+        if emit:
+            self.emit_changes()
+
+    def update_chip(self, prev_text: str, new_text: str) -> None:
+        idx = self.values.index(prev_text)
+        if idx >= 0:
+            self.values[idx] = new_text
+
+    def emit_changes(self):
+        self.valuesChanged.emit(self.values)
+
+    def add_chip(self):
+        text = self.input_field.text().strip()
+        if text and text not in self.values:
+            chip_button = ChipButton(text, self.update_chip, self.remove_chip)
+
+            self.chip_layout.addWidget(chip_button)
+            self.values.append(text)
+            self.emit_changes()
+            self.input_field.setText("")
+
+    def remove_chip(self, button: ChipButton):
+        self.chip_layout.removeWidget(button)
+        button.deleteLater()  # Schedule button widget for deletion
+        self.values.remove(button.text)
+        self.emit_changes()
+
+    def add_chips(self, items: list[str]) -> None:
+        utils.update_list_values(self.values, items)
+        self.set_items()
+
+    def remove_chips(self, items: list[str]) -> None:
+        utils.remove_list_values(self.values, items)
+        self.set_items()
+
+    def remove_all(self, *_) -> None:
+        self.values = []
+        self.clear_widgets()
+        self.emit_changes()

jbqt/widgets/multiselect.py

@@ -0,0 +1,201 @@
+from re import Pattern
+
+from PyQt6.QtCore import QObject, pyqtSignal, Qt
+from PyQt6.QtGui import QCursor, QMouseEvent, QWheelEvent
+from PyQt6.QtWidgets import QComboBox, QListWidget, QListWidgetItem
+
+import jb_utils as utils
+from jbqt.common import consts, qt_utils
+
+
+class MultiSelectComboBox(QComboBox):
+    selectedChanged = pyqtSignal(list)
+
+    def __init__(
+        self,
+        data: list | dict = None,
+        selected: list[str] = None,
+        multi_enabled: bool = True,
+        use_weight: bool = False,
+        weight_re: Pattern = None,
+    ):
+        super().__init__()
+
+        self.use_weight = use_weight
+        if use_weight:
+            weight_re = weight_re or consts.TAG_RE
+
+        self.weight_re = weight_re
+
+        self._multi_select_enabled: bool = multi_enabled
+        # Make the combo box read-only and use a custom view
+        self.setEditable(True)
+        self.lineEdit().setReadOnly(True)
+        # Override the mouse press event of the QLineEdit
+        self.lineEdit().installEventFilter(self)
+
+        self.view: QListWidget = QListWidget()
+        self._selected = selected or []
+
+        # Set the custom view
+        self.setModel(self.view.model())
+        self.setView(self.view)
+
+        # Add items and categories
+        if isinstance(data, dict):
+            for name, items in data.items():
+                self.add_group(name, items)
+        elif isinstance(data, list):
+            self.add_items(data)
+
+        # Connect the item clicked signal
+        self.view.itemClicked.connect(self.toggle_check_state)
+        self.update_display_text()
+
+    def eventFilter(self, obj: QObject, event: QMouseEvent) -> bool:
+
+        if (
+            obj == self.lineEdit()
+            and event.type() == QMouseEvent.Type.MouseButtonRelease
+        ):
+            self.showPopup()
+
+            return True
+        return super().eventFilter(obj, event)
+
+    def wheelEvent(self, event: QWheelEvent):
+        # Check if the mouse cursor is within the bounds of the line edit
+        pos = self.mapFromGlobal(QCursor.pos())
+        if self.lineEdit().rect().contains(pos):
+            # Consume the wheel event to prevent scrolling
+            return
+
+        # If not over the line edit, let the base class handle it (scrolling)
+        super().wheelEvent(event)
+
+    def toggle_check_state(self, item: QListWidgetItem):
+        # Toggle check state if the item is selectable
+        if item.flags() & Qt.ItemFlag.ItemIsUserCheckable:
+            current_state = item.checkState()
+
+            new_state = (
+                Qt.CheckState.Unchecked
+                if current_state == Qt.CheckState.Checked
+                else Qt.CheckState.Checked
+            )
+            item.setCheckState(new_state)
+            if not self._multi_select_enabled:
+                self.toggle_others(item)
+
+            self.update_display_text()
+            self._selected_changed()
+
+    def toggle_others(self, selected: QListWidgetItem) -> None:
+
+        for i in range(self.view.count()):
+            item = self.view.item(i)
+            if item != selected:
+                item.setCheckState(Qt.CheckState.Unchecked)
+        self.update_display_text()
+
+    def setMultiSelectEnabled(self, value: bool) -> None:
+        self._multi_select_enabled = value
+
+    def multiSelectEnabled(self) -> bool:
+        return self._multi_select_enabled
+
+    def add_items(self, items: list[str] | dict, indent: int = 0) -> None:
+
+        indent_str = "    " * indent
+        if isinstance(items, dict):
+            for name, children in items.items():
+                self.add_group(name, children, indent + 1)
+        else:
+            for item_value in items:
+                if isinstance(item_value, tuple):
+                    item = QListWidgetItem(f"{indent_str}{item_value[0]}")
+                    item.setData(consts.LIST_ITEM_ROLE, item_value[1])
+
+                else:
+                    item = QListWidgetItem(f"{indent_str}{item_value}")
+                item.setFlags(
+                    Qt.ItemFlag.ItemIsUserCheckable | Qt.ItemFlag.ItemIsEnabled
+                )
+                value = item.data(consts.LIST_ITEM_ROLE) or item.text()
+                if value.strip() in self._selected:
+                    item.setCheckState(Qt.CheckState.Checked)
+                else:
+                    item.setCheckState(Qt.CheckState.Unchecked)
+                self.view.addItem(item)
+
+    def add_group(self, group_name: str, items: list[str], indent: int = 0):
+        indent_str = "    " * indent
+        # Add group header
+        header_item = QListWidgetItem(indent_str + group_name)
+        header_item.setFlags(Qt.ItemFlag.ItemIsEnabled)
+        header_item.setData(Qt.ItemDataRole.UserRole, False)  # Non-selectable
+        self.view.addItem(header_item)
+
+        # Add items with checkboxes
+        self.add_items(items, indent + 1)
+
+    def update_display_text(self):
+        selected_items = []
+        for i in range(self.view.count()):
+            item = self.view.item(i)
+            if item.checkState() == Qt.CheckState.Checked:
+                selected_items.append(item.text().strip())
+
+        text = ", ".join(selected_items)
+        self.lineEdit().setText(text)
+
+    def showPopup(self):
+        # Override showPopup to update text when the dropdown is shown
+        self.update_display_text()
+        super().showPopup()
+
+    def hidePopup(self):
+        # Override hidePopup to update text when closing dropdown
+        self.update_display_text()
+        super().hidePopup()
+
+    def same_selected(self, values: list[str]) -> bool:
+        return set(values) == set(self._selected)
+
+    def get_selected(self) -> list[str]:
+        return [
+            qt_utils.get_item_value(item)
+            for item in self.view.findItems("", Qt.MatchFlag.MatchContains)
+            if item.checkState() == Qt.CheckState.Checked
+        ]
+
+    def _selected_changed(self):
+        self.selectedChanged.emit(self.get_selected())
+
+    def get_unweight_chip(self, tag: str) -> str:
+        if self.weight_re and self.weight_re.search(tag):
+            return self.weight_re.search(tag).groups()[0]
+        return tag
+
+    def get_chip_list(self, tags: list[str]) -> list[str]:
+        return [self.get_unweight_chip(tag) for tag in tags]
+
+    def set_selected(self, values: list[str], emit: bool = True):
+        """if self.same_selected(values):
+        return"""
+
+        values = self.get_chip_list(values)
+        # Set the selected items and emit the signal
+        self._selected = utils.dedupe_list(values)
+        # Update the checked state of items based on the new selection
+        for i in range(self.view.count()):
+            item = self.view.item(i)
+
+            item.setCheckState(
+                Qt.CheckState.Checked
+                if qt_utils.get_item_value(item) in values
+                else Qt.CheckState.Unchecked
+            )
+        self.update_display_text()
+        if emit:
+            self._selected_changed()