NotYAFC 1.0.0__py3-none-any.whl

font_converter/gui/profile_options.py

@@ -0,0 +1,316 @@
+"""Profile-specific controls and typed option construction for the converter."""
+
+from dataclasses import replace
+from pathlib import Path
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QSpinBox,
+    QVBoxLayout,
+)
+
+from font_converter.gui.widgets import (
+    UPM_STEP_VALUES,
+    DecimalSpinBox,
+    StepperField,
+    UpmSpinBox,
+)
+from font_converter.service import (
+    ConversionOptions,
+    ConversionSettings,
+    InstanceSpec,
+    OtfToTtfOptions,
+    SfntToWebOptions,
+    TtcToSfntOptions,
+    TtfToOtfOptions,
+    VarToStaticOptions,
+    WebFormat,
+    Woff2ToSfntOptions,
+    WoffToSfntOptions,
+)
+
+
+class ProfileOptionsPanel(QGroupBox):
+    """Own controls that change with a selected conversion profile."""
+
+    compatibilityChanged = Signal()
+    validityChanged = Signal()
+
+    def __init__(self) -> None:
+        super().__init__("Conversion options")
+        self.setObjectName("card")
+        self._outline_profile = False
+        self._variable_profile = False
+        self._web_profile = False
+        self._instance_outlines: set[str] = set()
+        options = QVBoxLayout(self)
+        options.setContentsMargins(16, 12, 16, 14)
+        options.setSpacing(9)
+
+        self.instances_hint = QLabel(
+            "Check the instances to export for each font. Select a font or an instance "
+            "and use “Add custom instance” to add one for that font."
+        )
+        self.instances_hint.setObjectName("stepHint")
+        self.instances_hint.setWordWrap(True)
+
+        self.tolerance_label = QLabel("Tolerance (0.0–3.0)")
+        self.tolerance = DecimalSpinBox()
+        self.tolerance.setRange(0, 3)
+        self.tolerance.setSingleStep(0.1)
+        self.tolerance.setValue(1.0)
+        self.tolerance.setDecimals(2)
+        self.tolerance_field = StepperField(self.tolerance, tab_buttons=True)
+        self.tolerance_field.setFixedWidth(170)
+        tolerance_tooltip = (
+            "Higher values allow larger curve deviations and usually produce fewer points; "
+            "lower values preserve more detail. "
+            "Tolerance is in thousandths of an em; actual deviation scales with UPM."
+        )
+        self.tolerance_label.setToolTip(tolerance_tooltip)
+        self.tolerance.setToolTip(tolerance_tooltip)
+        self.tolerance_field.setToolTip(tolerance_tooltip)
+        self.use_target_upm = QCheckBox("Set target UPM")
+        upm_tooltip = "UPM (units per em) is the font's design-grid size. Scale converted fonts to this value."
+        self.use_target_upm.setToolTip(upm_tooltip)
+        self.target_upm = UpmSpinBox()
+        self.target_upm_field = StepperField(self.target_upm, tab_buttons=True)
+        self.target_upm_field.setFixedWidth(170)
+        self.target_upm_field.setEnabled(False)
+        self.target_upm.setToolTip(upm_tooltip)
+        self.target_upm_field.setToolTip(upm_tooltip)
+        self.use_target_upm.toggled.connect(self.target_upm_field.setEnabled)
+
+        self.subroutinize = QCheckBox("Subroutinize")
+        self.subroutinize.setChecked(True)
+        self.subroutinize.setToolTip(
+            "Compress CFF outlines using shared subroutines (PostScript outlines only)."
+        )
+        self.optimize_contours_label = QLabel("Simplify contours (0–3)")
+        self.optimize_contours_label.setWordWrap(True)
+        self.optimize_contours = QSpinBox()
+        self.optimize_contours.setRange(0, 3)
+        self.optimize_contours.setSpecialValueText("Off")
+        self.optimize_contours.setToolTip(
+            "Merge adjacent smooth curve segments to reduce the number of points (experimental). "
+            "Higher values allow larger deviations; 0 disables simplification."
+        )
+        self.optimize_contours_field = StepperField(self.optimize_contours, tab_buttons=True)
+        self.optimize_contours_field.setFixedWidth(170)
+        self.optimize_contours_label.setToolTip(self.optimize_contours.toolTip())
+        self.optimize_contours_field.setToolTip(self.optimize_contours.toolTip())
+        self.autohint = QCheckBox("Autohint")
+        self.autohint.setChecked(True)
+        self.autohint.setToolTip(
+            "Add TrueType hinting instructions with ttfautohint (TrueType outlines only)."
+        )
+
+        spin_grid = QGridLayout()
+        spin_grid.setHorizontalSpacing(12)
+        spin_grid.setVerticalSpacing(12)
+        spin_grid.addWidget(self.tolerance_label, 0, 0)
+        spin_grid.addWidget(self.tolerance_field, 0, 1)
+        spin_grid.addWidget(self.optimize_contours_label, 1, 0)
+        spin_grid.addWidget(self.optimize_contours_field, 1, 1)
+        spin_grid.addWidget(self.use_target_upm, 2, 0)
+        spin_grid.addWidget(self.target_upm_field, 2, 1)
+        spin_grid.setColumnStretch(2, 1)
+        options.addLayout(spin_grid)
+
+        self.upm_warning_label = QLabel("Non-standard UPM. Common values: 1000, 1024, 2048.")
+        self.upm_warning_label.setObjectName("warningHint")
+        self.upm_warning_label.setWordWrap(True)
+        options.addWidget(self.upm_warning_label)
+        self.use_target_upm.toggled.connect(self._update_upm_warning)
+        self.target_upm.valueChanged.connect(self._update_upm_warning)
+        options.addWidget(self.subroutinize)
+        options.addWidget(self.autohint)
+
+        self.format_label = QLabel("Output format:")
+        self.format_woff = QCheckBox("WOFF")
+        self.format_woff.setChecked(True)
+        self.format_woff2 = QCheckBox("WOFF2")
+        self.format_woff2.setChecked(True)
+        for checkbox in (self.format_woff, self.format_woff2):
+            checkbox.toggled.connect(self.compatibilityChanged)
+            checkbox.toggled.connect(self.validityChanged)
+        self.obfuscate_names = QCheckBox("Obfuscate names")
+        self.obfuscate_names.setToolTip(
+            "Replace the family, full and PostScript names with hashes, also in the file name."
+        )
+        self.remove_unused_glyphs = QCheckBox("Remove unused glyphs")
+        self.remove_unused_glyphs.setToolTip(
+            "Drop the glyphs not reachable from the character map or the OpenType features."
+        )
+        self.remove_non_windows_names = QCheckBox("Remove non-Windows names")
+        self.remove_non_windows_names.setToolTip(
+            "Remove the name records whose platform ID is not 3 (e.g. Macintosh records)."
+        )
+        self.remove_dsig = QCheckBox("Remove DSIG table")
+        self.remove_dsig.setToolTip(
+            "Remove the digital signature table from WOFF fonts. WOFF2 does not support it."
+        )
+        self.format_woff.toggled.connect(self._update_dsig_visibility)
+        self.css_kit = QCheckBox("Create CSS")
+        self.css_kit.setToolTip(
+            "Write a fonts.css file with @font-face rules and a class for each OpenType feature."
+        )
+        formats = QHBoxLayout()
+        formats.setSpacing(16)
+        formats.addWidget(self.format_label)
+        formats.addWidget(self.format_woff)
+        formats.addWidget(self.format_woff2)
+        formats.addStretch()
+        options.addLayout(formats)
+        options.addWidget(self.obfuscate_names)
+        options.addWidget(self.remove_unused_glyphs)
+        options.addWidget(self.remove_non_windows_names)
+        options.addWidget(self.remove_dsig)
+        options.addWidget(self.css_kit)
+        options.addWidget(self.instances_hint)
+
+        self.no_profile_options_label = QLabel("No additional options for this profile.")
+        self.no_profile_options_label.setObjectName("hint")
+        self.no_profile_options_label.setWordWrap(True)
+        options.addWidget(self.no_profile_options_label)
+        self.set_conversion("ttf2otf")
+
+    def set_conversion(self, conversion: str | None) -> None:
+        outline = conversion in ("ttf2otf", "otf2ttf")
+        postscript = conversion == "ttf2otf"
+        webfont = conversion == "ft2wf"
+        self._web_profile = webfont
+        variable = conversion == "var2static"
+        self._outline_profile = outline
+        self.instances_hint.setVisible(variable)
+
+        # Qu2"uPen (TTF → OTF) rejects a tolerance of zero.
+        self.tolerance.setMinimum(0.1 if postscript else 0.0)
+        self.tolerance_label.setText("Tolerance (0.1–3.0)" if postscript else "Tolerance (0.0–3.0)")
+        self.tolerance_label.setVisible(outline)
+        self.tolerance_field.setVisible(outline)
+        self.use_target_upm.setVisible(outline or variable)
+        self.target_upm_field.setVisible(outline or variable)
+        self._variable_profile = variable
+        self._update_outline_options(conversion)
+        self.format_label.setVisible(webfont)
+        self.format_woff.setVisible(webfont)
+        self.format_woff2.setVisible(webfont)
+        self.obfuscate_names.setVisible(webfont)
+        self.remove_unused_glyphs.setVisible(webfont)
+        self.remove_non_windows_names.setVisible(webfont)
+        self.css_kit.setVisible(webfont)
+        self._update_dsig_visibility()
+        self.no_profile_options_label.setText(
+            "Choose a conversion to see its options."
+            if conversion is None
+            else "No additional options for this profile."
+        )
+        self.no_profile_options_label.setVisible(not (outline or webfont or variable))
+        self._update_upm_warning()
+
+    def _update_dsig_visibility(self, *_: object) -> None:
+        self.remove_dsig.setVisible(self._web_profile and self.format_woff.isChecked())
+
+    def set_instance_outlines(self, outlines: set[str]) -> None:
+        """Show only the options that apply to the outlines of the selected variable fonts."""
+        if outlines != self._instance_outlines:
+            self._instance_outlines = outlines
+            if self._variable_profile:
+                self._update_outline_options("var2static")
+
+    def _update_outline_options(self, conversion: str | None) -> None:
+        self.optimize_contours_label.setVisible(conversion == "ttf2otf")
+        self.optimize_contours_field.setVisible(conversion == "ttf2otf")
+        if conversion == "var2static":
+            outlines = self._instance_outlines or {"TrueType", "PostScript"}
+            self.subroutinize.setVisible("PostScript" in outlines)
+            self.autohint.setVisible("TrueType" in outlines)
+            self.subroutinize.setText("Subroutinize (PostScript only)")
+            self.autohint.setText("Autohint (TrueType only)")
+        else:
+            self.subroutinize.setVisible(conversion == "ttf2otf")
+            self.autohint.setVisible(conversion == "otf2ttf")
+            self.subroutinize.setText("Subroutinize")
+            self.autohint.setText("Autohint")
+
+    def selected_web_format(self) -> WebFormat | None:
+        woff, woff2 = self.format_woff.isChecked(), self.format_woff2.isChecked()
+        if woff and not woff2:
+            return "woff"
+        if woff2 and not woff:
+            return "woff2"
+        return None
+
+    def web_format_valid(self) -> bool:
+        return self.format_woff.isChecked() or self.format_woff2.isChecked()
+
+    def settings_for(
+        self,
+        conversion: str,
+        common: ConversionOptions,
+        instances: tuple[tuple[Path, tuple[InstanceSpec, ...]], ...] = (),
+    ) -> ConversionSettings:
+        if conversion == "ttf2otf":
+            settings: ConversionSettings = TtfToOtfOptions(
+                tolerance=self.tolerance.value(),
+                target_upm=self.target_upm.value() if self.use_target_upm.isChecked() else None,
+                subroutinize=self.subroutinize.isChecked(),
+                optimize_contours=self.optimize_contours.value(),
+            )
+        elif conversion == "otf2ttf":
+            settings = OtfToTtfOptions(
+                tolerance=self.tolerance.value(),
+                target_upm=self.target_upm.value() if self.use_target_upm.isChecked() else None,
+                autohint=self.autohint.isChecked(),
+            )
+        elif conversion == "ft2wf":
+            settings = SfntToWebOptions(
+                format=self.selected_web_format(),
+                obfuscate_names=self.obfuscate_names.isChecked(),
+                remove_unused_glyphs=self.remove_unused_glyphs.isChecked(),
+                remove_non_windows_names=self.remove_non_windows_names.isChecked(),
+                css_kit=self.css_kit.isChecked(),
+                remove_dsig=self.remove_dsig.isChecked() and self.format_woff.isChecked(),
+            )
+        elif conversion == "woff2ft":
+            settings = WoffToSfntOptions()
+        elif conversion == "woff22ft":
+            settings = Woff2ToSfntOptions()
+        elif conversion == "ttc2sfnt":
+            settings = TtcToSfntOptions()
+        elif conversion == "var2static":
+            settings = VarToStaticOptions(
+                instances=instances,
+                target_upm=self.target_upm.value() if self.use_target_upm.isChecked() else None,
+                autohint=self.autohint.isChecked(),
+                subroutinize=self.subroutinize.isChecked(),
+            )
+        else:
+            raise ValueError(f"Unsupported conversion profile: {conversion}")
+
+        return replace(
+            settings,
+            recursive=common.recursive,
+            output_dir=common.output_dir,
+            overwrite=common.overwrite,
+            recalc_bboxes=common.recalc_bboxes,
+            recalc_timestamp=common.recalc_timestamp,
+            reorder_tables=common.reorder_tables,
+            organize_output=common.organize_output,
+            organize_by_family=common.organize_by_family,
+            organization_levels=common.organization_levels,
+        )
+
+    def _update_upm_warning(self, *_: object) -> None:
+        non_standard = (
+            self.use_target_upm.isChecked() and self.target_upm.value() not in UPM_STEP_VALUES
+        )
+        self.upm_warning_label.setVisible(
+            (self._outline_profile or self._variable_profile) and non_standard
+        )

