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

Article technique

Analyse des propriétés de police PDF avec PDFium VCL dans Delphi

· Programmation PDF

Comprendre les polices utilisées dans un document PDF est essentiel pour le contrôle qualité, la conformité aux normes d'accessibilité et l'analyse forensique des documents. Propriétés de la police La démonstration montre comment accéder aux informations détaillées sur les polices pour les caractères dans un PDF en utilisant PDFium VCL.

Aperçu

Cette démonstration vous permet de cliquer sur n'importe quel caractère dans un PDF et de visualiser ses propriétés de police, notamment le nom de la famille, le poids, le style, la taille et si la police est intégrée. C'est un outil précieux pour l'analyse et le dépannage des PDF.

Principales fonctionnalités

  • Sélection interactive – Cliquez sur n'importe quel caractère pour l'analyser.
  • Nom de la famille de polices – La famille de polices (par exemple, "Arial", "Times New Roman").
  • Nom de base de la police. – Nom interne de la police PDF.
  • Épaisseur de la police. – Valeur numérique de l'épaisseur (400 = normal, 700 = gras).
  • Taille de la police. – Taille en points.
  • Angle italique. – Angle d'inclinaison pour les polices italiques.
  • Ascent/Descent – Métriques verticales
  • Statut intégré – Indique si la police est intégrée dans le PDF
  • Données de la police – Accès aux données brutes de la police si elle est intégrée

Exigences des DLL PDFium

Avant d'exécuter toute application PDFium VCL, assurez-vous que les fichiers DLL PDFium sont installés :

  • pdfium32.dll / pdfium64.dll – Versions standard (environ 5-6 Mo)
  • pdfium32v8.dll / pdfium64v8.dll – Avec le moteur JavaScript V8 (environ 23-27 Mo)

Installation : Exécuter PDFiumVCL\DLLs\CopyDlls.bat en tant qu'administrateur pour copier automatiquement les DLL dans les répertoires système Windows.

Accès aux propriétés de la police

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;

Cliquez pour analyser le caractère

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;

Saisie manuelle de l'index des caractères.

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;

Propriétés de la police disponibles.

PDFium VCL expose ces propriétés relatives à la police.

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

Utilisation des propriétés de la police pour l'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;

Vérification de l'intégration des polices.

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;

Extraction des données de police intégrées.

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;

Comprendre les valeurs de graisse de la police.

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

Cas d'utilisation.

  • Contrôle qualité. – Vérifier que les polices correctes sont utilisées dans les documents.
  • Accessibilité – Vérifier que les polices respectent les exigences d'accessibilité
  • Analyse forensique – Analyser l'origine et les modifications des documents
  • Pré-vérification d'impression – Vérifier l'intégration des polices avant la production
  • Inventaire des polices – Cataloguer les polices utilisées dans les documents

Conclusion.

La démo des propriétés de la police de caractères montre comment PDFium VCL offre un accès approfondi aux informations sur les polices dans les documents PDF. Que vous vérifiiez l'intégration des polices pour la production d'impression ou que vous analysiez la typographie des documents, ces API vous fournissent les outils dont vous avez besoin.

La possibilité de cliquer sur n'importe quel caractère et de voir instantanément ses propriétés de police rend l'analyse des PDF intuitive et efficace.

Explorez les polices PDF en profondeur avec le composant PDFium Delphi VCL..