jbqt 0.1.1__py3-none-any.whl

jbqt/common/__init__.py

@@ -0,0 +1,6 @@
+"""Const exports"""
+
+from jbqt.common.consts import COLORS, STYLES, SIZES, GlobalRefs, ICONS
+from jbqt.common.qt_utils import register_app
+
+__all__ = ["COLORS", "STYLES", "SIZES", "GlobalRefs", "ICONS", "register_app"]

jbqt/common/consts.py

@@ -0,0 +1,167 @@
+import os
+import re
+
+import jb_utils
+
+from PyQt6.QtWidgets import QApplication, QMainWindow, QScrollArea, QWidget
+from PyQt6.QtCore import Qt, QSize
+from PyQt6.QtGui import QIcon, QPixmap, QPainter, QColor
+
+TAG_RE = re.compile(r"^\((.+)\)(\d+\.\d+)$")
+LIST_ITEM_ROLE = Qt.ItemDataRole.UserRole - 1
+
+STYLES = jb_utils.STYLES
+COLORS = jb_utils.COLORS
+
+
+class GlobalRefs:
+    app: QApplication = None
+    main_window: QMainWindow = None
+    scroll_area: QScrollArea = None
+    server_active: bool = False
+    debug_set: bool = False
+    seed_widget: QWidget = None
+
+
+class QtPaths:
+    icon_dir: str = None
+
+
+THEME_ICONS: dict[str, QIcon] = {
+    "save": QIcon.fromTheme("media-floppy-symbolic"),
+    "new_file": QIcon.fromTheme("document-new-symbolic"),
+    "open": QIcon.fromTheme("folder-open-symbolic"),
+    "copy": QIcon.fromTheme("edit-paste-symbolic"),
+    "inspect": QIcon.fromTheme("docviewer-app-symbolic"),
+    "clone": QIcon.fromTheme("edit-copy-symbolic"),
+    "plus": QIcon.fromTheme("list-add-symbolic"),
+    "minus": QIcon.fromTheme("list-remove-symbolic"),
+    "times": QIcon.fromTheme("cancel-operation-symbolic"),
+    "refresh": QIcon.fromTheme("view-refresh-symbolic"),
+    "reload": QIcon.fromTheme("update-symbolic"),
+    "circle_check": QIcon.fromTheme("selection-checked"),
+    "circle_x": QIcon.fromTheme("application-exit"),
+    "code": QIcon.fromTheme("input-tablet-symbolic"),
+    "font-selection-editor": QIcon.fromTheme("font-select-symbolic"),
+    "trash": QIcon.fromTheme("trash-symbolic"),
+    "edit_data": QIcon.fromTheme("document-edit-symbolic"),
+    "preview": QIcon.fromTheme("view-layout-symbolic"),
+    "sync": QIcon.fromTheme("mail-send-receive-symbolic"),
+}
+STD_ICONS: dict[str, QIcon] = {
+    "save": QIcon.fromTheme(QIcon.ThemeIcon.DocumentSave),
+    "new_file": QIcon.fromTheme(QIcon.ThemeIcon.DocumentNew),
+    "open": QIcon.fromTheme(QIcon.ThemeIcon.FolderOpen),
+    "copy": QIcon.fromTheme(QIcon.ThemeIcon.EditPaste),
+    "inspect": QIcon.fromTheme(QIcon.ThemeIcon.DocumentPageSetup),
+    "clone": QIcon.fromTheme(QIcon.ThemeIcon.EditCopy),
+    "plus": QIcon.fromTheme(QIcon.ThemeIcon.ListAdd),
+    "minus": QIcon.fromTheme(QIcon.ThemeIcon.DialogError),
+    "times": QIcon.fromTheme(QIcon.ThemeIcon.ApplicationExit),
+    "refresh": QIcon.fromTheme(QIcon.ThemeIcon.SystemReboot),
+    "reload": QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaylistRepeat),
+    "circle_check": QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaybackStart),
+    "circle_x": QIcon.fromTheme(QIcon.ThemeIcon.ProcessStop),
+    "code": QIcon.fromTheme(QIcon.ThemeIcon.Computer),
+    "font-selection-editor": QIcon.fromTheme(QIcon.ThemeIcon.EditFind),
+    "trash": QIcon.fromTheme(QIcon.ThemeIcon.EditDelete),
+    "edit_data": QIcon.fromTheme(QIcon.ThemeIcon.InputTablet),
+    "preview": QIcon.fromTheme(QIcon.ThemeIcon.ZoomIn),
+    "sync": QIcon.fromTheme(QIcon.ThemeIcon.MediaPlaylistShuffle),
+}
+
+
+def set_icon_dir(path: str) -> None:
+    QtPaths.icon_dir = path
+
+
+class SIZES:
+    ICON_XS = QSize(16, 16)
+    ICON_SM = QSize(20, 20)
+    ICON_MD = QSize(22, 22)
+    ICON_LG = QSize(24, 24)
+    ICON_XL = QSize(32, 32)
+    ICON_XXL = QSize(48, 48)
+
+
+def icon_dir(file_name: str) -> str:
+    if QtPaths.icon_dir:
+        return os.path.join(QtPaths.icon_dir, file_name)
+    return file_name
+
+
+def recolor_icon(
+    image_path: str, color: str | QColor, scale: QSize = None
+) -> QIcon:
+    if not color:
+        color = QColor("black")
+    if isinstance(color, str):
+        color = QColor(color)
+
+    if not scale:
+        scale = SIZES.ICON_MD
+    pixmap = QPixmap(image_path)
+    icon_key = os.path.splitext(os.path.basename(image_path))[0]
+
+    if pixmap.isNull():
+        fallback = THEME_ICONS.get(icon_key, STD_ICONS.get(icon_key))
+        if fallback:
+            pixmap = fallback.pixmap()
+
+    recolored_pixmap = QPixmap(pixmap.size())
+
+    recolored_pixmap.fill(
+        QColor("transparent")
+    )  # Ensure the background is transparent
+    painter = QPainter(recolored_pixmap)
+    painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Source)
+
+    # Draw the original pixmap
+    painter.drawPixmap(0, 0, pixmap)
+
+    # Apply the desired color
+    painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn)
+    painter.fillRect(pixmap.rect(), color)
+
+    painter.end()
+    return QIcon(recolored_pixmap.scaled(scale, Qt.AspectRatioMode.KeepAspectRatio))
+
+
+def get_icon(file_name: str) -> QIcon:
+    def getter(color: str = "", size: QSize | int = None):
+        if isinstance(size, int):
+            size = QSize(size, size)
+
+        # return QIcon(QPixmap(_icon_dir(file_name)))
+        return recolor_icon(icon_dir(file_name), color, size)
+
+    return getter
+
+
+class ICONS:
+    SAVE = get_icon("save.svg")
+    NEW = get_icon("new_file.svg")
+    OPEN = get_icon("open.png")
+    COPY = get_icon("copy.png")
+    INSPECT = get_icon("inspect.svg")
+    CLONE = get_icon("clone.svg")
+    PLUS = get_icon("plus.png")
+    MINUS = get_icon("minus.png")
+    TIMES = get_icon("times.svg")
+    REFRESH = get_icon("refresh.svg")
+    RELOAD = get_icon("reload.png")
+    CIRCLE_CHECK = get_icon("circle_check.svg")
+    CIRCLE_TIMES = get_icon("circle_x.svg")
+    CODE = get_icon("code.png")
+    EDIT = get_icon("font-selection-editor.png")
+    TRASH = get_icon("trash.png")
+    EDIT_DATA = get_icon("edit_data.svg")
+    PREVIEW = get_icon("preview.png")
+    SYNC = get_icon("sync.png")
+
+    @classmethod
+    def get(cls, name: str, default: str = "") -> str:
+        if hasattr(cls, name):
+            return getattr(cls, name)
+        else:
+            return default

