NotYAFC 1.0.0__py3-none-any.whl

font_converter/gui/instance_tree.py

@@ -0,0 +1,583 @@
+"""Per-font tree of the static instances to export from variable fonts."""
+
+from pathlib import Path
+
+from PySide6.QtCore import QPoint, Qt, Signal
+from PySide6.QtGui import (
+    QColor,
+    QDragEnterEvent,
+    QDragLeaveEvent,
+    QDragMoveEvent,
+    QDropEvent,
+    QKeySequence,
+    QShortcut,
+)
+from PySide6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QGridLayout,
+    QHeaderView,
+    QLabel,
+    QMenu,
+    QMessageBox,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from font_converter.gui.styles import DARK, LIGHT
+from font_converter.gui.widgets import (
+    DecimalSpinBox,
+    StepperField,
+    accept_local_files,
+    dropped_paths,
+    set_drag_over,
+)
+from font_converter.inspection import AxisInfo, FontInfo
+from font_converter.service import InstanceSpec, instance_label, instance_stem
+
+_SPEC_ROLE = Qt.ItemDataRole.UserRole
+_CUSTOM_ROLE = Qt.ItemDataRole.UserRole + 1
+_PATH_ROLE = Qt.ItemDataRole.UserRole + 2
+_AXES_ROLE = Qt.ItemDataRole.UserRole + 3
+_OUTLINES_ROLE = Qt.ItemDataRole.UserRole + 4
+_LOCATION_COLUMN = 4
+
+_Memory = tuple[set[InstanceSpec], list[InstanceSpec]]
+
+
+def _number(value: float) -> str:
+    return f"{value:g}"
+
+
+def location_text(coordinates: tuple[tuple[str, float], ...]) -> str:
+    if not coordinates:
+        return "Default"
+    return ", ".join(f"{tag}={_number(value)}" for tag, value in coordinates)
+
+
+class CustomInstanceDialog(QDialog):
+    """Ask for one value per axis of a single variable font."""
+
+    def __init__(
+        self,
+        axes: tuple[AxisInfo, ...],
+        named_instances: tuple[InstanceSpec, ...],
+        font_name: str,
+        input_path: Path,
+        parent: QWidget,
+        coordinates: tuple[tuple[str, float], ...] | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self.setWindowTitle(
+            "Edit custom instance" if coordinates is not None else "Custom instance"
+        )
+        self._axes = axes
+        self._named_instances = named_instances
+        self._input_path = input_path
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(16, 12, 16, 14)
+        layout.setSpacing(9)
+        intro = QLabel(f"Axis values for {font_name}")
+        intro.setObjectName("hint")
+        intro.setWordWrap(True)
+        layout.addWidget(intro)
+
+        grid = QGridLayout()
+        grid.setHorizontalSpacing(12)
+        grid.setVerticalSpacing(12)
+        self._boxes: dict[str, DecimalSpinBox] = {}
+        for row, axis in enumerate(axes):
+            box = DecimalSpinBox()
+            box.setDecimals(2)
+            box.setRange(axis.minimum, axis.maximum)
+            box.setValue(dict(coordinates or ()).get(axis.tag, axis.default))
+            self._boxes[axis.tag] = box
+            field = StepperField(box)
+            field.setFixedWidth(170)
+            range_label = QLabel(f"{_number(axis.minimum)}–{_number(axis.maximum)}")
+            range_label.setObjectName("hint")
+            grid.addWidget(QLabel(axis.tag), row, 0)
+            grid.addWidget(field, row, 1)
+            grid.addWidget(range_label, row, 2)
+        layout.addLayout(grid)
+
+        self.filename_preview = QLabel()
+        self.filename_preview.setObjectName("hint")
+        self.filename_preview.setWordWrap(True)
+        layout.addWidget(self.filename_preview)
+        for box in self._boxes.values():
+            box.valueChanged.connect(self._update_filename_preview)
+        self._update_filename_preview()
+
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def coordinates(self) -> tuple[tuple[str, float], ...]:
+        return tuple((tag, box.value()) for tag, box in self._boxes.items())
+
+    def _update_filename_preview(self) -> None:
+        coordinates = self.coordinates()
+        label = instance_label(coordinates)
+        coordinates_by_tag = dict(coordinates)
+        named_instance = next(
+            (
+                spec
+                for spec in self._named_instances
+                if spec.name
+                and len(spec.coordinates) == len(coordinates_by_tag)
+                and all(
+                    tag in coordinates_by_tag and abs(coordinates_by_tag[tag] - value) < 0.0000005
+                    for tag, value in spec.coordinates
+                )
+            ),
+            None,
+        )
+        stem = instance_stem(
+            self._input_path,
+            named_instance.name if named_instance is not None else None,
+            label,
+        )
+        self.filename_preview.setText(f"Output file: {stem}{self._input_path.suffix}")
+
+
+class InstanceTree(QTreeWidget):
+    """Variable fonts as parents, their exportable instances as checkable children."""
+
+    paths_dropped = Signal(list)
+    checksChanged = Signal()
+    actionsChanged = Signal()
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setObjectName("instanceTree")
+        self.setAcceptDrops(True)
+        self.setProperty("dragOver", "false")
+        self.setColumnCount(5)
+        self.setHeaderLabels(["Font / instance", "Format", "Outlines", "UPM", "Location"])
+        self.headerItem().setToolTip(
+            _LOCATION_COLUMN, "Axis coordinates. Drag the column divider to resize."
+        )
+        self.setRootIsDecorated(True)
+        self.setAlternatingRowColors(True)
+        self.setUniformRowHeights(True)
+        self.setTabKeyNavigation(False)
+        self.setSelectionMode(QTreeWidget.SelectionMode.SingleSelection)
+        self.setSortingEnabled(True)
+        self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        header = self.header()
+        header.setStretchLastSection(False)
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Stretch)
+        for column in range(1, self.columnCount()):
+            header.setSectionResizeMode(column, QHeaderView.ResizeMode.Interactive)
+        header.resizeSection(1, 90)
+        header.resizeSection(2, 90)
+        header.resizeSection(3, 70)
+        header.resizeSection(_LOCATION_COLUMN, 220)
+        self.sortByColumn(0, Qt.SortOrder.AscendingOrder)
+        self._filter_text = ""
+        self._hide_incompatible = False
+        self._memory: dict[Path, _Memory] = {}
+        self._muted_color = QColor(LIGHT.text_disabled)
+        self.itemChanged.connect(self._on_item_changed)
+        self.currentItemChanged.connect(lambda *_: self.actionsChanged.emit())
+        self.customContextMenuRequested.connect(self._show_menu)
+        self.itemDoubleClicked.connect(self._on_item_double_clicked)
+        self._delete_shortcut = QShortcut(QKeySequence.StandardKey.Delete, self)
+        self._delete_shortcut.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self._delete_shortcut.activated.connect(self.remove_custom)
+        self._menu_shortcut = QShortcut(QKeySequence("Shift+F10"), self)
+        self._menu_shortcut.setContext(Qt.ShortcutContext.WidgetShortcut)
+        self._menu_shortcut.activated.connect(self._show_current_menu)
+
+    def set_dark_theme(self, enabled: bool) -> None:
+        palette = DARK if enabled else LIGHT
+        self._muted_color = QColor(palette.text_disabled)
+        for index in range(self.topLevelItemCount()):
+            item = self.topLevelItem(index)
+            if item is not None and item.data(0, _PATH_ROLE) is None:
+                for column in range(self.columnCount()):
+                    item.setForeground(column, self._muted_color)
+        self.viewport().update()
+
+    def add_skipped(self, path: Path, label: str, reason: str, info: FontInfo) -> None:
+        """List a font that cannot be used, greyed out and with the reason."""
+        item = QTreeWidgetItem(self._row_texts(label, info, reason))
+        item.setFlags(Qt.ItemFlag.ItemIsEnabled)
+        item.setToolTip(0, f"{path}\n{reason}")
+        item.setToolTip(_LOCATION_COLUMN, reason)
+        for column in range(self.columnCount()):
+            item.setForeground(column, self._muted_color)
+        self.addTopLevelItem(item)
+        self.set_filter(self._filter_text)
+        self.viewport().update()
+        self.checksChanged.emit()
+
+    def add_font(
+        self, path: Path, label: str, info: FontInfo, checked_by_default: bool = True
+    ) -> None:
+        remembered = self._memory.get(path)
+        checked, custom = remembered if remembered else (None, [])
+        was_blocked = self.blockSignals(True)
+        parent = QTreeWidgetItem(self._row_texts(label, info, ""))
+        parent.setFlags(
+            Qt.ItemFlag.ItemIsEnabled
+            | Qt.ItemFlag.ItemIsSelectable
+            | Qt.ItemFlag.ItemIsUserCheckable
+            | Qt.ItemFlag.ItemIsAutoTristate
+        )
+        parent.setToolTip(0, str(path))
+        parent.setData(0, _PATH_ROLE, path)
+        parent.setData(0, _AXES_ROLE, info.axes)
+        parent.setData(0, _OUTLINES_ROLE, info.outlines)
+        self.addTopLevelItem(parent)
+        named = [InstanceSpec(i.coordinates, i.name) for i in info.instances]
+        for spec in named or [InstanceSpec(())]:
+            self._add_child(
+                parent,
+                spec,
+                custom=False,
+                checked=checked_by_default if checked is None else spec in checked,
+            )
+        for spec in custom:
+            self._add_child(parent, spec, custom=True, checked=checked is None or spec in checked)
+        self._update_summary(parent)
+        self._fit_location_column()
+        self.blockSignals(was_blocked)
+        self.set_filter(self._filter_text)
+        self.viewport().update()
+        self.checksChanged.emit()
+
+    def set_font_checked(self, path: Path, checked: bool) -> None:
+        font = next((item for item in self._fonts() if item.data(0, _PATH_ROLE) == path), None)
+        if font is None:
+            return
+        was_blocked = self.blockSignals(True)
+        state = Qt.CheckState.Checked if checked else Qt.CheckState.Unchecked
+        for child in self._children(font):
+            child.setCheckState(0, state)
+        self._update_summary(font)
+        self._remember(font)
+        self.blockSignals(was_blocked)
+        self.checksChanged.emit()
+
+    @staticmethod
+    def _row_texts(label: str, info: FontInfo, location: str) -> list[str]:
+        upm = "Mixed" if info.upm is None else str(info.upm)
+        return [label, info.format, info.outlines, upm, location]
+
+    def _add_child(
+        self, parent: QTreeWidgetItem, spec: InstanceSpec, custom: bool, checked: bool
+    ) -> QTreeWidgetItem:
+        name = spec.name or ("Default instance" if not spec.coordinates else "Custom instance")
+        location = location_text(spec.coordinates)
+        child = QTreeWidgetItem([name, "", "", "", location])
+        child.setFlags(
+            Qt.ItemFlag.ItemIsEnabled
+            | Qt.ItemFlag.ItemIsSelectable
+            | Qt.ItemFlag.ItemIsUserCheckable
+        )
+        child.setCheckState(0, Qt.CheckState.Checked if checked else Qt.CheckState.Unchecked)
+        child.setData(0, _SPEC_ROLE, spec)
+        child.setData(0, _CUSTOM_ROLE, custom)
+        child.setToolTip(_LOCATION_COLUMN, location)
+        parent.addChild(child)
+        return child
+
+    def _fit_location_column(self) -> None:
+        self.resizeColumnToContents(_LOCATION_COLUMN)
+        self.header().resizeSection(
+            _LOCATION_COLUMN, min(max(self.columnWidth(_LOCATION_COLUMN), 180), 360)
+        )
+
+    def set_hide_incompatible(self, hide: bool) -> None:
+        """Show or hide fonts that cannot be exported as variable instances."""
+        self._hide_incompatible = hide
+        self.set_filter(self._filter_text)
+
+    def set_filter(self, text: str) -> None:
+        """Filter fonts and instances while keeping a matching font's children visible."""
+        self._filter_text = text.casefold().strip()
+        for font in self._fonts():
+            font_match = self._matches(font)
+            child_match = False
+            for child in self._children(font):
+                matches = not self._filter_text or font_match or self._matches(child)
+                child.setHidden(not matches)
+                child_match = child_match or matches
+            font.setHidden(bool(self._filter_text) and not font_match and not child_match)
+        for index in range(self.topLevelItemCount()):
+            item = self.topLevelItem(index)
+            if item is not None and item.data(0, _PATH_ROLE) is None:
+                item.setHidden(
+                    self._hide_incompatible or (bool(self._filter_text) and not self._matches(item))
+                )
+
+    def _matches(self, item: QTreeWidgetItem) -> bool:
+        if not self._filter_text:
+            return True
+        text = " ".join(
+            item.text(column) + " " + item.toolTip(column) for column in range(self.columnCount())
+        )
+        return self._filter_text in text.casefold()
+
+    def _update_summary(self, parent: QTreeWidgetItem) -> None:
+        total = parent.childCount()
+        selected = sum(c.checkState(0) == Qt.CheckState.Checked for c in self._children(parent))
+        parent.setText(_LOCATION_COLUMN, f"{selected} of {total} selected")
+        parent.setToolTip(_LOCATION_COLUMN, f"{selected} of {total} instances selected")
+
+    def _on_item_changed(self, item: QTreeWidgetItem, column: int) -> None:
+        if column != 0:
+            return
+        parent = item.parent() or item
+        was_blocked = self.blockSignals(True)
+        self._update_summary(parent)
+        self.blockSignals(was_blocked)
+        self._remember(parent)
+        self.checksChanged.emit()
+
+    def _fonts(self) -> list[QTreeWidgetItem]:
+        items = (self.topLevelItem(i) for i in range(self.topLevelItemCount()))
+        return [item for item in items if item and item.data(0, _PATH_ROLE) is not None]
+
+    @staticmethod
+    def _children(font: QTreeWidgetItem) -> list[QTreeWidgetItem]:
+        return [item for i in range(font.childCount()) if (item := font.child(i))]
+
+    def _remember(self, font: QTreeWidgetItem) -> None:
+        children = self._children(font)
+        self._memory[font.data(0, _PATH_ROLE)] = (
+            {c.data(0, _SPEC_ROLE) for c in children if c.checkState(0) == Qt.CheckState.Checked},
+            [c.data(0, _SPEC_ROLE) for c in children if c.data(0, _CUSTOM_ROLE)],
+        )
+
+    def clear_fonts(self) -> None:
+        """Drop the rows for a rescan while keeping the user's choices."""
+        was_blocked = self.blockSignals(True)
+        self.clear()
+        self.blockSignals(was_blocked)
+        self.viewport().update()
+        self.checksChanged.emit()
+
+    def forget(self) -> None:
+        self._memory.clear()
+
+    def selection(self) -> tuple[tuple[Path, tuple[InstanceSpec, ...]], ...]:
+        result = []
+        for font in self._fonts():
+            specs = tuple(
+                c.data(0, _SPEC_ROLE)
+                for c in self._children(font)
+                if c.checkState(0) == Qt.CheckState.Checked
+            )
+            if specs:
+                result.append((font.data(0, _PATH_ROLE), specs))
+        return tuple(result)
+
+    def selected_paths(self) -> list[Path]:
+        return [path for path, _ in self.selection()]
+
+    def instance_count(self) -> int:
+        return sum(len(specs) for _, specs in self.selection())
+
+    def font_count(self) -> int:
+        return len(self._fonts())
+
+    def skipped_count(self) -> int:
+        return self.topLevelItemCount() - len(self._fonts())
+
+    def selected_outlines(self) -> set[str]:
+        """Outline kinds ("TrueType"/"PostScript") of the fonts with selected instances."""
+        return {
+            font.data(0, _OUTLINES_ROLE)
+            for font in self._fonts()
+            if any(c.checkState(0) == Qt.CheckState.Checked for c in self._children(font))
+        }
+
+    def auto_expand(self) -> None:
+        """Show the instances right away when there is a single variable font."""
+        fonts = self._fonts()
+        if len(fonts) == 1:
+            fonts[0].setExpanded(True)
+
+    def check_state(self) -> Qt.CheckState | None:
+        states = {c.checkState(0) for font in self._fonts() for c in self._children(font)}
+        if not states:
+            return None
+        if len(states) > 1:
+            return Qt.CheckState.PartiallyChecked
+        return states.pop()
+
+    def set_all_checked(self, checked: bool) -> None:
+        state = Qt.CheckState.Checked if checked else Qt.CheckState.Unchecked
+        was_blocked = self.blockSignals(True)
+        for font in self._fonts():
+            for child in self._children(font):
+                child.setCheckState(0, state)
+            self._update_summary(font)
+            self._remember(font)
+        self.blockSignals(was_blocked)
+        self.checksChanged.emit()
+
+    def _current_font(self) -> QTreeWidgetItem | None:
+        item = self.currentItem()
+        if item is None:
+            return None
+        font = item.parent() or item
+        return font if font.data(0, _PATH_ROLE) is not None else None
+
+    def can_add(self) -> bool:
+        return self._current_font() is not None
+
+    def can_remove(self) -> bool:
+        item = self.currentItem()
+        return item is not None and bool(item.data(0, _CUSTOM_ROLE))
+
+    def add_custom(self) -> None:
+        self._edit_or_add_custom()
+
+    def edit_custom(self) -> None:
+        item = self.currentItem()
+        if item is not None and item.data(0, _CUSTOM_ROLE):
+            self._edit_or_add_custom(item)
+
+    def _edit_or_add_custom(self, editing: QTreeWidgetItem | None = None) -> None:
+        font = self._current_font()
+        if font is None:
+            return
+        axes: tuple[AxisInfo, ...] = font.data(0, _AXES_ROLE)
+        if not axes:
+            return
+        named_instances = tuple(
+            child.data(0, _SPEC_ROLE)
+            for child in self._children(font)
+            if not child.data(0, _CUSTOM_ROLE) and child.data(0, _SPEC_ROLE).name is not None
+        )
+        input_path: Path = font.data(0, _PATH_ROLE)
+        dialog = CustomInstanceDialog(
+            axes,
+            named_instances,
+            font.text(0),
+            input_path,
+            self.window(),
+            editing.data(0, _SPEC_ROLE).coordinates if editing is not None else None,
+        )
+        if dialog.exec() != QDialog.DialogCode.Accepted:
+            return
+        spec = InstanceSpec(dialog.coordinates())
+        existing = next(
+            (
+                c
+                for c in self._children(font)
+                if c is not editing and c.data(0, _SPEC_ROLE).coordinates == spec.coordinates
+            ),
+            None,
+        )
+        if existing is not None and editing is not None:
+            QMessageBox.information(
+                self.window(),
+                "Instance already exists",
+                f'These values match the existing instance "{existing.text(0)}".',
+            )
+            return
+        was_blocked = self.blockSignals(True)
+        if existing is not None:
+            existing.setCheckState(0, Qt.CheckState.Checked)
+            target = existing
+            existing_spec: InstanceSpec = existing.data(0, _SPEC_ROLE)
+            if existing_spec.name is not None:
+                QMessageBox.information(
+                    self.window(),
+                    "Named instance already exists",
+                    f'These values match the named instance "{existing.text(0)}". '
+                    "The existing instance has been selected.",
+                )
+        elif editing is not None:
+            was_checked = editing.checkState(0) == Qt.CheckState.Checked
+            editing.setText(0, "Custom instance")
+            editing.setText(_LOCATION_COLUMN, location_text(spec.coordinates))
+            editing.setToolTip(_LOCATION_COLUMN, location_text(spec.coordinates))
+            editing.setData(0, _SPEC_ROLE, spec)
+            editing.setCheckState(
+                0, Qt.CheckState.Checked if was_checked else Qt.CheckState.Unchecked
+            )
+            target = editing
+        else:
+            target = self._add_child(font, spec, custom=True, checked=True)
+        font.setExpanded(True)
+        self._update_summary(font)
+        self.blockSignals(was_blocked)
+        self._remember(font)
+        self.setCurrentItem(target)
+        self.set_filter(self._filter_text)
+        self.checksChanged.emit()
+
+    def _on_item_double_clicked(self, item: QTreeWidgetItem, _column: int) -> None:
+        if item.data(0, _CUSTOM_ROLE):
+            self.setCurrentItem(item)
+            self.edit_custom()
+
+    def remove_custom(self) -> None:
+        item = self.currentItem()
+        parent = item.parent() if item is not None else None
+        if item is None or parent is None or not item.data(0, _CUSTOM_ROLE):
+            return
+        was_blocked = self.blockSignals(True)
+        parent.removeChild(item)
+        self._update_summary(parent)
+        self.blockSignals(was_blocked)
+        self._remember(parent)
+        self.actionsChanged.emit()
+        self.checksChanged.emit()
+
+    def _show_menu(self, position: QPoint) -> None:
+        item = self.itemAt(position)
+        if item is None:
+            return
+        self.setCurrentItem(item)
+        menu = QMenu(self)
+        add = menu.addAction("Add custom instance…")
+        add.setEnabled(self.can_add())
+        edit = menu.addAction("Edit custom instance…")
+        edit.setEnabled(self.can_remove())
+        remove = menu.addAction("Remove instance")
+        remove.setEnabled(self.can_remove())
+        chosen = menu.exec(self.viewport().mapToGlobal(position))
+        if chosen is add:
+            self.add_custom()
+        elif chosen is edit:
+            self.edit_custom()
+        elif chosen is remove:
+            self.remove_custom()
+
+    def _show_current_menu(self) -> None:
+        item = self.currentItem()
+        if item is not None:
+            self.scrollToItem(item)
+            self._show_menu(self.visualItemRect(item).center())
+
+    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()

