LlosLab Software Development BlogEngineering notes for PDF, Delphi, and document software developers.

Fachartikel

Analysieren von PDF-Schrifteigenschaften mit PDFium VCL in Delphi

· PDF-Programmierung

Das Verständnis der in einem PDF-Dokument verwendeten Schriftarten ist entscheidend für die Qualitätskontrolle, die Einhaltung von Barrierefreiheitsstandards und die Dokumentforensik. Schriftarteigenschaften Die Demo zeigt, wie detaillierte Schriftarteninformationen für Zeichen in einer PDF-Datei mithilfe von PDFium VCL abgerufen werden können.

Überblick

Mit dieser Demo können Sie auf ein beliebiges Zeichen in einer PDF-Datei klicken und dessen Schrifteigenschaften anzeigen, einschließlich Familienname, Stärke, Stil, Größe und ob die Schriftart eingebettet ist. Es ist von unschätzbarem Wert für die PDF-Analyse und Fehlerbehebung.

Hauptmerkmale

  • Interaktive Auswahl – Klicken Sie auf ein beliebiges Zeichen, um es zu analysieren.
  • Familienname der Schriftart – Die Schriftfamilie (z. B. „Arial“, „Times New Roman“).
  • Name der Schriftartbasis – Der interne PDF-Schriftartname.
  • Schriftstärke – Numerale Schriftstärke (400 = normal, 700 = fett).
  • Schriftgröße – Größe in Punkten.
  • Kursiver Winkel – Neigungswinkel für kursive Schriftarten.
  • Aufstieg/Abstieg – Vertikale Metriken
  • Eingebetteter Status – Ob die Schriftart in der PDF-Datei eingebettet ist
  • Schriftartdaten – Zugriff auf die Rohdaten der Schriftart, falls eingebettet

PDFium-DLL-Anforderungen

Stellen Sie vor dem Ausführen einer PDFium VCL-Anwendung sicher, dass die PDFium DLL-Dateien installiert sind:

  • pdfium32.dll / pdfium64.dll – Standardversionen (~5-6 MB).
  • pdfium32v8.dll / pdfium64v8.dll – Mit V8 JavaScript-Engine (~23-27 MB).

Installation: Ausführen PDFiumVCL\DLLs\CopyDlls.bat als Administrator, um die DLLs automatisch in die Windows-Systemverzeichnisse zu kopieren.

Zugreifen auf Schriftarteigenschaften

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
procedure TfrmMain.UpdateFontInfo;
var
  FontInfo: TStringList;
begin
  FontInfo := TStringList.Create;
  try
    FontInfo.Add('=== Font Properties for Character Index: ' +
      IntToStr(PdfView.CurrentCharIndex) + ' ===');
    FontInfo.Add('');
    
    // Font family name
    try
      FontInfo.Add('Font Family Name: ' + PdfView.FontFamilyName);
    except
      FontInfo.Add('Font Family Name: \u003cError retrieving\u003e');
    end;
    
    // Font base name (internal PDF name)
    try
      FontInfo.Add('Font Base Name: ' + PdfView.FontBaseName);
    except
      FontInfo.Add('Font Base Name: \u003cError retrieving\u003e');
    end;
    
    // Font size for this character
    try
      FontInfo.Add('Font Size: ' +
        FloatToStr(PdfView.FontSize[PdfView.CurrentCharIndex]));
    except
      FontInfo.Add('Font Size: \u003cError retrieving\u003e');
    end;
    
    // Font weight (400=normal, 700=bold)
    try
      FontInfo.Add('Font Weight: ' + IntToStr(PdfView.FontWeight));
    except
      FontInfo.Add('Font Weight: \u003cError retrieving\u003e');
    end;
    
    // Italic angle (0 for upright, negative for italic)
    try
      FontInfo.Add('Font Italic Angle: ' + IntToStr(PdfView.FontItalicAngle));
    except
      FontInfo.Add('Font Italic Angle: \u003cError retrieving\u003e');
    end;
    
    // Vertical metrics
    try
      FontInfo.Add('Font Ascent: ' + FloatToStr(PdfView.FontAscent));
    except
      FontInfo.Add('Font Ascent: \u003cError retrieving\u003e');
    end;
    
    try
      FontInfo.Add('Font Descent: ' + FloatToStr(PdfView.FontDescent));
    except
      FontInfo.Add('Font Descent: \u003cError retrieving\u003e');
    end;
    
    // Embedded status
    try
      FontInfo.Add('Font Is Embedded: ' +
        BoolToStr(PdfView.FontIsEmbedded, True));
    except
      FontInfo.Add('Font Is Embedded: \u003cError retrieving\u003e');
    end;
    
    // Font data size (if embedded)
    try
      FontInfo.Add('Font Data Size: ' +
        IntToStr(Length(PdfView.FontData)) + ' bytes');
    except
      FontInfo.Add('Font Data Size: \u003cError retrieving\u003e');
    end;
    
    FontInfo.Add('');
    FontInfo.Add('Character: ' +
      PdfView.Character[PdfView.CurrentCharIndex]);
    
    memoFontInfo.Lines.Assign(FontInfo);
    
  finally
    FontInfo.Free;
  end;
end;

Klicken Sie hier, um den Charakter zu analysieren

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
procedure TfrmMain.PdfViewMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
var
  CharIndex: Integer;
begin
  if not PdfView.Active then
    Exit;
    
  try
    // Get character at click position
    CharIndex := PdfView.CharacterIndexAtPos(X, Y, 10.0, 10.0);
    
    if CharIndex >= 0 then
    begin
      edtCharIndex.Text := IntToStr(CharIndex);
      PdfView.CurrentCharIndex := CharIndex;
      UpdateFontInfo;
    end;
    
  except
    on E: Exception do
    begin
      memoFontInfo.Lines.Clear;
      memoFontInfo.Lines.Add('Error getting character: ' + E.Message);
    end;
  end;