jbqt/common/qt_utils.py

@@ -0,0 +1,81 @@
+from datetime import date
+from typing import Any
+
+from PyQt6.QtCore import Qt, QDate
+from PyQt6.QtWidgets import (
+    QListWidgetItem,
+    QCalendarWidget,
+    QApplication,
+    QWidget,
+    QLineEdit,
+    QTextEdit,
+    QSpinBox,
+    QCheckBox,
+    QDoubleSpinBox,
+)
+
+from jbqt.common import consts
+from jbqt.models import IChipsWidget
+
+
+def get_item_value(item: QListWidgetItem) -> str:
+    value = item.data(consts.LIST_ITEM_ROLE) or item.text()
+    return value.strip()
+
+
+def register_app(app: QApplication, icon_dir: str = "") -> None:
+    consts.GlobalRefs.app = app
+    consts.set_icon_dir(icon_dir)
+
+
+def get_widget_value(widget: QWidget, key: str = "") -> Any:
+
+    if isinstance(widget, QLineEdit):
+        return widget.text()
+    if isinstance(widget, QTextEdit):
+        return widget.toPlainText().strip()
+    if isinstance(widget, (QSpinBox, QDoubleSpinBox)):
+        return widget.value()
+    if isinstance(widget, IChipsWidget):
+        return widget.values
+    if isinstance(widget, QCheckBox):
+        return widget.checkState == Qt.CheckState.Checked
+    if isinstance(widget, QCalendarWidget):
+        return widget.selectedDate().toString()
+
+    print(f"No handler defined for {key} of type `{type(widget)}`")
+
+
+def set_widget_value(widget: QWidget, value: Any) -> None:
+    if isinstance(widget, (QLineEdit, QTextEdit)):
+        widget.setText(str(value))
+    elif isinstance(widget, QSpinBox):
+        try:
+            widget.setValue(int(value))
+        except Exception as e:
+            print(e)
+            print(type(e))
+
+    elif isinstance(widget, QDoubleSpinBox):
+        try:
+            widget.setValue(float(value))
+        except Exception as e:
+            print(e)
+            print(type(e))
+
+    elif isinstance(widget, IChipsWidget) and isinstance(value, list):
+        widget.add_chips(value)
+    elif isinstance(widget, QCheckBox):
+        state = Qt.CheckState.Unchecked
+        if isinstance(value, Qt.CheckState):
+            state = value
+        elif value is True:
+            state = Qt.CheckState.Checked
+        elif value is False:
+            state = Qt.CheckState.Unchecked
+
+        widget.setCheckState(state)
+
+    elif isinstance(widget, QCalendarWidget):
+        if isinstance(value, (date, QDate)):
+            widget.selectedDate(value)

