NotYAFC 1.0.0__py3-none-any.whl

font_converter/gui/widgets.py

@@ -0,0 +1,495 @@
+"""Reusable widgets for the NotYAFC window."""
+
+from pathlib import Path
+
+from PySide6.QtCore import QLocale, QSize, Qt, Signal
+from PySide6.QtGui import (
+    QColor,
+    QDragEnterEvent,
+    QDragLeaveEvent,
+    QDragMoveEvent,
+    QDropEvent,
+    QIcon,
+    QKeyEvent,
+    QPainter,
+    QPainterPath,
+    QPaintEvent,
+    QPixmap,
+    QResizeEvent,
+    QValidator,
+)
+from PySide6.QtWidgets import (
+    QAbstractSpinBox,
+    QBoxLayout,
+    QButtonGroup,
+    QDoubleSpinBox,
+    QFrame,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QPushButton,
+    QRadioButton,
+    QSizePolicy,
+    QSpinBox,
+    QTableView,
+    QToolButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from font_converter.gui.styles import DARK, LIGHT
+
+
+class ElidedLabel(QLabel):
+    """Single-line label that preserves its full text and tooltip when space is limited."""
+
+    def setText(self, text: str) -> None:
+        super().setText(text)
+        self.setToolTip(text)
+
+    def display_text(self) -> str:
+        return self.fontMetrics().elidedText(
+            self.text(), Qt.TextElideMode.ElideRight, self.contentsRect().width()
+        )
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        painter = QPainter(self)
+        rect = self.contentsRect()
+        self.style().drawItemText(
+            painter,
+            rect,
+            int(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter),
+            self.palette(),
+            self.isEnabled(),
+            self.display_text(),
+            self.foregroundRole(),
+        )
+
+
+COMMON_UPM_VALUES = (256, 512, 1000, 1024, 2000, 2048, 4096)
+UPM_STEP_VALUES = (
+    16,
+    32,
+    64,
+    128,
+    256,
+    512,
+    1000,
+    1024,
+    2000,
+    2048,
+    4000,
+    4096,
+    8000,
+    8192,
+    16000,
+    16384,
+)
+
+
+def _theme_icon(symbol: str, color: QColor) -> QIcon:
+    pixmap = QPixmap(24, 24)
+    pixmap.fill(Qt.GlobalColor.transparent)
+    painter = QPainter(pixmap)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+    painter.setPen(color)
+    painter.setBrush(color)
+
+    if symbol == "sun":
+        painter.drawEllipse(9, 9, 6, 6)
+        painter.setPen(Qt.PenStyle.NoPen)
+        for angle in range(0, 360, 45):
+            painter.save()
+            painter.translate(12, 12)
+            painter.rotate(angle)
+            painter.drawRoundedRect(-1, -11, 2, 4, 1, 1)
+            painter.restore()
+    else:
+        crescent = QPainterPath()
+        crescent.addEllipse(4, 3, 16, 16)
+        cutout = QPainterPath()
+        cutout.addEllipse(10, 1, 14, 14)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.drawPath(crescent.subtracted(cutout))
+
+    painter.end()
+    return QIcon(pixmap)
+
+
+class ThemeToggle(QToolButton):
+    themeChanged = Signal(bool)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setObjectName("themeToggle")
+        self.setFixedSize(92, 44)
+        self.setIconSize(QSize(82, 36))
+        self.setCheckable(True)
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.setAccessibleName("Dark theme")
+        self.toggled.connect(self._update_appearance)
+        self.clicked.connect(lambda checked: self.themeChanged.emit(checked))
+        self.set_dark_theme(False)
+
+    def set_dark_theme(self, enabled: bool) -> None:
+        self.setChecked(enabled)
+        self._update_appearance(enabled)
+
+    def _update_appearance(self, enabled: bool) -> None:
+        palette = DARK if enabled else LIGHT
+        current = "dark" if enabled else "light"
+        target = "light" if enabled else "dark"
+        self.setAccessibleDescription(f"Current theme: {current}. Activate to use {target} theme.")
+        self.setToolTip(f"Current theme: {current}. Switch to {target} theme.")
+
+        pixmap = QPixmap(82, 36)
+        pixmap.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(QColor(palette.toggle_checked))
+        painter.drawRoundedRect(44 if enabled else 2, 0, 36, 36, 18, 18)
+        for x, symbol, active in ((8, "sun", not enabled), (50, "moon", enabled)):
+            color = palette.icon_active if active else palette.icon_inactive
+            painter.drawPixmap(x, 6, _theme_icon(symbol, QColor(color)).pixmap(24, 24))
+        painter.end()
+        self.setIcon(QIcon(pixmap))
+
+
+class KeyboardPushButton(QPushButton):
+    """Push button that activates on Return/Enter as well as Space."""
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
+            if not event.isAutoRepeat():
+                self.click()
+            event.accept()
+            return
+        super().keyPressEvent(event)
+
+
+class DecimalSpinBox(QDoubleSpinBox):
+    """Double spin box that accepts both '.' and ',' as decimal separator."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setLocale(QLocale.c())
+
+    def validate(self, text: str, pos: int) -> tuple[QValidator.State, str, int]:
+        return super().validate(text.replace(",", "."), pos)
+
+    def valueFromText(self, text: str) -> float:
+        return super().valueFromText(text.replace(",", "."))
+
+
+class UpmSpinBox(QSpinBox):
+    """Spin box whose steps jump between supported units-per-em values."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setRange(16, 16384)
+        self.setValue(1000)
+
+    def stepBy(self, steps: int) -> None:
+        value = self.value()
+        for _ in range(abs(steps)):
+            if steps > 0:
+                value = next((v for v in UPM_STEP_VALUES if v > value), self.maximum())
+            else:
+                value = next((v for v in reversed(UPM_STEP_VALUES) if v < value), self.minimum())
+        self.setValue(value)
+
+
+class StepperField(QWidget):
+    """Spin box flanked by app-styled − / + buttons instead of native arrows."""
+
+    def __init__(self, spin_box: QAbstractSpinBox, *, tab_buttons: bool = False) -> None:
+        super().__init__()
+        self.spin_box = spin_box
+        spin_box.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(6)
+        self.decrement_button = KeyboardPushButton("−")
+        self.increment_button = KeyboardPushButton("+")
+        for button, direction in ((self.decrement_button, -1), (self.increment_button, 1)):
+            button.setObjectName("stepperButton")
+            button.setAutoRepeat(True)
+            if not tab_buttons:
+                button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+            button.clicked.connect(lambda _=False, step=direction: spin_box.stepBy(step))
+        layout.addWidget(self.decrement_button)
+        layout.addWidget(spin_box, 1)
+        layout.addWidget(self.increment_button)
+
+
+class ConversionSelector(QWidget):
+    currentIndexChanged = Signal(int)
+
+    def __init__(
+        self,
+        conversions: dict[str, str],
+        *,
+        select_first: bool = True,
+        group_headings: dict[str, str] | None = None,
+    ) -> None:
+        super().__init__()
+        self._keys = list(conversions)
+        self._labels = list(conversions.values())
+        self._group = QButtonGroup(self)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(8)
+        for index, (key, label) in enumerate(conversions.items()):
+            if group_headings is not None and key in group_headings:
+                if index:
+                    layout.addSpacing(3)
+                heading = QLabel(group_headings[key])
+                heading.setObjectName("conversionGroupHeading")
+                layout.addWidget(heading)
+            button = QRadioButton(label)
+            self._group.addButton(button, index)
+            layout.addWidget(button)
+        layout.addStretch()
+        if select_first:
+            self._group.button(0).setChecked(True)
+        self._group.idClicked.connect(self.currentIndexChanged)
+
+    def currentIndex(self) -> int:
+        return self._group.checkedId()
+
+    def currentData(self) -> str | None:
+        index = self.currentIndex()
+        return self._keys[index] if index >= 0 else None
+
+    def findData(self, key: str) -> int:
+        return self._keys.index(key) if key in self._keys else -1
+
+    def setCurrentIndex(self, index: int) -> None:
+        button = self._group.button(index)
+        if button is not None and not button.isChecked():
+            button.setChecked(True)
+            self.currentIndexChanged.emit(index)
+
+    def set_compatibility_counts(self, counts: dict[str, int] | None, total: int) -> None:
+        for index, (key, label) in enumerate(zip(self._keys, self._labels, strict=True)):
+            button = self._group.button(index)
+            if button is not None:
+                button.setText(
+                    f"{label}  ·  {counts[key]}/{total} compatible" if counts is not None else label
+                )
+        layout = self.layout()
+        if layout is not None:
+            layout.invalidate()
+        self.updateGeometry()
+
+
+def accept_local_files(event: QDragEnterEvent | QDragMoveEvent) -> None:
+    if event.mimeData().hasUrls() and any(url.isLocalFile() for url in event.mimeData().urls()):
+        event.acceptProposedAction()
+    else:
+        event.ignore()
+
+
+def dropped_paths(event: QDropEvent) -> list[str]:
+    return [
+        url.toLocalFile()
+        for url in event.mimeData().urls()
+        if url.isLocalFile()
+        and (Path(url.toLocalFile()).is_file() or Path(url.toLocalFile()).is_dir())
+    ]
+
+
+def set_drag_over(widget: QWidget, enabled: bool) -> None:
+    value = "true" if enabled else "false"
+    if widget.property("dragOver") == value:
+        return
+    widget.setProperty("dragOver", value)
+    widget.style().unpolish(widget)
+    widget.style().polish(widget)
+    widget.update()
+
+
+class DropIcon(QWidget):
+    def __init__(self) -> None:
+        super().__init__()
+        self.setFixedSize(32, 32)
+        self._color = QColor(LIGHT.text_muted)
+
+    def set_dark_theme(self, enabled: bool) -> None:
+        self._color = QColor((DARK if enabled else LIGHT).text_muted)
+        self.update()
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setPen(self._color)
+        pen = painter.pen()
+        pen.setWidth(2)
+        pen.setCapStyle(Qt.PenCapStyle.RoundCap)
+        pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+        painter.setPen(pen)
+        painter.drawLine(16, 3, 16, 20)
+        painter.drawLine(10, 14, 16, 20)
+        painter.drawLine(16, 20, 22, 14)
+        painter.drawLine(6, 21, 6, 27)
+        painter.drawLine(6, 27, 26, 27)
+        painter.drawLine(26, 27, 26, 21)
+        painter.end()
+
+
+class DropZone(QFrame):
+    paths_dropped = Signal(list)
+    addFilesRequested = Signal()
+    addFolderRequested = Signal()
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setObjectName("dropZone")
+        self.setAccessibleName("Font drop area")
+        self.setAcceptDrops(True)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Expanding)
+        self.setProperty("dragOver", "false")
+        self._scanning = False
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(12, 12, 12, 12)
+        layout.setSpacing(5)
+        layout.addStretch()
+        self.icon = DropIcon()
+        layout.addWidget(self.icon, 0, Qt.AlignmentFlag.AlignHCenter)
+        self.title = QLabel("Drop fonts or folders here")
+        self.title.setObjectName("dropZoneTitle")
+        self.title.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.title.setWordWrap(True)
+        self.title.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        layout.addWidget(self.title)
+        self.formats = QLabel("TTF · OTF · WOFF · WOFF2 · TTC · OTC")
+        self.folder_hint = QLabel("Folders are scanned for fonts")
+        for label in (self.formats, self.folder_hint):
+            label.setObjectName("hint")
+            label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            label.setWordWrap(True)
+            label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+            layout.addWidget(label)
+        self.buttons = QWidget()
+        self.buttons_layout = QBoxLayout(QBoxLayout.Direction.LeftToRight, self.buttons)
+        self.buttons_layout.setContentsMargins(0, 0, 0, 0)
+        self.buttons_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.add_files_button = KeyboardPushButton("Add files…")
+        self.add_folder_button = KeyboardPushButton("Add folder…")
+        self.buttons_layout.addWidget(self.add_files_button)
+        self.buttons_layout.addWidget(self.add_folder_button)
+        self.add_files_button.clicked.connect(self.addFilesRequested.emit)
+        self.add_folder_button.clicked.connect(self.addFolderRequested.emit)
+        layout.addWidget(self.buttons)
+        layout.addStretch()
+        for widget in (self.formats, self.folder_hint, self.buttons):
+            policy = widget.sizePolicy()
+            policy.setRetainSizeWhenHidden(True)
+            widget.setSizePolicy(policy)
+
+    def set_dark_theme(self, enabled: bool) -> None:
+        self.icon.set_dark_theme(enabled)
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        super().resizeEvent(event)
+        required = (
+            self.add_files_button.sizeHint().width()
+            + self.add_folder_button.sizeHint().width()
+            + self.buttons_layout.spacing()
+        )
+        self.buttons_layout.setDirection(
+            QBoxLayout.Direction.LeftToRight
+            if self.contentsRect().width() - 24 >= required
+            else QBoxLayout.Direction.TopToBottom
+        )
+
+    def set_scanning(self, scanning: bool) -> None:
+        self._scanning = scanning
+        self._update_state()
+
+    def _update_state(self) -> None:
+        dragging = self.property("dragOver") == "true"
+        self.title.setText(
+            "Release to add"
+            if dragging
+            else "Scanning…"
+            if self._scanning
+            else "Drop fonts or folders here"
+        )
+        for widget in (self.formats, self.folder_hint, self.buttons):
+            widget.setVisible(not (dragging or self._scanning))
+
+    def dragEnterEvent(self, event: QDragEnterEvent) -> None:
+        accept_local_files(event)
+        set_drag_over(self, event.isAccepted())
+        self._update_state()
+
+    def dragMoveEvent(self, event: QDragMoveEvent) -> None:
+        accept_local_files(event)
+
+    def dragLeaveEvent(self, event: QDragLeaveEvent) -> None:
+        set_drag_over(self, False)
+        self._update_state()
+        event.accept()
+
+    def dropEvent(self, event: QDropEvent) -> None:
+        set_drag_over(self, False)
+        self._update_state()
+        paths = dropped_paths(event)
+        if paths:
+            event.acceptProposedAction()
+            self.paths_dropped.emit(paths)
+        else:
+            event.ignore()
+
+
+class FileTable(QTableView):
+    paths_dropped = Signal(list)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setAcceptDrops(True)
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.setSelectionMode(QTableView.SelectionMode.ExtendedSelection)
+        self.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
+        self.setTabKeyNavigation(False)
+        self.setSortingEnabled(True)
+        self.setAlternatingRowColors(True)
+        self.setProperty("dragOver", "false")
+        self.muted_color = QColor(LIGHT.text_disabled)
+
+    def set_dark_theme(self, enabled: bool) -> None:
+        palette = DARK if enabled else LIGHT
+        self.muted_color = QColor(palette.text_disabled)
+        self.viewport().update()
+
+    def configure_columns(self) -> None:
+        header = self.horizontalHeader()
+        header.setStretchLastSection(False)
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        for column, width in ((1, 80), (2, 110), (3, 70), (4, 140), (5, 140)):
+            header.setSectionResizeMode(column, QHeaderView.ResizeMode.Interactive)
+            header.resizeSection(column, width)
+        for column in (4, 5):
+            self.setColumnHidden(column, True)
+
+    def dragEnterEvent(self, event: QDragEnterEvent) -> None:
+        accept_local_files(event)
+        set_drag_over(self, event.isAccepted())
+
+    def dragMoveEvent(self, event: QDragMoveEvent) -> None:
+        accept_local_files(event)
+
+    def dragLeaveEvent(self, event: QDragLeaveEvent) -> None:
+        set_drag_over(self, False)
+        event.accept()
+
+    def dropEvent(self, event: QDropEvent) -> None:
+        set_drag_over(self, False)
+        paths = dropped_paths(event)
+        if paths:
+            self.paths_dropped.emit(paths)
+            event.acceptProposedAction()
+        else:
+            event.ignore()