end;

Manuelle Eingabe des Zeichenindex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
procedure TfrmMain.btnGetFontInfoClick(Sender: TObject);
var
  CharIndex: Integer;
begin
  if not PdfView.Active then
  begin
    ShowMessage('Please open a PDF file first.');
    Exit;
  end;
  
  try
    CharIndex := StrToInt(edtCharIndex.Text);
    PdfView.CurrentCharIndex := CharIndex;
    UpdateFontInfo;
  except
    on E: Exception do
      ShowMessage('Invalid character index: ' + E.Message);
  end;
end;

Schriftarteigenschaften verfügbar

PDFium VCL stellt diese schriftartbezogenen Eigenschaften bereit:

1
2
3
4
5
6
7
8
9
10
11
12
13
// Font properties accessible via TPdf and TPdfView
property FontFamilyName: WString;  // e.g., "Arial", "Times New Roman"
property FontBaseName: WString;    // Internal PDF font name
property FontWeight: Integer;      // 100-900, 400=normal, 700=bold
property FontItalicAngle: Integer; // Degrees, 0=upright, negative=italic
property FontAscent: Single;       // Height above baseline
property FontDescent: Single;      // Depth below baseline (negative)
property FontIsEmbedded: Boolean;  // True if font is embedded
property FontData: TBytes;         // Raw font data if embedded
property FontHandle: FPDF_FONT;    // PDFium font handle
 
// Per-character property
property FontSize[Index: Integer]: Double;  // Font size for character

Verwendung von Schrifteigenschaften zur Analyse

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
procedure AnalyzeDocumentFonts(Pdf: TPdf);
var
  FontList: TStringList;
  I: Integer;
  FontName: string;
  LastFontName: string;
begin
  FontList := TStringList.Create;
  FontList.Sorted := True;
  FontList.Duplicates := dupIgnore;
  
  try
    Pdf.PageNumber := 1;
    LastFontName := '';
    
    for I := 0 to Pdf.CharacterCount - 1 do
    begin
      // Access font for each character
      // (In practice, use CurrentCharIndex pattern)
      
      // Check FontFamilyName changes
      // Add unique fonts to list
    end;
    
    ShowMessage('Document uses ' + IntToStr(FontList.Count) + ' fonts');
    
  finally
    FontList.Free;
  end;
end;

Überprüfen der Schriftarteinbettung

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
procedure CheckFontEmbedding(Pdf: TPdf);
var
  EmbeddedFonts, NonEmbeddedFonts: TStringList;
begin
  EmbeddedFonts := TStringList.Create;
  NonEmbeddedFonts := TStringList.Create;
  
  try
    EmbeddedFonts.Sorted := True;
    EmbeddedFonts.Duplicates := dupIgnore;
    NonEmbeddedFonts.Sorted := True;
    NonEmbeddedFonts.Duplicates := dupIgnore;
    
    // Analyze fonts...
    
    if NonEmbeddedFonts.Count > 0 then
    begin
      ShowMessage('Warning: ' + IntToStr(NonEmbeddedFonts.Count) +
        ' fonts are not embedded. Document may not display correctly ' +
        'on systems without these fonts installed.');
    end
    else
    begin
      ShowMessage('All fonts are embedded. Document will display ' +
        'consistently on all systems.');
    end;
    
  finally
    EmbeddedFonts.Free;
    NonEmbeddedFonts.Free;
  end;
end;

Extrahieren eingebetteter Schriftartdaten

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
procedure ExtractEmbeddedFont(Pdf: TPdf; const OutputFile: string);
var
  FontData: TBytes;
  FileStream: TFileStream;
begin
  if Pdf.FontIsEmbedded then
  begin
    FontData := Pdf.FontData;
    
    if Length(FontData) > 0 then
    begin
      FileStream := TFileStream.Create(OutputFile, fmCreate);
      try
        FileStream.WriteBuffer(FontData[0], Length(FontData));
        ShowMessage('Font extracted: ' + IntToStr(Length(FontData)) + ' bytes');
      finally
        FileStream.Free;
      end;
    end;
  end
  else
    ShowMessage('Font is not embedded in the document.');
end;

Grundlegendes zu den Werten der Schriftstärke

Weight Value Common Name
100 Thin
200 Extra Light
300 Light
400 Normal/Regular
500 Medium
600 Semi Bold
700 Bold
800 Extra Bold
900 Black

Anwendungsfälle

  • Qualitätskontrolle – Überprüfung, ob die korrekten Schriftarten in Dokumenten verwendet werden
  • Zugänglichkeit – Überprüfung, ob die Schriftarten die Anforderungen an die Barrierefreiheit erfüllen
  • Forensische Analyse – Analyse der Dokumentherkunft und -änderungen
  • Preflight drucken – Überprüfung der Schriftart-Einbettung vor der Produktion
  • Schriftarten-Inventar – Katalogisierung der in Dokumenten verwendeten Schriftarten

Abschluss

Die Demo zu den Schriftarteigenschaften zeigt, wie PDFium VCL umfassenden Zugriff auf Schriftartinformationen in PDF-Dokumenten bietet. Egal, ob Sie die Einbettung von Schriftarten für die Druckproduktion überprüfen oder die Typografie von Dokumenten analysieren, diese APIs stellen Ihnen die Tools zur Verfügung, die Sie benötigen.

Die Möglichkeit, auf ein beliebiges Zeichen zu klicken und sofort dessen Schrifteigenschaften anzuzeigen, macht die PDF-Analyse intuitiv und effizient.

Entdecken Sie PDF-Schriftarten detailliert mit. PDFium Delphi VCL-Komponente.