jbqt/dialogs/__init__.py

@@ -0,0 +1,7 @@
+"""jbqt Dialog exports"""
+
+from jbqt.dialogs.input_form import InputDialog
+from jbqt.dialogs.text_preview import TextPreviewDialog
+from jbqt.dialogs.file_dialog import JbFileDialog
+
+__all__ = ["InputDialog", "TextPreviewDialog", "JbFileDialog"]

jbqt/dialogs/file_dialog.py

@@ -0,0 +1,27 @@
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import QWidget, QPushButton, QVBoxLayout, QFileDialog
+
+
+class JbFileDialog(QWidget):
+    selectedFile = pyqtSignal(str)
+
+    def __init__(self, title: str = "File Dialog", directory: str = "") -> None:
+        """Initialize the main window with a button to open a file dialog."""
+        super().__init__()
+        self.setWindowTitle("QFileDialog Example")
+        self.directory = directory
+
+        self.button = QPushButton("Open File", self)
+        self.button.clicked.connect(self.open_file_dialog)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.button)
+        self.setLayout(layout)
+
+    def open_file_dialog(self) -> None:
+        """Open a file dialog to select a file."""
+        file_name, _ = QFileDialog.getOpenFileName(
+            self, "Open File", self.directory, "All Files (*);;Text Files (*.txt)"
+        )
+        if file_name:
+            self.selectedFile.emit(file_name)