font_converter/gui/profiles.py

@@ -0,0 +1,17 @@
+"""Presentation labels for the converter's supported conversion profiles."""
+
+CONVERSIONS: dict[str, str] = {
+    "ttf2otf": "TrueType → PostScript (TTF → OTF)",
+    "otf2ttf": "PostScript → TrueType (OTF → TTF)",
+    "ft2wf": "SFNT → WOFF / WOFF2",
+    "woff2ft": "WOFF → SFNT",
+    "woff22ft": "WOFF2 → SFNT",
+    "ttc2sfnt": "TrueType Collection → SFNT",
+    "var2static": "Variable → Static (instances)",
+}
+
+CONVERSION_GROUP_HEADINGS: dict[str, str] = {
+    "ttf2otf": "Outlines",
+    "ft2wf": "Web fonts",
+    "ttc2sfnt": "Other",
+}

font_converter/gui/scanner.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+
+from PySide6.QtCore import QThread, Signal
+
+from font_converter.inspection import inspect_font
+
+
+class ScanWorker(QThread):
+    """Lists the candidate files of the sources and reads their font metadata."""
+
+    # (done, total); total is 0 while the files are still being listed.
+    progress = Signal(int, int)
+    font_found = Signal(object, object)
+
+    def __init__(self, sources: list[Path], recursive: bool) -> None:
+        super().__init__()
+        self.sources = sources
+        self.recursive = recursive
+
+    def run(self) -> None:
+        self.progress.emit(0, 0)
+        files: dict[Path, None] = {}
+        for source in self.sources:
+            if source.is_file():
+                files[source] = None
+            elif source.is_dir():
+                candidates = source.rglob("*") if self.recursive else source.glob("*")
+                for path in candidates:
+                    if self.isInterruptionRequested():
+                        return
+                    if path.is_file():
+                        files[path] = None
+        total = len(files)
+        self.progress.emit(0, total)
+        for done, path in enumerate(files, start=1):
+            if self.isInterruptionRequested():
+                return
+            info = inspect_font(path)
+            if info is not None:
+                self.font_found.emit(path, info)
+            if done % 20 == 0 or done == total:
+                self.progress.emit(done, total)