fix(render): Type1 font text rendering via system-font fallback (v1.47.10)

Symptom: PDFs with Type1 fonts (e.g. UniviaProRegular in Word/InDesign-
exported documents) rendered with all text invisible. Logos, vectors and
"-" bullets did appear, but glyph-encoded text was silently dropped.

Root cause:
- fonts.rs:287-308 extract_and_parse_font only checked /FontFile2
  (TrueType) and /FontFile3 (CFF). The /FontFile (Type1 binary) stream
  was ignored, leaving parsed=None.
- fonts.rs:367-388 try_system_font fell through if no system font matched
  the BaseFont name (subset prefixes like BAAAAA+UniviaProRegular rarely
  match).
- text_renderer.rs:46-49 early-returns when parsed=None, so no glyph fill
  commands were emitted by extract_draw_commands.

Fix: try_system_font now ends with a last-resort Arial family fallback
(arial / arialbd / ariali / arialbi based on bold/italic hints from the
font name). Character mapping stays correct because char_to_glyph_id
already routes through the font's ToUnicode CMap → Unicode → Arial cmap →
GID. Only the visual letter shape changes.

CIDFontType2 path (the v1.48.1 fix) is untouched.

Verified with new regression test (tests/test_type1_text.rs) on both PDFs:
- AC294 (Type1 + TrueType): 0 → 711 text fills emitted
- Vloerverwarming (CIDFontType2): 2199 fills, unchanged

Author: DutchSailor

open-pdf-render/src/fonts.rs