jbqt/dialogs/input_form.py

@@ -0,0 +1,85 @@
+from typing import Any, Callable
+
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QDoubleSpinBox,
+    QLabel,
+    QLineEdit,
+    QSpinBox,
+    QVBoxLayout,
+)
+
+
+INPUT_SIGNAL_TYPES: tuple[Any] = (str, int, float)
+
+
+class InputDialog(QDialog):
+    signal_types: tuple[Any] = INPUT_SIGNAL_TYPES
+    """ reference value for external use """
+
+    value = pyqtSignal(*([ptype] for ptype in INPUT_SIGNAL_TYPES))
+
+    def __init__(
+        self,
+        parent=None,
+        title: str = "Input",
+        msg_str: str = "Enter Input:",
+        input_type: type = str,
+        **opts,
+    ):
+        super().__init__(parent)
+
+        self.setWindowTitle(title)
+
+        QBtn = (
+            QDialogButtonBox.StandardButton.Cancel
+            | QDialogButtonBox.StandardButton.Open
+        )
+
+        self.buttonBox = QDialogButtonBox(QBtn)
+        self.buttonBox.accepted.connect(self.accept)
+        self.buttonBox.rejected.connect(self.reject)
+
+        layout = QVBoxLayout()
+        message = QLabel(msg_str)
+        layout.addWidget(message)
+
+        self.input_widget = None
+        if input_type is str:
+            self.input_widget = QLineEdit()
+        elif input_type is int:
+            self.input_widget = QSpinBox()
+        elif input_type is float:
+            self.input_widget = QDoubleSpinBox()
+
+        self._init_widget(**opts)
+
+        layout.addWidget(self.input_widget)
+        layout.addWidget(self.buttonBox)
+        self.setLayout(layout)
+
+    def _init_widget(self, **opts) -> None:
+        for key, value in opts.items():
+            setter_key = f"set{key[0].upper() + key[1:]}"
+            if hasattr(self.input_widget, setter_key):
+                setter = getattr(self.input_widget, setter_key)
+                if setter:
+                    setter(value)
+
+    def connect(self, callback: Callable) -> None:
+        for parm_type in self.signal_types:
+            self.value[parm_type].connect(callback)
+
+    def accept(self):
+        # Emit the custom signal with data when the dialog is accepted
+
+        if isinstance(self.input_widget, QLineEdit):
+            self.value[str].emit(self.input_widget.text())
+        elif isinstance(self.input_widget, QSpinBox):
+            self.value[int].emit(self.input_widget.value())
+        elif isinstance(self.input_widget, QDoubleSpinBox):
+            self.value[float].emit(self.input_widget.value())
+
+        super().accept()

jbqt/dialogs/text_preview.py

@@ -0,0 +1,42 @@
+from PyQt6.QtGui import QFontMetrics
+from PyQt6.QtWidgets import (
+    QDialog,
+    QVBoxLayout,
+    QTextEdit,
+    QPushButton,
+)
+
+
+class TextPreviewDialog(QDialog):
+    def __init__(self, text: str, title: str = "", parent=None):
+        super().__init__(parent)
+
+        self.setWindowTitle("Text Preview")
+        if title:
+            self.setWindowTitle(f"Text Preview [{title}]")
+
+        layout = QVBoxLayout(self)
+
+        # QTextEdit to display the text
+        self.text_edit = QTextEdit(self)
+        self.text_edit.setPlainText(text)
+        self.text_edit.setReadOnly(True)
+        layout.addWidget(self.text_edit)
+
+        # Close button
+        close_button = QPushButton("Close", self)
+        close_button.clicked.connect(self.accept)
+        layout.addWidget(close_button)
+
+        # Adjust the dialog size based on the text
+        self.adjust_size_based_on_text(text)
+
+    def adjust_size_based_on_text(self, text):
+        # Calculate text size
+        font_metrics = QFontMetrics(self.text_edit.font())
+        text_size = font_metrics.size(0, text)
+
+        # Adjust size with some padding
+        h_padding = 20
+        v_padding = 100
+        self.resize(text_size.width() + h_padding, text_size.height() + v_padding)