font_converter/gui/logs.py

@@ -0,0 +1,51 @@
+"""Structured conversion log records kept in memory by the GUI."""
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Literal
+
+LogLevel = Literal["INFO", "WARNING", "ERROR"]
+
+
+@dataclass(frozen=True)
+class LogEntry:
+    timestamp: str
+    level: LogLevel
+    event: str
+    message: str
+    context: dict[str, object] = field(default_factory=dict)
+
+    @classmethod
+    def create(
+        cls,
+        level: LogLevel,
+        event: str,
+        message: str,
+        context: dict[str, object] | None = None,
+    ) -> "LogEntry":
+        return cls(
+            datetime.now().astimezone().isoformat(timespec="milliseconds"),
+            level,
+            event,
+            message,
+            context or {},
+        )
+
+    def display_text(self) -> str:
+        input_name = self.context.get("input")
+        input_label = f" [{input_name}]" if isinstance(input_name, str) else ""
+        return f"{self.timestamp} {self.level} [{self.event}]{input_label} {self.message}"
+
+    def to_json(self) -> str:
+        return json.dumps(
+            {
+                "timestamp": self.timestamp,
+                "level": self.level,
+                "event": self.event,
+                "message": self.message,
+                "context": self.context,
+            },
+            ensure_ascii=False,
+            sort_keys=True,
+        )