@@ -364,6 +364,11 @@ impl FontRegistry {
     /// Try to load a system font matching the PDF BaseFont name.
     /// Strips subset prefix (e.g., "ESYDQT+SegoeUI-Bold" → "SegoeUI-Bold")
     /// then maps to Windows font files.
+    ///
+    /// As a last resort (e.g. for Type1 fonts whose embedded /FontFile we
+    /// cannot parse, like UniviaPro), falls back to Arial so text is at
+    /// least visible — character mapping still works through the font's
+    /// ToUnicode CMap → Arial's Unicode cmap → glyph IDs.
     fn try_system_font(base_font: &str) -> Option<ParsedFont> {
         // Strip subset prefix: 6 uppercase letters + '+'
         let clean_name = if base_font.len() > 7 && base_font.as_bytes()[6] == b'+' {
@@ -373,18 +378,39 @@ impl FontRegistry {
         };
 
         // Try to find system font file
-        let font_path = Self::find_system_font(clean_name)?;
-        let font_data = std::fs::read(&font_path).ok()?;
-        match font_parser::parse_truetype(&font_data) {
-            Ok(parsed) => {
-                eprintln!("[fonts] Loaded system font: {} → {}", clean_name, font_path);
-                Some(parsed)
+        if let Some(font_path) = Self::find_system_font(clean_name) {
+            if let Ok(font_data) = std::fs::read(&font_path) {
+                match font_parser::parse_truetype(&font_data) {
+                    Ok(parsed) => {
+                        eprintln!("[fonts] Loaded system font: {} → {}", clean_name, font_path);
+                        return Some(parsed);
+                    }
+                    Err(e) => {
+                        eprintln!("[fonts] Failed to parse system font {}: {}", font_path, e);
+                    }
+                }
             }
-            Err(e) => {
-                eprintln!("[fonts] Failed to parse system font {}: {}", font_path, e);
-                None
+        }
+
+        // Last-resort generic fallback — pick a sane default based on the
+        // font name's hints (bold/italic) so substitutions look reasonable.
+        let lower = clean_name.to_lowercase();
+        let is_bold = lower.contains("bold") || lower.contains("black") || lower.contains("heavy");
+        let is_italic = lower.contains("italic") || lower.contains("oblique");
+        let fallback_file = match (is_bold, is_italic) {
+            (true, true) => "arialbi.ttf",
+            (true, false) => "arialbd.ttf",
+            (false, true) => "ariali.ttf",
+            (false, false) => "arial.ttf",
+        };
+        let path = format!(r"C:\Windows\Fonts\{}", fallback_file);
+        if let Ok(font_data) = std::fs::read(&path) {
+            if let Ok(parsed) = font_parser::parse_truetype(&font_data) {
+                eprintln!("[fonts] Generic fallback: {} → {}", clean_name, fallback_file);
+                return Some(parsed);
             }
         }
+        None
     }
 
     /// Find a system font file matching a PDF font name.

open-pdf-render/tests/test_type1_text.rs

@@ -0,0 +1,69 @@
+// Verifies Type1 fonts (e.g. UniviaPro) emit glyph outlines via system-font fallback.
+use open_pdf_render::PdfRenderer;
+use std::fs;
+
+fn run(path: &str) -> (usize, usize) {
+    let bytes = fs::read(path).expect("read pdf");
+    let r = PdfRenderer::new();
+    let doc = r.load_document(&bytes).expect("load");
+    let buf = doc.extract_draw_commands(0, 0).expect("extract");
+    let raw = buf.into_bytes();
+    let mut fills = 0usize;
+    let mut transforms = 0usize;
+    // Header: f32 x0, y0, w, h = 16 bytes
+    let mut i = 16usize;
+    while i < raw.len() {
+        let op = raw[i]; i += 1;
+        match op {
+            0 | 1 => i += 8,            // MoveTo / LineTo
+            2 => i += 24,                // CubicTo
+            3 => i += 16,                // Rect
+            4 => {}                      // ClosePath
+            5 => i += 8,                 // SetStroke (rgba+width)
+            6 => i += 4,                 // SetFill
+            7 => {}                      // Stroke
+            8 => fills += 1,             // Fill
+            9 => {}                      // FillEvenOdd
+            10 | 11 => {}                // Save/Restore
+            12 => { transforms += 1; i += 24; }
+            13 | 14 => i += 1,
+            15 => i += 4,
+            16 => {
+                if i >= raw.len() { break; }
+                let n = raw[i] as usize; i += 1;
+                i += n * 4 + 4;
+            }
+            17 => {}
+            18 => {
+                if i + 17 > raw.len() { break; }
+                i += 16;
+                let len = raw[i] as usize; i += 1;
+                i += len;
+            }
+            19 => {
+                // DrawImage: u16 w + u16 h + u32 dataLen + bytes
+                if i + 8 > raw.len() { break; }
+                i += 4;
+                let len = u32::from_le_bytes([raw[i],raw[i+1],raw[i+2],raw[i+3]]) as usize;
+                i += 4 + len;
+            }
+            20 | 21 => {}                 // Clip / ClipEvenOdd
+            _ => { eprintln!("unknown opcode {} at {}", op, i - 1); break; }
+        }
+    }
+    (fills, transforms)
+}
+
+#[test]
+fn ac294_emits_glyph_fills() {
+    let (fills, transforms) = run("../test pdf-bestanden/AC294_offerte_stalen_bak_Vincent_Christe.pdf");
+    eprintln!("AC294 page0: fills={} transforms={}", fills, transforms);
+    assert!(fills > 100, "AC294 should emit many glyph fills, got {}", fills);
+}
+
+#[test]
+fn vloerverwarming_still_renders() {
+    let (fills, transforms) = run("../test pdf-bestanden/Vloerverwarming Woning Bert van Dorp - opm BvD.pdf");
+    eprintln!("Vloerverwarming page0: fills={} transforms={}", fills, transforms);
+    assert!(fills > 50, "Vloerverwarming regression: only {} fills", fills);
+}

open-pdf-studio/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-pdf-studio",
-  "version": "1.47.9",
+  "version": "1.47.10",
   "description": "A free, open-source PDF annotation editor built with Tauri",
   "scripts": {
     "dev": "vite",

open-pdf-studio/src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "open-pdf-studio"
-version = "1.47.9"
+version = "1.47.10"
 description = "A free, open-source PDF annotation editor"
 authors = ["OpenAEC Foundation"]
 license = "MIT"

open-pdf-studio/src-tauri/Cargo.toml

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Open PDF Studio",
-  "version": "1.47.9",
+  "version": "1.47.10",
   "identifier": "org.openaec.openpdfstudio",
   "build": {
     "frontendDist": "../dist",