NotYAFC 1.0.0__py3-none-any.whl

font_converter/gui/organization_dialog.py

@@ -0,0 +1,417 @@
+"""Dialog for composing output-directory organization rules."""
+
+from dataclasses import dataclass, field
+from html import escape
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QStandardItem, QStandardItemModel
+from PySide6.QtWidgets import (
+    QComboBox,
+    QDialog,
+    QDialogButtonBox,
+    QFrame,
+    QGridLayout,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from font_converter.gui.widgets import KeyboardPushButton
+from font_converter.service import organization_level_name
+
+CRITERIA: dict[str, str] = {
+    "family": "Family",
+    "format": "Format",
+    "outline": "Outline type",
+    "upm": "UPM",
+    "tolerance": "Tolerance",
+    "simplify": "Contour simplification",
+}
+
+_PROFILE_CRITERIA: dict[str, tuple[str, ...]] = {
+    "ttf2otf": ("family", "format", "outline", "upm", "tolerance", "simplify"),
+    "otf2ttf": ("family", "format", "outline", "upm", "tolerance"),
+    "ft2wf": ("family", "format", "outline"),
+    "woff2ft": ("family", "format", "outline"),
+    "woff22ft": ("family", "format", "outline"),
+    "ttc2sfnt": ("family", "format", "outline"),
+    "var2static": ("family", "format", "outline", "upm"),
+}
+
+
+@dataclass
+class _LevelRow:
+    widget: QFrame
+    number: QLabel
+    criteria_layout: QGridLayout
+    add_criterion: QPushButton
+    move_up: QPushButton
+    move_down: QPushButton
+    remove_level: QPushButton
+    combos: list[QComboBox] = field(default_factory=list)
+    criterion_moves: dict[QComboBox, tuple[QPushButton, QPushButton]] = field(default_factory=dict)
+    criterion_removes: dict[QComboBox, QPushButton] = field(default_factory=dict)
+
+
+def available_organization_criteria(conversion: str) -> tuple[str, ...]:
+    return _PROFILE_CRITERIA.get(conversion, ("family", "format", "outline"))
+
+
+class OrganizationDialog(QDialog):
+    """Configure ordered directory levels, with multiple criteria per level."""
+
+    def __init__(
+        self,
+        conversion: str,
+        levels: tuple[tuple[str, ...], ...],
+        values: dict[str, str],
+        extension: str,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("Output organization")
+        self.setMinimumWidth(680)
+        self.resize(800, 360)
+        self._available = available_organization_criteria(conversion)
+        self._values = values
+        self._extension = extension
+        self._rows: list[_LevelRow] = []
+        self._previous: dict[QComboBox, str] = {}
+        self._models: dict[QComboBox, QStandardItemModel] = {}
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(22, 18, 22, 18)
+        layout.setSpacing(12)
+        intro = QLabel(
+            "Choose font properties to organize your output. Criteria in the same level are "
+            "joined with “_”; separate levels create nested folders, like family_format/outline."
+        )
+        intro.setObjectName("organizationIntro")
+        intro.setWordWrap(True)
+        layout.addWidget(intro)
+        levels_title = QLabel("FOLDER LEVELS")
+        levels_title.setObjectName("organizationSection")
+        layout.addWidget(levels_title)
+        self._levels_layout = QVBoxLayout()
+        self._levels_layout.setSpacing(7)
+        layout.addLayout(self._levels_layout)
+        self.empty_hint = QLabel(
+            "No folder levels: files will be saved directly in the chosen output location."
+        )
+        self.empty_hint.setObjectName("hint")
+        self.empty_hint.setWordWrap(True)
+        layout.addWidget(self.empty_hint)
+
+        actions = QHBoxLayout()
+        self.add_level_button = KeyboardPushButton("+  Add folder level")
+        self.add_level_button.setObjectName("organizationAddButton")
+        self.add_level_button.clicked.connect(lambda: self._add_level())
+        actions.addWidget(self.add_level_button)
+        actions.addStretch()
+        layout.addLayout(actions)
+        self.criteria_exhausted_hint = QLabel(
+            "All available criteria are already in use. Remove one to add it elsewhere."
+        )
+        self.criteria_exhausted_hint.setObjectName("hint")
+        self.criteria_exhausted_hint.setWordWrap(True)
+        layout.addWidget(self.criteria_exhausted_hint)
+
+        preview_title = QLabel("EXAMPLE OUTPUT PATH")
+        preview_title.setObjectName("organizationSection")
+        layout.addWidget(preview_title)
+        preview_hint = QLabel(
+            "Folder names and the file name are examples; actual output depends on the font."
+        )
+        preview_hint.setObjectName("hint")
+        preview_hint.setWordWrap(True)
+        layout.addWidget(preview_hint)
+        self.preview = QLabel()
+        self.preview.setWordWrap(True)
+        self.preview.setObjectName("pathLabel")
+        self.preview.setTextFormat(Qt.TextFormat.RichText)
+        self.preview.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        layout.addWidget(self.preview)
+        layout.addStretch()
+
+        self.buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        apply_button = self.buttons.button(QDialogButtonBox.StandardButton.Ok)
+        if apply_button is not None:
+            apply_button.setText("Apply")
+            apply_button.setObjectName("primaryButton")
+        self.buttons.accepted.connect(self.accept)
+        self.buttons.rejected.connect(self.reject)
+        layout.addWidget(self.buttons)
+
+        for level in levels:
+            supported = tuple(key for key in level if key in self._available)
+            if supported:
+                self._add_level(supported)
+        self._refresh()
+
+    @property
+    def levels(self) -> tuple[tuple[str, ...], ...]:
+        return tuple(tuple(str(combo.currentData()) for combo in row.combos) for row in self._rows)
+
+    def _add_level(self, criteria: tuple[str, ...] | None = None, *_: object) -> None:
+        focus_new_level = criteria is None and self.add_level_button.hasFocus()
+        used = {key for level in self.levels for key in level}
+        choices = [key for key in self._available if key not in used]
+        if criteria is None:
+            if not choices:
+                return
+            criteria = (choices[0],)
+        row_widget = QFrame(self)
+        row_widget.setObjectName("organizationLevel")
+        row_layout = QVBoxLayout(row_widget)
+        row_layout.setContentsMargins(12, 9, 12, 10)
+        row_layout.setSpacing(8)
+        header_layout = QHBoxLayout()
+        number = QLabel()
+        number.setObjectName("organizationLevelNumber")
+        header_layout.addWidget(number)
+        header_layout.addWidget(QLabel("Folder level"))
+        header_layout.addStretch()
+        move_up = KeyboardPushButton("↑")
+        move_up.setObjectName("organizationIconButton")
+        move_up.setToolTip("Move this folder level up")
+        move_up.setFixedSize(30, 28)
+        move_down = KeyboardPushButton("↓")
+        move_down.setObjectName("organizationIconButton")
+        move_down.setToolTip("Move this folder level down")
+        move_down.setFixedSize(30, 28)
+        remove_level = KeyboardPushButton("Remove level")
+        remove_level.setObjectName("organizationRemoveButton")
+        remove_level.setToolTip("Remove this folder level and all its criteria.")
+        remove_level.setAccessibleName("Remove folder level and all its criteria")
+        header_layout.addWidget(move_up)
+        header_layout.addWidget(move_down)
+        header_layout.addWidget(remove_level)
+        row_layout.addLayout(header_layout)
+
+        criteria_layout = QGridLayout()
+        criteria_layout.setContentsMargins(0, 0, 0, 0)
+        criteria_layout.setHorizontalSpacing(8)
+        criteria_layout.setVerticalSpacing(6)
+        row_layout.addLayout(criteria_layout)
+        add_criterion = KeyboardPushButton("+  Add criterion")
+        add_criterion.setObjectName("organizationAddCriterionButton")
+        row_layout.addWidget(add_criterion, 0, Qt.AlignmentFlag.AlignLeft)
+        row = _LevelRow(
+            row_widget, number, criteria_layout, add_criterion, move_up, move_down, remove_level
+        )
+        add_criterion.clicked.connect(lambda: self._add_criterion(row))
+        move_up.clicked.connect(lambda: self._move_level(row, -1))
+        move_down.clicked.connect(lambda: self._move_level(row, 1))
+        remove_level.clicked.connect(lambda: self._remove_level(row))
+        for criterion in criteria:
+            self._append_criterion(row, criterion)
+        self._rows.append(row)
+        self._refresh()
+        if focus_new_level:
+            row.combos[0].setFocus()
+
+    def _append_criterion(self, row: _LevelRow, criterion: str) -> None:
+        combo = QComboBox()
+        combo.setMinimumWidth(130)
+        model = QStandardItemModel(combo)
+        for key in self._available:
+            item = QStandardItem(CRITERIA[key])
+            item.setData(key, Qt.ItemDataRole.UserRole)
+            model.appendRow(item)
+        combo.setModel(model)
+        combo.setCurrentIndex(combo.findData(criterion))
+        combo.currentIndexChanged.connect(
+            lambda _index, current=combo: self._criterion_changed(current)
+        )
+        move_left = KeyboardPushButton("←")
+        move_left.setObjectName("organizationIconButton")
+        move_left.setFixedSize(30, 34)
+        move_left.setToolTip("Move this criterion earlier in the folder name.")
+        move_left.setAccessibleName("Move criterion earlier")
+        move_left.clicked.connect(lambda: self._move_criterion(row, combo, -1))
+        move_right = KeyboardPushButton("→")
+        move_right.setObjectName("organizationIconButton")
+        move_right.setFixedSize(30, 34)
+        move_right.setToolTip("Move this criterion later in the folder name.")
+        move_right.setAccessibleName("Move criterion later")
+        move_right.clicked.connect(lambda: self._move_criterion(row, combo, 1))
+        remove = KeyboardPushButton("×")
+        remove.setObjectName("organizationRemoveCriterionButton")
+        remove.setFixedSize(30, 34)
+        remove.setToolTip("Remove this criterion; removing the last one also removes the level.")
+        remove.setAccessibleName("Remove criterion")
+        remove.clicked.connect(lambda: self._remove_criterion(row, combo))
+        wrapper = QWidget()
+        wrapper_layout = QHBoxLayout(wrapper)
+        wrapper_layout.setContentsMargins(0, 0, 0, 0)
+        wrapper_layout.setSpacing(2)
+        wrapper_layout.addWidget(combo)
+        wrapper_layout.addWidget(move_left)
+        wrapper_layout.addWidget(move_right)
+        wrapper_layout.addWidget(remove)
+        row.combos.append(combo)
+        row.criterion_moves[combo] = (move_left, move_right)
+        row.criterion_removes[combo] = remove
+        self._layout_criteria(row)
+        self._previous[combo] = criterion
+        self._models[combo] = model
+
+    def _add_criterion(self, row: _LevelRow) -> None:
+        focus_new_criterion = row.add_criterion.hasFocus()
+        used = {key for level in self.levels for key in level}
+        criterion = next((key for key in self._available if key not in used), None)
+        if criterion is not None:
+            self._append_criterion(row, criterion)
+            self._refresh()
+            if focus_new_criterion:
+                row.combos[-1].setFocus()
+
+    def _criterion_changed(self, combo: QComboBox) -> None:
+        selected = str(combo.currentData())
+        if any(
+            other is not combo and other.currentData() == selected for other in self._all_combos()
+        ):
+            combo.blockSignals(True)
+            combo.setCurrentIndex(combo.findData(self._previous[combo]))
+            combo.blockSignals(False)
+            return
+        self._previous[combo] = selected
+        self._refresh()
+
+    def _remove_criterion(self, row: _LevelRow, combo: QComboBox) -> None:
+        wrapper = combo.parentWidget()
+        focused = self.focusWidget()
+        focus_removed = (
+            wrapper is not None
+            and focused is not None
+            and (focused is wrapper or wrapper.isAncestorOf(focused))
+        )
+        index = row.combos.index(combo)
+        if combo in row.combos:
+            row.combos.remove(combo)
+        row.criterion_moves.pop(combo, None)
+        row.criterion_removes.pop(combo, None)
+        if wrapper is not None:
+            row.criteria_layout.removeWidget(wrapper)
+            wrapper.hide()
+            wrapper.deleteLater()
+        self._previous.pop(combo, None)
+        self._models.pop(combo, None)
+        if not row.combos:
+            self._remove_level(row)
+        else:
+            self._layout_criteria(row)
+            self._refresh()
+            if focus_removed:
+                row.combos[min(index, len(row.combos) - 1)].setFocus()
+        if focus_removed and not row.combos:
+            self.add_level_button.setFocus()
+
+    def _remove_level(self, row: _LevelRow) -> None:
+        focused = self.focusWidget()
+        focus_removed = focused is not None and (
+            focused is row.widget or row.widget.isAncestorOf(focused)
+        )
+        index = self._rows.index(row)
+        if row in self._rows:
+            self._rows.remove(row)
+        for combo in row.combos:
+            self._previous.pop(combo, None)
+            self._models.pop(combo, None)
+        self._levels_layout.removeWidget(row.widget)
+        row.widget.hide()
+        row.widget.deleteLater()
+        self._refresh()
+        if focus_removed:
+            if self._rows:
+                self._rows[min(index, len(self._rows) - 1)].combos[0].setFocus()
+            else:
+                self.add_level_button.setFocus()
+
+    def _move_level(self, row: _LevelRow, offset: int) -> None:
+        focused = self.focusWidget()
+        index = self._rows.index(row)
+        target = index + offset
+        if 0 <= target < len(self._rows):
+            self._rows[index], self._rows[target] = self._rows[target], self._rows[index]
+            self._refresh()
+            if focused in (row.move_up, row.move_down) and not focused.isEnabled():
+                row.combos[0].setFocus()
+
+    def _move_criterion(self, row: _LevelRow, combo: QComboBox, offset: int) -> None:
+        focused = self.focusWidget()
+        index = row.combos.index(combo)
+        target = index + offset
+        if 0 <= target < len(row.combos):
+            row.combos[index], row.combos[target] = row.combos[target], row.combos[index]
+            self._layout_criteria(row)
+            self._refresh()
+            if focused in row.criterion_moves[combo] and not focused.isEnabled():
+                combo.setFocus()
+
+    def _all_combos(self) -> list[QComboBox]:
+        return [combo for row in self._rows for combo in row.combos]
+
+    @staticmethod
+    def _layout_criteria(row: _LevelRow) -> None:
+        while row.criteria_layout.count():
+            item = row.criteria_layout.takeAt(0)
+            if item is not None:
+                widget = item.widget()
+                if widget is not None:
+                    widget.setParent(row.widget)
+        for index, combo in enumerate(row.combos):
+            wrapper = combo.parentWidget()
+            if wrapper is not None:
+                row.criteria_layout.addWidget(wrapper, index // 2, index % 2)
+
+    def _refresh(self) -> None:
+        used = {key for level in self.levels for key in level}
+        has_available_criteria = any(key not in used for key in self._available)
+        self.criteria_exhausted_hint.setVisible(not has_available_criteria)
+        self.add_level_button.setEnabled(has_available_criteria)
+        self.empty_hint.setVisible(not self._rows)
+        for index, row in enumerate(self._rows):
+            row.number.setText(f"{index + 1}.")
+            self._levels_layout.removeWidget(row.widget)
+            self._levels_layout.insertWidget(index, row.widget)
+            row.move_up.setEnabled(index > 0)
+            row.move_down.setEnabled(index < len(self._rows) - 1)
+            row.add_criterion.setEnabled(has_available_criteria)
+            for position, combo in enumerate(row.combos):
+                move_left, move_right = row.criterion_moves[combo]
+                move_left.setEnabled(position > 0)
+                move_right.setEnabled(position < len(row.combos) - 1)
+                used_by_others = used - {str(combo.currentData())}
+                model = self._models[combo]
+                for item_index, key in enumerate(self._available):
+                    item = model.item(item_index)
+                    if item is not None:
+                        item.setEnabled(key not in used_by_others)
+        pieces = [organization_level_name(level, self._values) for level in self.levels]
+        suffix = "/" if pieces else ""
+        folder_path = escape(f"{'/'.join(pieces)}{suffix}")
+        filename = escape(f"font{self._extension}")
+        self.preview.setText(f"{folder_path}<b>{filename}</b>")
+        self._configure_tab_order()
+
+    def _configure_tab_order(self) -> None:
+        chain: list[QWidget] = []
+        for row in self._rows:
+            chain.extend((row.move_up, row.move_down, row.remove_level))
+            for combo in row.combos:
+                chain.append(combo)
+                chain.extend(row.criterion_moves[combo])
+                chain.append(row.criterion_removes[combo])
+            chain.append(row.add_criterion)
+        chain.append(self.add_level_button)
+        for role in (QDialogButtonBox.StandardButton.Ok, QDialogButtonBox.StandardButton.Cancel):
+            button = self.buttons.button(role)
+            if button is not None:
+                chain.append(button)
+        for current, following in zip(chain, chain[1:], strict=False):
+            QWidget.setTabOrder(current, following)