NotYAFC 1.0.0__py3-none-any.whl

font_converter/gui/window.py

@@ -0,0 +1,1768 @@
+"""Native NotYAFC converter window."""
+
+import os
+import threading
+import time
+from enum import Enum
+from pathlib import Path
+
+from PySide6.QtCore import (
+    QEvent,
+    QObject,
+    QPoint,
+    QSettings,
+    QSize,
+    Qt,
+    QThread,
+    QTimer,
+    QUrl,
+    Signal,
+)
+from PySide6.QtGui import (
+    QAction,
+    QCloseEvent,
+    QDesktopServices,
+    QGuiApplication,
+    QKeySequence,
+    QResizeEvent,
+    QShortcut,
+    QShowEvent,
+)
+from PySide6.QtWidgets import (
+    QAbstractButton,
+    QBoxLayout,
+    QButtonGroup,
+    QCheckBox,
+    QDialog,
+    QDialogButtonBox,
+    QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMainWindow,
+    QMenu,
+    QMessageBox,
+    QProgressBar,
+    QRadioButton,
+    QScrollArea,
+    QSizePolicy,
+    QStackedWidget,
+    QStyle,
+    QVBoxLayout,
+    QWidget,
+)
+
+from font_converter.gui.conversion_dialog import ConversionDialog
+from font_converter.gui.file_list import FontFileList
+from font_converter.gui.instance_tree import InstanceTree
+from font_converter.gui.logs import LogEntry, LogLevel
+from font_converter.gui.organization_dialog import (
+    CRITERIA,
+    OrganizationDialog,
+    available_organization_criteria,
+)
+from font_converter.gui.profile_options import ProfileOptionsPanel
+from font_converter.gui.profiles import CONVERSION_GROUP_HEADINGS, CONVERSIONS
+from font_converter.gui.styles import stylesheet_for
+from font_converter.gui.widgets import (
+    ConversionSelector,
+    DropZone,
+    ElidedLabel,
+    FileTable,
+    KeyboardPushButton,
+    ThemeToggle,
+)
+from font_converter.inspection import FontInfo, incompatibility
+from font_converter.service import (
+    ConversionOptions,
+    ConversionRequest,
+    ConversionResult,
+    ConversionSettings,
+    ConverterService,
+    FontOutcome,
+    FontOutcomeKind,
+    organization_level_name,
+)
+
+FONT_FILTER = "Font files (*.ttf *.otf *.woff *.woff2 *.ttc *.otc);;All files (*)"
+INPUT_DIR_KEY = "last_input_dir"
+OUTPUT_DIR_KEY = "last_output_dir"
+LOG_DIR_KEY = "last_log_dir"
+FONT_FILTER_PLACEHOLDER = "Filter fonts by name, family, style, format, outlines, or UPM…"
+OPTIONAL_FONT_COLUMNS = {4: ("Family", "font_columns/family"), 5: ("Style", "font_columns/style")}
+
+
+def _window_sizes(available: QSize | None) -> tuple[QSize, QSize]:
+    minimum = QSize(800, 500)
+    preferred = QSize(1200, 880)
+    if available is None:
+        return minimum, preferred
+    usable = QSize(max(1, available.width() - 40), max(1, available.height() - 80))
+    return minimum.boundedTo(usable), preferred.boundedTo(usable)
+
+
+def format_duration(seconds: float) -> str:
+    if seconds < 60:
+        return f"{seconds:.1f} s"
+    minutes, secs = divmod(int(seconds), 60)
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}:{minutes:02d}:{secs:02d}" if hours else f"{minutes}:{secs:02d}"
+
+
+def _exception_type(message: str) -> str | None:
+    name, separator, _ = message.partition(": ")
+    return name if separator and name.isidentifier() else None
+
+
+class RunState(Enum):
+    IDLE = "idle"
+    RUNNING = "running"
+    PAUSING = "pausing"
+    PAUSED = "paused"
+
+
+class ConversionWorker(QThread):
+    log_received = Signal(object)
+    progress_changed = Signal(int, int)
+    finished_conversion = Signal(object)
+    failed = Signal(str)
+    paused_changed = Signal(bool)
+
+    def __init__(self, request: ConversionRequest) -> None:
+        super().__init__()
+        self.request = request
+        self._current_input: Path | None = None
+        self._lock = threading.Lock()
+        self._running = threading.Event()
+        self._running.set()
+
+    def pause(self) -> None:
+        with self._lock:
+            if not self.isInterruptionRequested():
+                self._running.clear()
+
+    def resume(self) -> None:
+        with self._lock:
+            self._running.set()
+
+    def cancel(self) -> None:
+        with self._lock:
+            self.requestInterruption()
+            self._running.set()
+
+    def wait_if_paused(self) -> None:
+        if self._running.is_set():
+            return
+        self.paused_changed.emit(True)
+        self._running.wait()
+        self.paused_changed.emit(False)
+
+    def run(self) -> None:
+        try:
+            result = ConverterService().convert(
+                self.request,
+                on_log=lambda message: self._log(
+                    "INFO",
+                    "conversion.step",
+                    message,
+                    {
+                        "profile": self.request.conversion,
+                        "input": (
+                            self._current_input.name if self._current_input is not None else None
+                        ),
+                    },
+                ),
+                on_outcome=self._report_outcome,
+                on_progress=lambda progress: self.progress_changed.emit(
+                    progress.done, progress.total
+                ),
+                should_cancel=self.isInterruptionRequested,
+                on_font_start=self._on_font_start,
+                wait_if_paused=self.wait_if_paused,
+            )
+            self.finished_conversion.emit(result)
+        except Exception as error:
+            self.failed.emit(f"{type(error).__name__}: {error}")
+
+    def _on_font_start(self, input_path: Path) -> None:
+        self._current_input = input_path
+
+    def _report_outcome(self, outcome: FontOutcome) -> None:
+        duration = format_duration(outcome.elapsed)
+        name = outcome.input_path.name
+        if self.request.conversion == "var2static" and outcome.output_paths:
+            name = f"{name} → {outcome.output_paths[0].name}"
+        if outcome.kind is FontOutcomeKind.CONVERTED:
+            self._log(
+                "INFO",
+                "font.converted",
+                f"Converted {name} in {duration}",
+                {
+                    "input": outcome.input_path.name,
+                    "outputs": [path.name for path in outcome.output_paths],
+                    "elapsed_seconds": outcome.elapsed,
+                },
+            )
+        elif outcome.kind is FontOutcomeKind.SKIPPED:
+            self._log(
+                "INFO",
+                "font.skipped",
+                f"Skipped {name}",
+                {"input": outcome.input_path.name},
+            )
+        elif outcome.error is not None:
+            self._log(
+                "ERROR",
+                "font.failed",
+                f"{outcome.error} ({name}, {duration})",
+                {
+                    "input": outcome.input_path.name,
+                    "elapsed_seconds": outcome.elapsed,
+                    "error_type": _exception_type(outcome.error),
+                    "error": outcome.error,
+                },
+            )
+
+    def _log(
+        self,
+        level: LogLevel,
+        event: str,
+        message: str,
+        context: dict[str, object] | None = None,
+    ) -> None:
+        self.log_received.emit(LogEntry.create(level, event, message, context))
+
+
+class ConverterWindow(QMainWindow):
+    def __init__(self) -> None:
+        super().__init__()
+        self.setWindowTitle("NotYAFC")
+        screen = self.screen()
+        available = screen.availableGeometry().size() if screen is not None else None
+        minimum, initial = _window_sizes(available)
+        self.setMinimumSize(minimum)
+        self.resize(initial)
+        self.worker: ConversionWorker | None = None
+        self.output_directory: Path | None = None
+        self.organization_levels: tuple[tuple[str, ...], ...] = ()
+        self._settings = QSettings()
+        self._close_when_finished = False
+        self._saved_files: list[Path] = []
+        self._run_output_directory: Path | None = None
+        self._run_input_directory: Path | None = None
+        self._last_run_available = False
+        self._sources: list[Path] = []
+        self._scan_cancelled = False
+        self._input_check_states: dict[Path, bool] = {}
+        self._log_entries: list[LogEntry] = []
+        self._progress_done = 0
+        self._progress_total = 0
+        self._session_started_at: float | None = None
+        self._session_elapsed = 0.0
+        self._cancelling = False
+        self._run_state = RunState.IDLE
+        self._profile_options_width = 0
+        self._elapsed_timer = QTimer(self)
+        self._elapsed_timer.setInterval(1000)
+        self._elapsed_timer.timeout.connect(self._refresh_progress_status)
+
+        page = QWidget()
+        page.setObjectName("page")
+        layout = QVBoxLayout(page)
+        layout.setContentsMargins(26, 12, 26, 12)
+        layout.setSpacing(8)
+
+        title = QLabel("NotYAFC")
+        title.setObjectName("pageTitle")
+        subtitle = ElidedLabel("Not Yet Another Font Converter")
+        subtitle.setObjectName("pageSubtitle")
+        subtitle.setToolTip(subtitle.text())
+        subtitle.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        self.theme_toggle = ThemeToggle()
+        title_row = QHBoxLayout()
+        title_row.addWidget(title)
+        title_row.addWidget(subtitle, 1)
+        title_row.addWidget(self.theme_toggle)
+        layout.addLayout(title_row)
+
+        self.conversion = ConversionSelector(
+            CONVERSIONS, select_first=False, group_headings=CONVERSION_GROUP_HEADINGS
+        )
+        conversion_layout = QVBoxLayout()
+        conversion_layout.setContentsMargins(16, 12, 16, 14)
+        conversion_layout.addWidget(self.conversion)
+        self.conversion_group = QGroupBox("2. Choose a conversion")
+        self.conversion_group.setObjectName("card")
+        self.conversion_group.setLayout(conversion_layout)
+        self.conversion_group.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
+        self.profile_options = ProfileOptionsPanel()
+        self.profile_options.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
+        self.conversion.currentIndexChanged.connect(self._apply_compatibility)
+        self.conversion.currentIndexChanged.connect(lambda _index: self._on_conversion_changed())
+        self.conversion.currentIndexChanged.connect(self._update_buttons)
+        self.profile_options.compatibilityChanged.connect(self._apply_compatibility)
+        self.profile_options.validityChanged.connect(self._update_buttons)
+
+        self.overwrite = QCheckBox("Overwrite existing files")
+        self.overwrite.setChecked(False)
+        self.recalc_bboxes = QCheckBox("Recalculate bounding boxes")
+        self.recalc_bboxes.setChecked(True)
+        self.recalc_bboxes.setToolTip("Rebuild glyph bounds before writing output files.")
+        self.recalc_timestamp = QCheckBox("Recalculate modified timestamp")
+        self.recalc_timestamp.setToolTip("Set a fresh font modification timestamp on save.")
+        self.reorder_tables = QCheckBox("Reorder tables on save")
+        self.reorder_tables.setChecked(True)
+        self.reorder_tables.setToolTip("Use a standard table order for compatibility.")
+        self.organization_button = KeyboardPushButton("Organize output…")
+        self.organization_button.setToolTip("Choose how converted fonts are grouped into folders.")
+        self.organization_button.clicked.connect(self._show_organization_dialog)
+
+        self.advanced_settings_button = KeyboardPushButton("Save options…")
+        self.advanced_settings_button.setToolTip("Configure how output fonts are saved.")
+        for button in (self.organization_button, self.advanced_settings_button):
+            button.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Fixed)
+        self.advanced_settings_dialog = QDialog(self)
+        self.advanced_settings_dialog.setWindowTitle("Save options")
+        advanced_layout = QVBoxLayout(self.advanced_settings_dialog)
+        advanced_layout.setContentsMargins(16, 12, 16, 14)
+        advanced_layout.setSpacing(9)
+        for checkbox in (self.recalc_bboxes, self.recalc_timestamp, self.reorder_tables):
+            advanced_layout.addWidget(checkbox)
+        advanced_buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        advanced_buttons.accepted.connect(self.advanced_settings_dialog.accept)
+        advanced_buttons.rejected.connect(self.advanced_settings_dialog.reject)
+        advanced_layout.addWidget(advanced_buttons)
+        self.advanced_settings_button.clicked.connect(self._show_advanced_settings)
+
+        self.files_group = QGroupBox("1. Add fonts")
+        self.files_group.setObjectName("card")
+        files_layout = QVBoxLayout(self.files_group)
+        files_layout.setContentsMargins(16, 12, 16, 14)
+        files_layout.setSpacing(9)
+        self.files_header = QBoxLayout(QBoxLayout.Direction.LeftToRight)
+        self.input_buttons = QBoxLayout(QBoxLayout.Direction.LeftToRight)
+        self.input_options = QBoxLayout(QBoxLayout.Direction.LeftToRight)
+        self.add_button = KeyboardPushButton("Add files…")
+        self.add_folder_button = KeyboardPushButton("Add folder…")
+        self.clear_button = KeyboardPushButton("Clear list")
+        self.input_buttons.addWidget(self.add_button)
+        self.recursive = QCheckBox("Recurse subfolders")
+        self.recursive.setToolTip("Also look for fonts in subfolders.")
+        self.recursive.toggled.connect(self._refresh_folder_contents)
+        self.input_buttons.addWidget(self.add_folder_button)
+        self.input_options.addWidget(self.recursive)
+        self.input_options.addStretch()
+        self.input_options.addWidget(self.clear_button)
+        self.files_header.addLayout(self.input_buttons)
+        self.files_header.addLayout(self.input_options, 1)
+        files_layout.addLayout(self.files_header)
+        self.select_all_checkbox = QCheckBox("Select compatible fonts")
+        self.select_all_checkbox.setTristate(True)
+        self.select_all_checkbox.setToolTip("Select or clear all visible compatible fonts.")
+        self.select_all_checkbox.clicked.connect(self._toggle_visible_checks)
+        self.hide_incompatible = QCheckBox("Hide incompatible")
+        self.hide_incompatible.setToolTip(
+            "Hide fonts that cannot be used with the selected profile."
+        )
+        self.hide_incompatible.toggled.connect(self._apply_compatibility)
+        self.hide_incompatible.toggled.connect(self._update_buttons)
+        self.file_options_row = QBoxLayout(QBoxLayout.Direction.LeftToRight)
+        self.file_options_row.setSpacing(12)
+        self.file_options_row.addWidget(self.select_all_checkbox)
+        self.file_options_row.addWidget(self.hide_incompatible)
+        self.file_options_row.addStretch()
+        files_layout.addLayout(self.file_options_row)
+        self.font_filter = QLineEdit()
+        self.font_filter.setPlaceholderText(FONT_FILTER_PLACEHOLDER)
+        self.font_filter.setClearButtonEnabled(True)
+        self.font_filter.setToolTip("Filter the font list by matching text.")
+        self.font_filter.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Fixed)
+        self.add_instance_button = KeyboardPushButton("Add custom instance…")
+        self.add_instance_button.setToolTip("Select a variable font or instance to add one.")
+        self.instance_view_button = KeyboardPushButton("View")
+        self.instance_view_button.setToolTip("Expand or collapse all variable fonts.")
+        self.instance_view_menu = QMenu(self.instance_view_button)
+        self.expand_instances_action = self.instance_view_menu.addAction("Expand all")
+        self.collapse_instances_action = self.instance_view_menu.addAction("Collapse all")
+        self.instance_view_button.setMenu(self.instance_view_menu)
+        self.filter_row = QBoxLayout(QBoxLayout.Direction.LeftToRight)
+        self.filter_row.setSpacing(9)
+        self.filter_row.addWidget(self.font_filter, 1)
+        self.filter_row.addWidget(self.add_instance_button)
+        self.filter_row.addWidget(self.instance_view_button)
+        files_layout.addLayout(self.filter_row)
+
+        self.files = FileTable()
+        self.file_list = FontFileList(self.files, self._compatibility_profile)
+        self.column_menu = QMenu(self.files)
+        table_header = self.files.horizontalHeader()
+        table_header.setToolTip("Click to sort; right-click to choose optional columns.")
+        table_header.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        table_header.customContextMenuRequested.connect(self._show_column_menu)
+        for column, (name, key) in OPTIONAL_FONT_COLUMNS.items():
+            visible = bool(self._settings.value(key, False, type=bool))
+            self.files.setColumnHidden(column, not visible)
+            action = self.column_menu.addAction(name)
+            action.setData(column)
+            action.setCheckable(True)
+            action.setChecked(visible)
+            action.toggled.connect(self._set_column_visible)
+        self.file_list.progress.connect(self._on_scan_progress)
+        self.file_list.font_found.connect(self._on_font_found)
+        self.file_list.scan_finished.connect(self._on_scan_finished)
+        self.files.setMinimumHeight(150)
+        self.files.setToolTip("Check the fonts to convert. Click a column header to sort.")
+        self.file_list.model.dataChanged.connect(self._on_file_item_changed)
+        self.instance_tree = InstanceTree()
+        self.font_filter.textChanged.connect(self.instance_tree.set_filter)
+        self.font_filter.textChanged.connect(self.file_list.proxy.setFilterFixedString)
+        self.font_filter.textChanged.connect(self._update_buttons)
+        self.instance_tree.setMinimumHeight(150)
+        self.instance_tree.setToolTip(
+            "Check instances to export. Double-click a custom instance to edit it; "
+            "right-click it or press Shift+F10 for actions, or Delete to remove it."
+        )
+        self.instance_tree.checksChanged.connect(self._update_buttons)
+        self.instance_tree.actionsChanged.connect(self._sync_instance_actions)
+        self.expand_instances_action.triggered.connect(self.instance_tree.expandAll)
+        self.collapse_instances_action.triggered.connect(self.instance_tree.collapseAll)
+        self.add_instance_button.clicked.connect(self.instance_tree.add_custom)
+        self._sync_instance_actions()
+        self.files_stack = QStackedWidget()
+        self.files_stack.addWidget(self.files)
+        self.files_stack.addWidget(self.instance_tree)
+        self.drop_zone = DropZone()
+        self.files_stack.addWidget(self.drop_zone)
+        self.instance_view_hint = QLabel(
+            "The font list is now an instance tree. Expand a font to select its instances."
+        )
+        self.instance_view_hint.setObjectName("stepHint")
+        self.instance_view_hint.setWordWrap(True)
+        self.instance_view_hint.hide()
+        files_layout.addWidget(self.instance_view_hint)
+        files_layout.addWidget(self.files_stack)
+        self.scan_widget = QWidget()
+        scan_layout = QHBoxLayout(self.scan_widget)
+        scan_layout.setContentsMargins(0, 0, 0, 0)
+        scan_layout.setSpacing(10)
+        self.scan_label = QLabel()
+        self.scan_label.setObjectName("stepHint")
+        self.scan_label.setWordWrap(True)
+        self.scan_progress = QProgressBar()
+        self.scan_progress.setTextVisible(False)
+        self.scan_progress.setFixedHeight(8)
+        scan_layout.addWidget(self.scan_label)
+        scan_layout.addWidget(self.scan_progress, 1)
+        self.scan_stop_button = KeyboardPushButton("Stop")
+        self.scan_stop_button.setToolTip("Stop the scan and keep the fonts found so far.")
+        self.scan_stop_button.clicked.connect(self._cancel_scan)
+        scan_layout.addWidget(self.scan_stop_button)
+        self.scan_widget.setVisible(False)
+        files_layout.addWidget(self.scan_widget)
+        self.variable_hint = QLabel()
+        self.variable_hint.setObjectName("stepHint")
+        self.variable_hint.setWordWrap(True)
+        self.variable_hint.hide()
+        files_layout.addWidget(self.variable_hint)
+        self.destination_group = QGroupBox("3. Choose output")
+        self.destination_group.setObjectName("card")
+        self.destination_group.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
+        destination_layout = QVBoxLayout(self.destination_group)
+        destination_layout.setContentsMargins(16, 12, 16, 18)
+        destination_layout.setSpacing(9)
+        self.destination_source_radio = QRadioButton("Same as source")
+        self.destination_folder_radio = QRadioButton("Folder")
+        self.destination_source_radio.setChecked(True)
+        self.destination_mode_group = QButtonGroup(self)
+        self.destination_mode_group.addButton(self.destination_source_radio)
+        self.destination_mode_group.addButton(self.destination_folder_radio)
+        self.destination_edit = QLineEdit()
+        self.destination_edit.setReadOnly(True)
+        self.destination_edit.setEnabled(False)
+        self.destination_button = KeyboardPushButton("…")
+        self.destination_button.setObjectName("stepperButton")
+        self.destination_button.setToolTip("Choose output folder")
+        self.destination_button.setEnabled(False)
+        destination = QHBoxLayout()
+        destination.setSpacing(8)
+        destination.addWidget(self.destination_folder_radio)
+        destination.addWidget(self.destination_edit, 1)
+        destination.addWidget(self.destination_button)
+        destination_layout.addWidget(self.destination_source_radio, 0, Qt.AlignmentFlag.AlignLeft)
+        destination_layout.addLayout(destination)
+        destination_layout.addWidget(self.overwrite, 0, Qt.AlignmentFlag.AlignLeft)
+        options_row = QHBoxLayout()
+        options_row.setSpacing(9)
+        options_row.addWidget(self.organization_button, 1)
+        options_row.addWidget(self.advanced_settings_button, 1)
+        destination_layout.addLayout(options_row)
+        self.organization_preview = QLabel()
+        self.organization_preview.setObjectName("hint")
+        self.organization_preview.setTextFormat(Qt.TextFormat.PlainText)
+        self.organization_preview.setWordWrap(True)
+        self.organization_preview.setSizePolicy(
+            QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred
+        )
+        self.organization_preview.setToolTip(
+            "Example output path. Actual folder and file names depend on the font."
+        )
+        self.organization_preview.hide()
+        destination_layout.addWidget(self.organization_preview)
+        for checkbox in (
+            self.profile_options.use_target_upm,
+            self.profile_options.format_woff,
+            self.profile_options.format_woff2,
+        ):
+            checkbox.toggled.connect(self._update_organization_button)
+        for spinbox in (
+            self.profile_options.target_upm,
+            self.profile_options.tolerance,
+            self.profile_options.optimize_contours,
+        ):
+            spinbox.valueChanged.connect(self._update_organization_button)
+        sidebar = QWidget()
+        sidebar.setObjectName("page")
+        sidebar_layout = QVBoxLayout(sidebar)
+        sidebar_layout.setContentsMargins(0, 0, 0, 0)
+        sidebar_layout.setSpacing(8)
+        sidebar_layout.addWidget(self.conversion_group)
+        sidebar_layout.addWidget(self.profile_options)
+        sidebar_layout.addWidget(self.destination_group)
+        sidebar_layout.addStretch()
+        self.sidebar_scroll = QScrollArea()
+        self.sidebar_scroll.setWidgetResizable(True)
+        self.sidebar_scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+        self.sidebar_scroll.setWidget(sidebar)
+        self.sidebar_scroll.setMinimumSize(0, 200)
+        self._sidebar_maximum_width = self.sidebar_scroll.maximumWidth()
+        self.sidebar_scroll.setSizePolicy(QSizePolicy.Policy.Maximum, QSizePolicy.Policy.Expanding)
+
+        self.body_layout = QBoxLayout(QBoxLayout.Direction.LeftToRight)
+        self.body_layout.setSpacing(12)
+        self.body_layout.addWidget(self.files_group, 1)
+        self.body_layout.addWidget(self.sidebar_scroll)
+        layout.addLayout(self.body_layout, 1)
+
+        self.convert_button = KeyboardPushButton("Convert")
+        self.convert_button.setObjectName("primaryButton")
+        self.convert_button.setProperty("footerPrimary", True)
+        self.convert_button.setMinimumHeight(56)
+        self.convert_button.setSizePolicy(
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
+        )
+        self.convert_button.setDefault(True)
+        self.convert_button.setToolTip("Start conversion (Ctrl+Enter).")
+        self.convert_shortcuts = [
+            QShortcut(QKeySequence(key), self) for key in ("Ctrl+Return", "Ctrl+Enter")
+        ]
+        for shortcut in self.convert_shortcuts:
+            shortcut.activated.connect(self.convert_button.click)
+        self.convert_button.setEnabled(False)
+        self.conversion_required_hint = QLabel("Choose a conversion to continue.")
+        self.conversion_required_hint.setObjectName("stepHint")
+        self.conversion_required_hint.setWordWrap(True)
+        self.convert_column = QWidget()
+        convert_layout = QVBoxLayout(self.convert_column)
+        convert_layout.setContentsMargins(0, 0, 0, 0)
+        convert_layout.setSpacing(6)
+        convert_layout.addWidget(self.conversion_required_hint)
+        convert_layout.addWidget(self.convert_button, 1)
+        self.conversion_dialog = ConversionDialog(self)
+        self.cancel_button = self.conversion_dialog.cancel_button
+        self.pause_button = self.conversion_dialog.pause_button
+        self.progress = self.conversion_dialog.progress
+        self.log = self.conversion_dialog.log
+        self.save_logs_button = self.conversion_dialog.save_logs_button
+        self.last_run_button = KeyboardPushButton("View last run")
+        self.last_run_button.setToolTip("Show the progress and logs of the last conversion.")
+        self.last_run_button.setEnabled(False)
+        self.last_run_button.hide()
+        self.open_output_button = KeyboardPushButton("Open output folder")
+        self.open_output_button.setEnabled(False)
+        self.open_output_button.hide()
+        self.summary = ElidedLabel()
+        self.summary.setObjectName("statusLabel")
+        self.summary.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        self.status = ElidedLabel()
+        self.status.setObjectName("statusLabel")
+        self.status.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        self.status.hide()
+        self.result_actions = QWidget()
+        self.result_actions_layout = QBoxLayout(
+            QBoxLayout.Direction.LeftToRight, self.result_actions
+        )
+        self.result_actions_layout.setContentsMargins(0, 0, 0, 0)
+        self.result_actions_layout.setSpacing(6)
+        self.result_actions_layout.addWidget(self.last_run_button)
+        self.result_actions_layout.addWidget(self.open_output_button)
+        self.result_actions.hide()
+        self.actions_row = QHBoxLayout()
+        self.actions_row.addWidget(self.status, 1)
+        self.actions_row.addWidget(self.result_actions)
+        self.result_row = QHBoxLayout()
+        self.result_row.addStretch()
+        footer_left = QWidget()
+        footer_left.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+        footer_left_layout = QVBoxLayout(footer_left)
+        footer_left_layout.setContentsMargins(0, 0, 0, 0)
+        footer_left_layout.setSpacing(6)
+        footer_left_layout.addWidget(self.summary)
+        footer_left_layout.addLayout(self.actions_row)
+        footer_left_layout.addLayout(self.result_row)
+        self.footer = QWidget()
+        self.footer.setObjectName("actionBar")
+        self.footer.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        self.footer_layout = QBoxLayout(QBoxLayout.Direction.LeftToRight, self.footer)
+        self.footer_layout.setContentsMargins(26, 10, 26, 14)
+        self.footer_layout.setSpacing(self.body_layout.spacing())
+        self.footer_layout.addWidget(footer_left, 1)
+        self.footer_layout.addWidget(self.convert_column)
+        self.content_scroll = QScrollArea()
+        self.content_scroll.setWidgetResizable(True)
+        self.content_scroll.setFrameShape(QScrollArea.Shape.NoFrame)
+        self.content_scroll.setWidget(page)
+        self.content_scroll.viewport().installEventFilter(self)
+        central = QWidget()
+        central.setObjectName("page")
+        central_layout = QVBoxLayout(central)
+        central_layout.setContentsMargins(0, 0, 0, 0)
+        central_layout.setSpacing(0)
+        central_layout.addWidget(self.content_scroll, 1)
+        central_layout.addWidget(self.footer)
+        self.setCentralWidget(central)
+        if self._settings.contains("dark_theme"):
+            self._dark_theme = bool(self._settings.value("dark_theme", False, type=bool))
+        else:
+            self._dark_theme = QGuiApplication.styleHints().colorScheme() == Qt.ColorScheme.Dark
+        self.setStyleSheet(stylesheet_for(self._dark_theme))
+        self.theme_toggle.set_dark_theme(self._dark_theme)
+        self.files.set_dark_theme(self._dark_theme)
+        self.instance_tree.set_dark_theme(self._dark_theme)
+        self.drop_zone.set_dark_theme(self._dark_theme)
+        self.theme_toggle.themeChanged.connect(self._set_theme)
+
+        self.add_button.clicked.connect(self._choose_files)
+        self.add_folder_button.clicked.connect(self._choose_folder)
+        self.clear_button.clicked.connect(self._clear_files)
+        self.files.paths_dropped.connect(self._add_paths)
+        self.instance_tree.paths_dropped.connect(self._add_paths)
+        self.drop_zone.paths_dropped.connect(self._add_paths)
+        self.drop_zone.addFilesRequested.connect(self._choose_files)
+        self.drop_zone.addFolderRequested.connect(self._choose_folder)
+        self.files.selectionModel().selectionChanged.connect(lambda *_: self._update_buttons())
+        self.destination_button.clicked.connect(self._choose_destination)
+        self.destination_source_radio.toggled.connect(self._on_destination_mode_changed)
+        self.convert_button.clicked.connect(self._start_conversion)
+        self.cancel_button.clicked.connect(self._cancel_conversion)
+        self.pause_button.clicked.connect(self._toggle_pause)
+        self.open_output_button.clicked.connect(self._open_output_folder)
+        self.conversion_dialog.open_output_button.clicked.connect(self._open_output_folder)
+        self.save_logs_button.clicked.connect(self._save_logs)
+        self.last_run_button.clicked.connect(self._show_conversion_dialog)
+        self._configure_tab_order()
+        self.profile_options.set_conversion(None)
+        self._update_body_layout()
+        self._update_buttons()
+
+    def resizeEvent(self, event: QResizeEvent) -> None:
+        super().resizeEvent(event)
+        if hasattr(self, "body_layout"):
+            self._update_body_layout()
+        if hasattr(self, "result_actions"):
+            self._update_footer_layout()
+
+    def eventFilter(self, watched: QObject, event: QEvent) -> bool:
+        if (
+            hasattr(self, "content_scroll")
+            and watched is self.content_scroll.viewport()
+            and event.type() == QEvent.Type.Resize
+        ):
+            QTimer.singleShot(0, self._sync_footer_margins)
+        return super().eventFilter(watched, event)
+
+    def _sync_footer_margins(self) -> None:
+        scrollbar_width = self.content_scroll.width() - self.content_scroll.viewport().width()
+        if self.footer_layout.contentsMargins().right() != 26 + scrollbar_width:
+            self.footer_layout.setContentsMargins(26, 10, 26 + scrollbar_width, 14)
+            self._update_body_layout()
+
+    def _update_footer_layout(self) -> None:
+        width = self.width() - self.footer_layout.contentsMargins().left()
+        width -= self.footer_layout.contentsMargins().right()
+        if self.body_layout.direction() == QBoxLayout.Direction.LeftToRight:
+            width -= self.sidebar_scroll.width() + self.footer_layout.spacing()
+        self._wrap_button_text(self.last_run_button, "View last run", width, 28)
+        self._wrap_button_text(self.open_output_button, "Open output folder", width, 28)
+        buttons_width = (
+            self.last_run_button.sizeHint().width()
+            + self.open_output_button.sizeHint().width()
+            + self.result_actions_layout.spacing()
+        )
+        separate = self.width() < 650 or width < buttons_width + 80
+        self.result_actions_layout.setDirection(
+            QBoxLayout.Direction.TopToBottom
+            if width < buttons_width
+            else QBoxLayout.Direction.LeftToRight
+        )
+        if separate:
+            if self.result_row.indexOf(self.result_actions) < 0:
+                self.actions_row.removeWidget(self.result_actions)
+                self.result_row.addWidget(self.result_actions)
+        elif self.actions_row.indexOf(self.result_actions) < 0:
+            self.result_row.removeWidget(self.result_actions)
+            self.actions_row.insertWidget(1, self.result_actions)
+
+    def _update_result_actions(self) -> None:
+        self.result_actions.setVisible(
+            not self.last_run_button.isHidden() or not self.open_output_button.isHidden()
+        )
+
+    def showEvent(self, event: QShowEvent) -> None:
+        super().showEvent(event)
+        QTimer.singleShot(0, self._refresh_sidebar_metrics)
+
+    def _refresh_sidebar_metrics(self) -> None:
+        button_width = max(
+            self.organization_button.sizeHint().width(),
+            self.advanced_settings_button.sizeHint().width(),
+        )
+        self.organization_button.setMinimumWidth(button_width)
+        self.advanced_settings_button.setMinimumWidth(button_width)
+        destination_layout = self.destination_group.layout()
+        if destination_layout is not None:
+            destination_layout.invalidate()
+            destination_layout.activate()
+        panel = ProfileOptionsPanel()
+        panel.setAttribute(Qt.WidgetAttribute.WA_DontShowOnScreen)
+        panel.setStyleSheet(self.styleSheet())
+        panel.show()
+        widest = 0
+        for conversion in CONVERSIONS:
+            panel.set_conversion(conversion)
+            layout = panel.layout()
+            if layout is not None:
+                layout.invalidate()
+                layout.activate()
+            widest = max(widest, panel.minimumSizeHint().width())
+        panel.close()
+        panel.deleteLater()
+        self._profile_options_width = widest
+        self._update_body_layout()
+
+    def _update_body_layout(self) -> None:
+        direction = (
+            QBoxLayout.Direction.LeftToRight
+            if self.width() >= 1050
+            else QBoxLayout.Direction.TopToBottom
+        )
+        if self.body_layout.direction() != direction:
+            self.body_layout.setDirection(direction)
+        horizontal = direction == QBoxLayout.Direction.LeftToRight
+        self.footer_layout.setDirection(
+            QBoxLayout.Direction.LeftToRight if horizontal else QBoxLayout.Direction.BottomToTop
+        )
+        self.body_layout.setStretch(0, 1)
+        self.body_layout.setStretch(1, 0)
+        self.sidebar_scroll.setSizePolicy(
+            QSizePolicy.Policy.Maximum if horizontal else QSizePolicy.Policy.Expanding,
+            QSizePolicy.Policy.Expanding,
+        )
+        sidebar = self.sidebar_scroll.widget()
+        if horizontal:
+            conversion_layout = self.conversion_group.layout()
+            if conversion_layout is not None:
+                conversion_layout.invalidate()
+            widths = [
+                self.conversion_group.sizeHint().width(),
+                self.destination_group.minimumSizeHint().width(),
+                self._profile_options_width,
+            ]
+            if not self.profile_options.isHidden():
+                widths.append(self.profile_options.minimumSizeHint().width())
+            scrollbar = self.style().pixelMetric(QStyle.PixelMetric.PM_ScrollBarExtent)
+            sidebar_width = max(widths) + scrollbar
+            self.sidebar_scroll.setFixedWidth(sidebar_width)
+            self.convert_column.setFixedWidth(sidebar_width)
+        else:
+            self.sidebar_scroll.setMaximumWidth(self._sidebar_maximum_width)
+            self.sidebar_scroll.setMinimumWidth(
+                sidebar.minimumSizeHint().width()
+                + self.style().pixelMetric(QStyle.PixelMetric.PM_ScrollBarExtent)
+                if sidebar is not None
+                else 0
+            )
+            self.convert_column.setMinimumWidth(0)
+            self.convert_column.setMaximumWidth(16777215)
+        available = self.width() - 52
+        if horizontal:
+            available -= sidebar_width + self.body_layout.spacing()
+        if self.content_scroll.verticalScrollBar().isVisible():
+            available -= self.content_scroll.verticalScrollBar().width()
+        self._update_input_layout(available - 34)
+        self._update_footer_layout()
+        self.sidebar_scroll.setMinimumHeight(
+            200 if horizontal or sidebar is None else max(200, sidebar.sizeHint().height())
+        )
+
+    def _update_input_layout(self, width: int) -> None:
+        horizontal = QBoxLayout.Direction.LeftToRight
+        vertical = QBoxLayout.Direction.TopToBottom
+        self._wrap_button_text(self.recursive, "Recurse subfolders", width, 40)
+        self._wrap_button_text(self.hide_incompatible, "Hide incompatible", width, 40)
+        self._wrap_button_text(self.add_instance_button, "Add custom instance…", width, 28)
+        header_width = (
+            sum(
+                widget.sizeHint().width()
+                for widget in (
+                    self.add_button,
+                    self.add_folder_button,
+                    self.recursive,
+                    self.clear_button,
+                )
+            )
+            + 3 * self.files_header.spacing()
+        )
+        self.files_header.setDirection(horizontal if width >= header_width else vertical)
+        self.input_buttons.setDirection(
+            horizontal
+            if width
+            >= self.add_button.sizeHint().width()
+            + self.add_folder_button.sizeHint().width()
+            + self.input_buttons.spacing()
+            else vertical
+        )
+        self.input_options.setDirection(
+            horizontal
+            if width
+            >= self.recursive.sizeHint().width()
+            + self.clear_button.sizeHint().width()
+            + self.input_options.spacing()
+            else vertical
+        )
+        self._wrap_button_text(
+            self.select_all_checkbox, self.select_all_checkbox.text().replace("\n", " "), width, 40
+        )
+        options_width = (
+            self.select_all_checkbox.sizeHint().width()
+            + self.hide_incompatible.sizeHint().width()
+            + self.file_options_row.spacing()
+        )
+        self.file_options_row.setDirection(horizontal if width >= options_width else vertical)
+        filter_width = 70 + sum(
+            widget.sizeHint().width() + self.filter_row.spacing()
+            for widget in (self.add_instance_button, self.instance_view_button)
+            if not widget.isHidden()
+        )
+        self.filter_row.setDirection(horizontal if width >= filter_width else vertical)
+
+    @staticmethod
+    def _wrap_button_text(button: QAbstractButton, text: str, width: int, padding: int) -> None:
+        lines: list[str] = []
+        for word in text.split():
+            candidate = f"{lines[-1]} {word}" if lines else word
+            if lines and button.fontMetrics().horizontalAdvance(candidate) + padding > width:
+                lines.append(word)
+            elif lines:
+                lines[-1] = candidate
+            else:
+                lines.append(word)
+        wrapped = "\n".join(lines)
+        if button.text() != wrapped:
+            button.setText(wrapped)
+
+    def _configure_tab_order(self) -> None:
+        profile = self.profile_options
+        chain: list[QWidget] = [
+            self.theme_toggle,
+            self.add_button,
+            self.add_folder_button,
+            self.recursive,
+            self.clear_button,
+            self.select_all_checkbox,
+            self.hide_incompatible,
+            self.font_filter,
+            self.add_instance_button,
+            self.instance_view_button,
+            self.drop_zone.add_files_button,
+            self.drop_zone.add_folder_button,
+            self.files,
+            self.instance_tree,
+            *self.conversion.findChildren(QRadioButton),
+            profile.tolerance_field.decrement_button,
+            profile.tolerance,
+            profile.tolerance_field.increment_button,
+            profile.optimize_contours_field.decrement_button,
+            profile.optimize_contours,
+            profile.optimize_contours_field.increment_button,
+            profile.use_target_upm,
+            profile.target_upm_field.decrement_button,
+            profile.target_upm,
+            profile.target_upm_field.increment_button,
+            profile.subroutinize,
+            profile.autohint,
+            profile.format_woff,
+            profile.format_woff2,
+            profile.obfuscate_names,
+            profile.remove_unused_glyphs,
+            profile.remove_non_windows_names,
+            profile.remove_dsig,
+            profile.css_kit,
+            self.destination_source_radio,
+            self.destination_folder_radio,
+            self.destination_button,
+            self.overwrite,
+            self.organization_button,
+            self.advanced_settings_button,
+            self.last_run_button,
+            self.open_output_button,
+            self.convert_button,
+        ]
+        for current, following in zip(chain, chain[1:], strict=False):
+            QWidget.setTabOrder(current, following)
+
+    def _show_column_menu(self, pos: QPoint) -> None:
+        self.column_menu.popup(self.files.horizontalHeader().mapToGlobal(pos))
+
+    def _set_column_visible(self, visible: bool) -> None:
+        action = self.sender()
+        if not isinstance(action, QAction):
+            raise TypeError("Column visibility changes must come from a QAction")
+        column = int(action.data())
+        self.files.setColumnHidden(column, not visible)
+        self._settings.setValue(OPTIONAL_FONT_COLUMNS[column][1], visible)
+
+    def _set_theme(self, enabled: bool) -> None:
+        self._dark_theme = enabled
+        self._settings.setValue("dark_theme", enabled)
+        self.setStyleSheet(stylesheet_for(enabled))
+        self.files.set_dark_theme(enabled)
+        self.instance_tree.set_dark_theme(enabled)
+        self.drop_zone.set_dark_theme(enabled)
+        self.theme_toggle.set_dark_theme(enabled)
+        self._refresh_sidebar_metrics()
+
+    def _on_conversion_changed(self) -> None:
+        conversion = self.conversion.currentData()
+        if conversion is None:
+            return
+        self.profile_options.set_conversion(conversion)
+        available = set(available_organization_criteria(conversion))
+        self.organization_levels = tuple(
+            filtered
+            for level in self.organization_levels
+            if (filtered := tuple(key for key in level if key in available))
+        )
+        self._update_organization_button()
+        self._update_body_layout()
+
+    def _organization_preview(self) -> tuple[dict[str, str], str]:
+        conversion = str(self.conversion.currentData())
+        format_: str = self.profile_options.selected_web_format() or "woff2"
+        if conversion != "ft2wf":
+            format_ = "opentype"
+        outline = {
+            "ttf2otf": "ps",
+            "otf2ttf": "tt",
+            "var2static": "tt",
+        }.get(conversion, "tt")
+        upm = (
+            str(self.profile_options.target_upm.value())
+            if self.profile_options.use_target_upm.isChecked()
+            else "1000"
+        )
+        values = {
+            "family": "Sample Family",
+            "format": format_,
+            "outline": outline,
+            "upm": upm,
+            "tolerance": f"{self.profile_options.tolerance.value():g}",
+            "simplify": str(self.profile_options.optimize_contours.value()),
+        }
+        extension = {
+            "ttf2otf": ".otf",
+            "otf2ttf": ".ttf",
+            "ft2wf": f".{format_}",
+            "woff2ft": ".ttf",
+            "woff22ft": ".ttf",
+            "ttc2sfnt": ".ttf",
+            "var2static": ".ttf",
+        }.get(conversion, ".ttf")
+        return values, extension
+
+    def _show_organization_dialog(self) -> None:
+        values, extension = self._organization_preview()
+        dialog = OrganizationDialog(
+            str(self.conversion.currentData()),
+            self.organization_levels,
+            values,
+            extension,
+            self,
+        )
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            self.organization_levels = dialog.levels
+            self._update_organization_button()
+            self._update_body_layout()
+
+    def _update_organization_button(self, *_: object) -> None:
+        self.organization_preview.setVisible(bool(self.organization_levels))
+        if not self.organization_levels:
+            self.organization_button.setToolTip(
+                "Choose how converted fonts are grouped into folders."
+            )
+            self.organization_preview.clear()
+            return
+        summary = " → ".join(
+            " + ".join(CRITERIA[key] for key in level) for level in self.organization_levels
+        )
+        self.organization_button.setToolTip(f"Output folder levels: {summary}")
+        values, extension = self._organization_preview()
+        pieces = [organization_level_name(level, values) for level in self.organization_levels]
+        self.organization_preview.setText(f"Example: {'/'.join(pieces)}/font{extension}")
+
+    def _show_advanced_settings(self) -> None:
+        previous = (
+            self.recalc_bboxes.isChecked(),
+            self.recalc_timestamp.isChecked(),
+            self.reorder_tables.isChecked(),
+        )
+        if self.advanced_settings_dialog.exec() == QDialog.DialogCode.Rejected:
+            for checkbox, checked in zip(
+                (self.recalc_bboxes, self.recalc_timestamp, self.reorder_tables),
+                previous,
+                strict=True,
+            ):
+                checkbox.setChecked(checked)
+
+    def _saved_dir(self, key: str) -> str:
+        value = self._settings.value(key, "")
+        return value if isinstance(value, str) and Path(value).is_dir() else ""
+
+    def _choose_files(self) -> None:
+        paths, _ = QFileDialog.getOpenFileNames(
+            self, "Select font files", self._saved_dir(INPUT_DIR_KEY), FONT_FILTER
+        )
+        if paths:
+            self._settings.setValue(INPUT_DIR_KEY, str(Path(paths[0]).parent))
+        self._add_paths(paths)
+
+    def _choose_folder(self) -> None:
+        selected = QFileDialog.getExistingDirectory(
+            self, "Select font folder", self._saved_dir(INPUT_DIR_KEY) or str(Path.home())
+        )
+        if selected:
+            self._settings.setValue(INPUT_DIR_KEY, selected)
+            self._add_paths([selected])
+
+    def _add_paths(self, paths: list[str]) -> None:
+        for raw_path in paths:
+            path = Path(raw_path)
+            if not path.is_dir() and not path.is_file():
+                continue
+            path = path.resolve()
+            if path in self._sources:
+                continue
+            self._sources.append(path)
+        self._refresh_folder_contents()
+
+    def _refresh_folder_contents(self) -> None:
+        self._remember_input_checks()
+        self._stop_scan()
+        self.files.setSortingEnabled(False)
+        self.file_list.clear()
+        self.instance_tree.clear_fonts()
+        self.conversion.set_compatibility_counts(None, 0)
+        self._update_body_layout()
+        self._scan_cancelled = False
+        if not self._sources:
+            self.files.setSortingEnabled(True)
+            self._update_buttons()
+            return
+        self.scan_progress.setRange(0, 0)
+        self.scan_progress.setVisible(True)
+        self.scan_label.setText("Searching for files…")
+        self.scan_widget.setVisible(True)
+        self.scan_stop_button.setEnabled(True)
+        self.file_list.start(list(self._sources), self.recursive.isChecked())
+        self._update_buttons()
+
+    def _stop_scan(self) -> None:
+        self.file_list.stop()
+        self.scan_widget.setVisible(False)
+
+    def _cancel_scan(self) -> None:
+        if not self.file_list.scanning:
+            return
+        self._scan_cancelled = True
+        self.scan_stop_button.setEnabled(False)
+        self.file_list.cancel()
+
+    def _on_scan_progress(self, done: int, total: int) -> None:
+        if total == 0:
+            self.scan_progress.setRange(0, 0)
+            self.scan_label.setText("Searching for files…")
+            return
+        self.scan_progress.setRange(0, total)
+        self.scan_progress.setValue(done)
+        self.scan_label.setText(f"Scanning fonts… {done} / {total}")
+
+    def _is_instance_mode(self) -> bool:
+        return self.conversion.currentData() == "var2static"
+
+    def _on_font_found(self, path: Path, info: FontInfo) -> None:
+        source = next((s for s in self._sources if s.is_dir() and path.is_relative_to(s)), None)
+        label = path.name if source is None else path.relative_to(source).as_posix()
+        checked = self._input_check_states.setdefault(path, True)
+        was_blocked = self.files.blockSignals(True)
+        self.file_list.add_font(path, label, info, checked)
+        self.files.blockSignals(was_blocked)
+        if info.variable and not info.collection:
+            self.instance_tree.add_font(path, label, info, checked_by_default=checked)
+        else:
+            reason = incompatibility(info, "var2static") or "Not a variable font"
+            self.instance_tree.add_skipped(path, label, reason, info)
+        if self.file_list.row_count == 1:
+            self._update_buttons()
+
+    def _sync_instance_actions(self) -> None:
+        self.add_instance_button.setEnabled(self.instance_tree.can_add())
+
+    def _on_scan_finished(self) -> None:
+        self.scan_progress.setVisible(False)
+        self.files.setSortingEnabled(True)
+        header = self.files.horizontalHeader()
+        self.files.sortByColumn(header.sortIndicatorSection(), header.sortIndicatorOrder())
+        self.instance_tree.auto_expand()
+        rows = list(self.file_list.rows())
+        if rows:
+            counts = {
+                conversion: sum(incompatibility(row.info, conversion) is None for row in rows)
+                for conversion in CONVERSIONS
+            }
+            self.conversion.set_compatibility_counts(counts, len(rows))
+        self._update_body_layout()
+        self._update_buttons()
+
+    def _apply_compatibility(self, *_: object) -> None:
+        self.file_list.apply_compatibility()
+        self.instance_tree.set_hide_incompatible(self.hide_incompatible.isChecked())
+
+    def _selected_input_paths(self) -> list[Path]:
+        if self._is_instance_mode():
+            return self.instance_tree.selected_paths()
+        return self.file_list.selected_paths()
+
+    def _remember_input_checks(self) -> None:
+        self._input_check_states.update(self.file_list.remember_checks())
+
+    def _on_file_item_changed(self, *_: object) -> None:
+        for row in self.file_list.rows():
+            if (
+                row.path in self._input_check_states
+                and self._input_check_states[row.path] != row.checked
+            ):
+                self.instance_tree.set_font_checked(row.path, row.checked)
+        self._remember_input_checks()
+        self._update_buttons()
+
+    def _set_visible_checks(self, checked: bool) -> None:
+        if self._is_instance_mode():
+            self.instance_tree.set_all_checked(checked)
+            return
+        self.file_list.set_visible_checks(checked)
+        self._remember_input_checks()
+        self._update_buttons()
+
+    def _toggle_visible_checks(self) -> None:
+        checked = self.select_all_checkbox.checkState() != Qt.CheckState.Unchecked
+        self._set_visible_checks(checked)
+
+    def _clear_files(self) -> None:
+        self._sources.clear()
+        self._input_check_states.clear()
+        self.instance_tree.forget()
+        self._refresh_folder_contents()
+
+    def _choose_destination(self) -> None:
+        start = str(self.output_directory or self._saved_dir(OUTPUT_DIR_KEY) or Path.home())
+        selected = QFileDialog.getExistingDirectory(self, "Choose output folder", start)
+        if selected:
+            self._settings.setValue(OUTPUT_DIR_KEY, selected)
+            self.output_directory = Path(selected)
+            self.destination_edit.setText(selected)
+            self._update_buttons()
+        elif self.output_directory is None:
+            self.destination_source_radio.setChecked(True)
+
+    def _on_destination_mode_changed(self, source_selected: bool) -> None:
+        if source_selected:
+            self.output_directory = None
+            self.destination_edit.clear()
+            self.destination_edit.setPlaceholderText("")
+        else:
+            self.destination_edit.setPlaceholderText("Choose an output folder…")
+            saved_directory = self._saved_dir(OUTPUT_DIR_KEY)
+            if saved_directory:
+                self.destination_edit.setText(saved_directory)
+                self.output_directory = Path(saved_directory)
+            else:
+                self.output_directory = None
+                self._choose_destination()
+        self._update_buttons()
+
+    def _web_format_valid(self) -> bool:
+        conversion = self.conversion.currentData()
+        if conversion != "ft2wf":
+            return True
+        return self.profile_options.web_format_valid()
+
+    def _update_buttons(self) -> None:
+        instance_mode = self._is_instance_mode()
+        has_rows = self.file_list.row_count > 0
+        self.drop_zone.set_scanning(self.file_list.scanning)
+        self.files_stack.setCurrentWidget(
+            self.drop_zone if not has_rows else self.instance_tree if instance_mode else self.files
+        )
+        self.instance_view_hint.setVisible(instance_mode and has_rows)
+        self.hide_incompatible.setVisible(True)
+        self.font_filter.setVisible(True)
+        if instance_mode:
+            self.font_filter.setPlaceholderText("Filter fonts or instances…")
+            self.font_filter.setToolTip(
+                "Show fonts and instances whose names, locations, or paths match."
+            )
+        else:
+            self.font_filter.setPlaceholderText(FONT_FILTER_PLACEHOLDER)
+            self.font_filter.setToolTip("Filter the font list by matching text.")
+        has_fonts = self.instance_tree.font_count() > 0
+        instance_controls_visible = not self.add_instance_button.isHidden()
+        self.add_instance_button.setVisible(instance_mode and has_fonts)
+        self.instance_view_button.setVisible(instance_mode and has_fonts)
+        if instance_controls_visible != (instance_mode and has_fonts):
+            self._update_body_layout()
+        self.font_filter.setEnabled(
+            self.instance_tree.font_count() > 0 if instance_mode else self.file_list.row_count > 0
+        )
+        self.profile_options.set_instance_outlines(
+            self.instance_tree.selected_outlines() if instance_mode else set()
+        )
+        self.select_all_checkbox.setText(
+            "Select all instances"
+            if instance_mode
+            else "Select compatible fonts"
+            if self.conversion.currentData() is not None
+            else "Select all fonts"
+        )
+        self._update_body_layout()
+        self._sync_instance_actions()
+        has_roots = bool(self._sources)
+        selected = (
+            self.instance_tree.instance_count()
+            if instance_mode
+            else len(self.file_list.selected_paths())
+        )
+        has_files = selected > 0
+        has_logs = self.log.count() > 0
+        scanning = self.file_list.scanning
+        folder_mode = self.destination_folder_radio.isChecked()
+        conversion = self.conversion.currentData()
+        self.conversion_required_hint.setVisible(conversion is None)
+        unit = "instance" if instance_mode else "font"
+        if selected != 1:
+            unit += "s"
+        self.convert_button.setText(f"Convert {selected} {unit}" if selected else "Convert")
+        self.convert_button.setEnabled(
+            conversion is not None
+            and has_files
+            and not scanning
+            and self.worker is None
+            and self._web_format_valid()
+        )
+        self.conversion_dialog.set_running(self.worker is not None)
+        self.last_run_button.setEnabled(has_logs)
+        self.last_run_button.setVisible(self._last_run_available and has_logs)
+        self._update_result_actions()
+        self.pause_button.setText("Resume" if self._run_state is RunState.PAUSED else "Pause")
+        self.pause_button.setEnabled(
+            self._run_state in (RunState.RUNNING, RunState.PAUSED) and not self._cancelling
+        )
+        self.clear_button.setEnabled(has_roots)
+        check_state = (
+            self.instance_tree.check_state()
+            if instance_mode
+            else self.file_list.visible_check_state()
+        )
+        self.select_all_checkbox.setEnabled(check_state is not None and not scanning)
+        self.select_all_checkbox.setCheckState(
+            Qt.CheckState.Unchecked if check_state is None else check_state
+        )
+        self.destination_edit.setEnabled(folder_mode)
+        self.destination_button.setEnabled(folder_mode)
+        if scanning:
+            summary = "Wait for the font scan to finish."
+        elif self.file_list.row_count == 0:
+            summary = "Add font files or folders to get started."
+        elif conversion is None:
+            summary = f"{selected} {unit} selected" if has_files else "No fonts selected."
+        elif not has_files:
+            summary = "Select compatible fonts or instances to continue."
+        elif not self._web_format_valid():
+            summary = "Choose at least one web font format to continue."
+        else:
+            destination = str(self.output_directory) if folder_mode else "same as source"
+            summary = f"{CONVERSIONS[conversion]} · {selected} {unit} selected · {destination}"
+        self.summary.setText(summary)
+        self.save_logs_button.setEnabled(has_logs and self.worker is None)
+        self.scan_stop_button.setVisible(scanning)
+        variable_count = sum(
+            1
+            for row in self.file_list.rows()
+            if row.info.variable and not row.info.collection and row.reason is not None
+        )
+        self.variable_hint.setVisible(
+            not scanning and conversion is not None and variable_count > 0
+        )
+        if variable_count:
+            unit = "font" if variable_count == 1 else "fonts"
+            self.variable_hint.setText(
+                f"{variable_count} variable {unit} found: "
+                "use Variable → Static to export instances."
+            )
+        if not scanning:
+            count = self.file_list.row_count
+            compatible = self.file_list.compatible_count()
+            if instance_mode:
+                fonts = self.instance_tree.font_count()
+                instances = self.instance_tree.instance_count()
+                text = (
+                    f"{fonts} variable font{'' if fonts == 1 else 's'} · "
+                    f"{instances} instance{'' if instances == 1 else 's'} selected"
+                )
+                skipped = self.instance_tree.skipped_count()
+                if skipped:
+                    text += f" · {skipped} skipped"
+                if count == 0:
+                    text = "No fonts found"
+            elif count == 0:
+                text = "No fonts found"
+            else:
+                text = f"{count} font{'' if count == 1 else 's'} found"
+                if conversion is None:
+                    text += " · choose a conversion"
+                elif compatible == 0:
+                    text += " · none compatible with this profile"
+                elif compatible != count:
+                    text += f" · {compatible} compatible"
+            if self._scan_cancelled:
+                text = "Scan stopped · " + text
+            if not instance_mode:
+                selected_rows = self.files.selectionModel().selectedRows()
+                if len(selected_rows) == 1:
+                    reason = selected_rows[0].data(Qt.ItemDataRole.UserRole + 1)
+                    if reason:
+                        text += f" · {reason}"
+            self.scan_label.setText(text)
+            self.scan_label.setToolTip(text)
+            self.scan_widget.setVisible(has_roots)
+
+    def _append_log(self, entry: LogEntry) -> None:
+        self._log_entries.append(entry)
+        self.log.addItem(entry.display_text())
+        self.log.scrollToBottom()
+        self._update_buttons()
+
+    def _show_conversion_dialog(self) -> None:
+        self.conversion_dialog.open()
+
+    def _set_output_available(self, available: bool) -> None:
+        self.open_output_button.setEnabled(available)
+        self.open_output_button.setVisible(available)
+        self._update_result_actions()
+        self.conversion_dialog.open_output_button.setEnabled(available)
+
+    def _set_status(self, text: str, state: str = "") -> None:
+        self.conversion_dialog.set_status(text, state)
+        self.status.setText(text)
+        self.status.show()
+        self.status.setProperty("state", state)
+        self.status.style().unpolish(self.status)
+        self.status.style().polish(self.status)
+
+    def _save_logs(self) -> None:
+        if not self._log_entries:
+            self._set_status("No logs available to save.", "warning")
+            return
+        start = str(Path(self._saved_dir(LOG_DIR_KEY) or Path.home()) / "font-converter.jsonl")
+        selected, _ = QFileDialog.getSaveFileName(
+            self, "Save logs", start, "JSON Lines logs (*.jsonl);;All files (*)"
+        )
+        if not selected:
+            return
+        text = "\n".join(entry.to_json() for entry in self._log_entries)
+        try:
+            Path(selected).write_text(text + "\n", encoding="utf-8")
+        except OSError as error:
+            self._set_status(f"Could not save logs: {error}", "error")
+            return
+        self._settings.setValue(LOG_DIR_KEY, str(Path(selected).parent))
+        self._set_status(f"Logs saved to {selected}.")
+
+    def _options(self) -> ConversionSettings:
+        conversion = self.conversion.currentData()
+        if conversion is None:
+            raise ValueError("Choose a conversion profile first.")
+        common = ConversionOptions(
+            recursive=self.recursive.isChecked(),
+            output_dir=self.output_directory,
+            overwrite=self.overwrite.isChecked(),
+            recalc_bboxes=self.recalc_bboxes.isChecked(),
+            recalc_timestamp=self.recalc_timestamp.isChecked(),
+            reorder_tables=self.reorder_tables.isChecked(),
+            organization_levels=self.organization_levels,
+        )
+        return self.profile_options.settings_for(
+            conversion, common, self.instance_tree.selection() if conversion == "var2static" else ()
+        )
+
+    def _compatibility_profile(self) -> tuple[str | None, bool]:
+        return (
+            self.conversion.currentData(),
+            self.hide_incompatible.isChecked(),
+        )
+
+    def _start_conversion(self) -> None:
+        if self.conversion.currentData() is None:
+            return
+        input_paths = self._selected_input_paths()
+        if not input_paths:
+            return
+        if any(not path.exists() for path in input_paths):
+            QMessageBox.critical(
+                self, "Input unavailable", "One or more selected inputs no longer exist."
+            )
+            return
+
+        total = (
+            self.instance_tree.instance_count() if self._is_instance_mode() else len(input_paths)
+        )
+        self._log_entries.clear()
+        self.log.clear()
+        self._last_run_available = False
+        self._run_output_directory = self.output_directory
+        self._run_input_directory = input_paths[0].parent
+        self.progress.setRange(0, total)
+        self.progress.setValue(0)
+        self._set_status(f"Converting… 0 / {total} · 0.0 s")
+        self._set_output_available(False)
+        self.cancel_button.setEnabled(True)
+        self._saved_files = []
+        self._progress_done = 0
+        self._progress_total = total
+        self._session_elapsed = 0.0
+        self._cancelling = False
+        self._run_state = RunState.RUNNING
+        self.worker = ConversionWorker(ConversionRequest(tuple(input_paths), self._options()))
+        self.worker.log_received.connect(self._append_log)
+        self.worker.paused_changed.connect(self._on_paused_changed)
+        self.worker.progress_changed.connect(self._on_conversion_progress)
+        self.worker.finished_conversion.connect(self._conversion_finished)
+        self.worker.failed.connect(self._conversion_failed)
+        self.worker.finished.connect(self._worker_stopped)
+        self._update_buttons()
+        self._session_started_at = time.perf_counter()
+        self._append_log(
+            LogEntry.create(
+                "INFO",
+                "conversion.started",
+                f"Started {self.worker.request.conversion} conversion",
+                {
+                    "profile": self.worker.request.conversion,
+                    "input_count": len(input_paths),
+                    "inputs": [path.name for path in input_paths],
+                    "target_count": total,
+                },
+            )
+        )
+        self._elapsed_timer.start()
+        self.worker.start()
+        self.conversion_dialog.open()
+
+    def _conversion_elapsed(self) -> float:
+        if self._session_started_at is None:
+            return self._session_elapsed
+        return time.perf_counter() - self._session_started_at
+
+    def _finish_conversion_timer(self) -> None:
+        self._elapsed_timer.stop()
+        if self._session_started_at is not None:
+            self._session_elapsed = time.perf_counter() - self._session_started_at
+            self._session_started_at = None
+
+    def _refresh_progress_status(self) -> None:
+        if self._cancelling or self._run_state in (RunState.PAUSING, RunState.PAUSED):
+            return
+        self._set_status(
+            f"Converting… {self._progress_done} / {self._progress_total}"
+            f" · {format_duration(self._conversion_elapsed())}"
+        )
+
+    def _on_conversion_progress(self, done: int, total: int) -> None:
+        self.progress.setRange(0, total)
+        self.progress.setValue(done)
+        self._progress_done = done
+        self._progress_total = total
+        self._refresh_progress_status()
+
+    def _output_folder_to_open(self) -> Path | None:
+        if self._run_output_directory is not None:
+            return self._run_output_directory
+        parents = {path.parent for path in self._saved_files}
+        if parents:
+            try:
+                return Path(os.path.commonpath(parents))
+            except ValueError:
+                return min(parents)
+        return self._run_input_directory
+
+    def _toggle_pause(self) -> None:
+        if self.worker is None or self._cancelling:
+            return
+        if self._run_state is RunState.RUNNING:
+            self._run_state = RunState.PAUSING
+            self._set_status("Pausing… finishing the current font", "warning")
+            self.pause_button.setEnabled(False)
+            self.worker.pause()
+        elif self._run_state is RunState.PAUSED:
+            self.worker.resume()
+
+    def _on_paused_changed(self, paused: bool) -> None:
+        if self.worker is None:
+            return
+        if paused:
+            if self._run_state is not RunState.PAUSING or self._cancelling:
+                return
+            self._run_state = RunState.PAUSED
+            self._finish_conversion_timer()
+            self._set_status(
+                f"Paused — {self._progress_done} / {self._progress_total}"
+                f" · {format_duration(self._session_elapsed)}",
+                "warning",
+            )
+            self._append_log(
+                LogEntry.create(
+                    "INFO",
+                    "conversion.paused",
+                    f"Paused at {self._progress_done} / {self._progress_total}",
+                    {"done": self._progress_done, "total": self._progress_total},
+                )
+            )
+        else:
+            if self._run_state is not RunState.PAUSED:
+                return
+            self._run_state = RunState.RUNNING
+            if not self._cancelling:
+                self._session_started_at = time.perf_counter() - self._session_elapsed
+                self._elapsed_timer.start()
+                self._append_log(
+                    LogEntry.create("INFO", "conversion.resumed", "Resumed conversion", {})
+                )
+                self._refresh_progress_status()
+        self._update_buttons()
+
+    def _cancel_conversion(self) -> None:
+        if self.worker is None:
+            return
+        answer = QMessageBox.question(
+            self.conversion_dialog,
+            "Cancel conversion",
+            "Cancel the conversion? The font being converted will be finished and the "
+            "files already saved will be kept.",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No,
+        )
+        if answer != QMessageBox.StandardButton.Yes or self.worker is None:
+            return
+        self._request_cancel()
+
+    def _request_cancel(self) -> None:
+        if self.worker is None:
+            return
+        self.cancel_button.setEnabled(False)
+        self._cancelling = True
+        self._set_status("Cancelling… finishing the current font", "warning")
+        self.worker.cancel()
+        self._update_buttons()
+
+    def _conversion_finished(self, result: ConversionResult) -> None:
+        self._finish_conversion_timer()
+        self._saved_files = result.saved_files
+        self._last_run_available = True
+        total_time = format_duration(self._session_elapsed)
+        if result.cancelled:
+            self._append_log(
+                LogEntry.create(
+                    "WARNING",
+                    "conversion.cancelled",
+                    self._batch_summary(result),
+                    {"elapsed_seconds": self._session_elapsed},
+                )
+            )
+            self._set_status(
+                f"Cancelled — {self._batch_summary(result)} · {total_time}.", "warning"
+            )
+            self._set_output_available(bool(result.saved_files))
+            return
+        if not result.ok:
+            failed_outcomes = [
+                outcome for outcome in result.outcomes if outcome.kind is FontOutcomeKind.FAILED
+            ]
+            failure_details = [
+                f"{outcome.input_path.name}: {outcome.error or 'Unknown error'}"
+                for outcome in failed_outcomes
+            ]
+            message = result.error or "; ".join(failure_details) or "Conversion failed."
+            error_types = sorted(
+                {
+                    error_type
+                    for error_text in ([result.error] if result.error else [])
+                    + [outcome.error for outcome in failed_outcomes if outcome.error]
+                    if (error_type := _exception_type(error_text)) is not None
+                }
+            )
+            self._append_log(
+                LogEntry.create(
+                    "ERROR",
+                    "conversion.failed",
+                    message,
+                    {
+                        "elapsed_seconds": self._session_elapsed,
+                        "converted": result.converted_count,
+                        "skipped": result.skipped_count,
+                        "failed": result.failed_count,
+                        "error_types": error_types,
+                        "failures": [
+                            {
+                                "input": outcome.input_path.name,
+                                "error_type": _exception_type(outcome.error or ""),
+                                "error": outcome.error,
+                            }
+                            for outcome in failed_outcomes
+                        ],
+                    },
+                )
+            )
+            if result.converted_count or result.failed_count:
+                message += f" ({self._batch_summary(result)} · {total_time})"
+            else:
+                message += f" ({total_time})"
+            self._show_error(message, log_event=None)
+            self._set_output_available(bool(result.saved_files))
+            return
+        self._append_log(
+            LogEntry.create(
+                "INFO",
+                "conversion.completed",
+                self._batch_summary(result),
+                {
+                    "elapsed_seconds": self._session_elapsed,
+                    "converted": result.converted_count,
+                    "skipped": result.skipped_count,
+                    "failed": result.failed_count,
+                },
+            )
+        )
+        self.progress.setValue(self.progress.maximum())
+        self._set_status(
+            f"Done — {self._batch_summary(result)} in {total_time}.",
+            "warning" if result.failed_count else "",
+        )
+        self._set_output_available(bool(result.saved_files))
+
+    @staticmethod
+    def _batch_summary(result: ConversionResult) -> str:
+        return (
+            f"{result.converted_count} converted, {result.skipped_count} skipped, "
+            f"{result.failed_count} failed"
+        )
+
+    def _show_error(
+        self,
+        message: str,
+        log_event: str | None = "application.error",
+        log_context: dict[str, object] | None = None,
+    ) -> None:
+        self._set_status(message, "error")
+        if log_event is not None:
+            self._append_log(
+                LogEntry.create("ERROR", log_event, message, log_context or {"message": message})
+            )
+        self.progress.setRange(0, 1)
+        self.progress.setValue(0)
+
+    def _conversion_failed(self, message: str) -> None:
+        self._finish_conversion_timer()
+        self._last_run_available = True
+        self._show_error(
+            f"Conversion failed: {message} ({format_duration(self._session_elapsed)})",
+            log_event="conversion.failed",
+            log_context={
+                "error": message,
+                "error_type": _exception_type(message),
+                "elapsed_seconds": self._session_elapsed,
+            },
+        )
+
+    def _worker_stopped(self) -> None:
+        self._finish_conversion_timer()
+        self.worker = None
+        self._run_state = RunState.IDLE
+        self._update_buttons()
+        if self._close_when_finished:
+            self.close()
+
+    def _open_output_folder(self) -> None:
+        output_directory = self._output_folder_to_open()
+        if output_directory is not None and not QDesktopServices.openUrl(
+            QUrl.fromLocalFile(str(output_directory))
+        ):
+            self._set_status("Could not open the output folder.", "error")
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        if self.worker is not None and self.worker.isRunning():
+            if self._run_state is RunState.PAUSED and not self._cancelling:
+                box = QMessageBox(self)
+                box.setWindowTitle("Conversion paused")
+                box.setText("The conversion is paused. What do you want to do?")
+                resume = box.addButton("Resume", QMessageBox.ButtonRole.AcceptRole)
+                cancel = box.addButton("Cancel conversion", QMessageBox.ButtonRole.DestructiveRole)
+                box.addButton("Keep window open", QMessageBox.ButtonRole.RejectRole)
+                box.exec()
+                clicked = box.clickedButton()
+                if clicked is cancel:
+                    self._close_when_finished = True
+                    self._request_cancel()
+                elif clicked is resume:
+                    self._toggle_pause()
+                event.ignore()
+                return
+            if self._cancelling:
+                self._close_when_finished = True
+                event.ignore()
+                return
+            answer = QMessageBox.question(
+                self,
+                "Conversion in progress",
+                "Wait for the current conversion to finish before closing?",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                QMessageBox.StandardButton.Yes,
+            )
+            if answer == QMessageBox.StandardButton.Yes:
+                self._close_when_finished = True
+                self._set_status("The window will close when conversion finishes.", "warning")
+            event.ignore()
+            return
+        self._stop_scan()
+        self.file_list.shutdown()
+        event.accept()