jbqt/models/__init__.py

@@ -0,0 +1,6 @@
+"""Model exports"""
+
+from jbqt.models.chips import IChipsWidget
+from jbqt.models.chip_button import IChipButton
+
+__all__ = ["IChipButton", "IChipsWidget"]

jbqt/models/chip_button.py

@@ -0,0 +1,13 @@
+"""Model for chips widget"""
+
+from abc import abstractmethod, ABC
+
+from PyQt6.QtCore import QObject
+from PyQt6.QtWidgets import QWidget
+
+
+class IChipButton(QWidget):
+    """ChipButton model"""
+
+    def __init__(self, parent: QObject = None) -> None:
+        super().__init__(parent)

jbqt/models/chips.py

@@ -0,0 +1,31 @@
+"""Model for chips widget"""
+
+from abc import abstractmethod, ABC
+
+from PyQt6.QtCore import QObject
+from PyQt6.QtWidgets import QWidget
+
+from jbqt.models.chip_button import IChipButton
+
+
+class IChipsWidget(QWidget):
+    """ChipsWidget model"""
+
+    def __init__(self, parent: QObject = None) -> None:
+        super().__init__(parent)
+        self.values: list = None
+
+    def add_chip(self):
+        pass
+
+    def remove_chip(self, button: IChipButton):
+        pass
+
+    def add_chips(self, items: list[str]) -> None:
+        pass
+
+    def remove_chips(self, items: list[str]) -> None:
+        pass
+
+    def remove_all(self, *_) -> None:
+        pass

jbqt/view_icons.py

@@ -0,0 +1,208 @@
+import argparse
+import os
+import sys
+
+from PyQt6.QtCore import QSize, Qt, QTimer
+from PyQt6.QtGui import QIcon
+from PyQt6.QtWidgets import (
+    QApplication,
+    QGridLayout,
+    QLabel,
+    QLineEdit,
+    QMainWindow,
+    QPushButton,
+    QScrollArea,
+    QStyle,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from fuzzywuzzy import process  # Needs fuzzywuzzy + python-Levenshtein
+
+parser = argparse.ArgumentParser(description="Simple tool to display icons")
+parser.add_argument(
+    "--from-theme",
+    "-f",
+    action="store_true",
+    help="Search and display all icons from the Ubuntu themes as opposed to the StandardIcon library in Qt6",
+)
+parser.add_argument(
+    "--theme-icons",
+    "-t",
+    action="store_true",
+    help="Pull icons from the QIcon.ThemeIcon list",
+)
+parser.add_argument(
+    "--add-quotes",
+    "-q",
+    action="store_true",
+    help="Wrap copied icon name with quotes",
+)
+args = parser.parse_args()
+
+THEMES_DIR = "/usr/share/icons"
+
+
+class Toast(QLabel):
+    def __init__(self, text: str, parent: QWidget = None, duration_ms: int = 1500):
+        super().__init__(parent)
+
+        self.setText(text)
+        self.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setStyleSheet(
+            """
+            background-color: rgba(50, 50, 50, 180);
+            color: white;
+            border-radius: 8px;
+            padding: 8px 16px;
+            font-size: 14px;
+        """
+        )
+        self.setWindowFlags(Qt.WindowType.ToolTip)
+        self.adjustSize()
+
+        # Center it over parent if available
+        if parent:
+            parent_rect = parent.rect()
+            toast_rect = self.rect()
+            self.move(
+                parent_rect.center().x() - toast_rect.width() // 2,
+                parent_rect.top() + 50,  # appear slightly under the top
+            )
+
+        QTimer.singleShot(duration_ms, self.close)
+
+
+def get_theme_icons(theme_dir: str) -> list[str]:
+    icon_names = set()
+    for root, _, files in os.walk(theme_dir):
+        for file in files:
+            if file.endswith((".svg", ".png")):
+                rel_path = os.path.relpath(os.path.join(root, file), theme_dir)
+                parts = rel_path.split(os.sep)
+                if len(parts) >= 2:
+                    icon_name = os.path.splitext(parts[-1])[0]
+                    icon_names.add(icon_name)
+    return sorted(icon_names)
+
+
+class Window(QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.setGeometry(1000, 400, 1600, 800)
+
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+
+        self.layout = QVBoxLayout()
+        central_widget.setLayout(self.layout)
+
+        self.search_bar = QLineEdit()
+        self.search_bar.setPlaceholderText("Search icons...")
+        self.search_bar.textChanged.connect(self.update_display)
+
+        self.table = QTableWidget()
+        self.table.setColumnCount(4)  # 4 columns of icons
+        self.table.horizontalHeader().setVisible(False)
+        self.table.verticalHeader().setVisible(False)
+        self.table.setIconSize(QSize(64, 64))
+        self.table.setShowGrid(False)
+        self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        self.table.setSelectionMode(QTableWidget.SelectionMode.NoSelection)
+        self.table.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.table.cellClicked.connect(self.copy_icon_name_to_clipboard)
+        self.table.setStyleSheet(
+            """
+        QTableWidget::item:hover {
+            background-color: #444444;
+        }
+        """
+        )
+
+        self.layout.addWidget(self.search_bar)
+        self.layout.addWidget(self.table)
+
+        cur_theme = QIcon.themeName()
+        self.icon_src = "standard"
+        if args.from_theme:
+            self.icon_src = "from_theme"
+        elif args.theme_icons:
+            self.icon_src = "theme_icons"
+
+        match self.icon_src:
+            case "from_theme":
+                self.icons = get_theme_icons(os.path.join(THEMES_DIR, cur_theme))
+            case "theme_icons":
+                self.icons = [
+                    i for i in dir(QIcon.ThemeIcon) if not i.startswith("_")
+                ]
+            case _:
+                self.icons = sorted(
+                    [
+                        attr
+                        for attr in dir(QStyle.StandardPixmap)
+                        if attr.startswith("SP_")
+                    ]
+                )
+
+        self.update_display()
+
+    def copy_icon_name_to_clipboard(self, row: int, column: int) -> None:
+        item = self.table.item(row, column)
+        if item and item.text():
+            text = f'"{item.text()}"' if args.add_quotes else item.text()
+            QApplication.clipboard().setText(text)
+            print(f"Copied '{item.text()}' to clipboard")
+            Toast(f"Copied '{item.text()}'", parent=self).show()
+
+    def update_display(self):
+        text = self.search_bar.text().strip()
+
+        if text:
+            # Use fuzzy matching
+            matches = process.extract(
+                text,
+                self.icons,
+                limit=200,  # Don't explode the table even if 2400+ icons exist
+            )
+            filtered_icons = [match[0] for match in matches if match[1] >= 50]
+        else:
+            filtered_icons = self.icons
+
+        self.table.setRowCount((len(filtered_icons) + 3) // 4)
+
+        for i in range(self.table.rowCount()):
+            for j in range(4):
+                idx = i * 4 + j
+                if idx >= len(filtered_icons):
+                    self.table.setItem(i, j, QTableWidgetItem())
+                    continue
+
+                name = filtered_icons[idx]
+
+                match self.icon_src:
+                    case "from_theme":
+                        icon = QIcon.fromTheme(name)
+                    case "theme_icons":
+                        icon = QIcon.fromTheme(getattr(QIcon.ThemeIcon, name))
+                    case _:
+
+                        pixmapi = getattr(QStyle.StandardPixmap, name)
+                        icon = self.style().standardIcon(pixmapi)
+
+                item = QTableWidgetItem(name)
+                item.setIcon(icon)
+                self.table.setItem(i, j, item)
+
+        self.table.resizeRowsToContents()
+        self.table.resizeColumnsToContents()
+
+
+app = QApplication(sys.argv)
+w = Window()
+w.show()
+
+app.exec()