Exemple de composant Delphi HotPDF Hello World

Bonjour le monde avec le composant HotPDF pour Delphi.

Bienvenue dans ce guide complet pour le composant HotPDF pour Delphi. Programme de démonstration HelloWorld !

À propos du composant HotPDF.

Le composant HotPDF est une bibliothèque de traitement PDF puissante et polyvalente, conçue spécifiquement pour les développeurs Delphi et C++Builder. Ce composant complet offre une API étendue qui permet aux développeurs de créer, de manipuler et de modifier des documents PDF facilement et avec précision.

Principales fonctionnalités du composant HotPDF :

Création et génération de PDF : Créez des documents PDF à partir de zéro, avec un contrôle total sur la mise en page, le formatage et le contenu.
Prise en charge du texte et des graphiques : Ajoutez du texte, des images, des formes et des graphiques complexes aux pages PDF.
Prise en charge multilingue: Prise en charge complète de Unicode pour l'affichage de texte international.
Gestion des polices : Intégrez les polices pour une apparence de document cohérente sur différents systèmes.
Options de compression : Utilisez des algorithmes de compression pour optimiser la taille des fichiers.
Fonctionnalités de sécurité : Cryptage des documents, protection par mot de passe et contrôles d'accès.
Manipulation des documents : Fusion, division et modification des documents PDF existants.
Prise en charge des tableaux et des formulaires : Création de tableaux complexes et de formulaires interactifs.

HotPDF Component Delphi Hello World Sample

Aperçu du programme HelloWorld.dpr

La HelloWorld.dpr Le programme d'exemple est une excellente introduction au composant HotPDF.
fonctionnalité la plus basique et importante : la fonction TexOut. Ce programme de démonstration présente également les fonctionnalités de base de création de PDF.

Fonctionnalités principales :

1. Création de documents PDF

La fonction principale du programme est de générer des documents PDF contenant du texte multilingue "Hello World". CreatePDF La procédure démontre :

Initialisation des composants : Configuration et paramétrage corrects du composant THotPDF.
Propriétés du document : Définition des métadonnées telles que les options de compression et l'intégration des polices.
Rendu de texte multilingue : Affichage de texte dans 11 langues différentes, notamment l'anglais, l'espagnol, l'allemand, le français, l'italien, le portugais, le russe, le japonais, le turc, le chinois et le coréen.
Gestion des polices : Utilisation de la police Arial Unicode MS pour la prise en charge de l'affichage multilingue.
Compression : Création d'un document PDF compressé.

2. Gestion des fenêtres et intégration au système.

Le programme inclut une fonctionnalité sophistiquée d'énumération de fenêtres qui démontre :

Énumération des fenêtres du système : Utilisation de l'API Windows EnumWindows pour itérer sur toutes les fenêtres de niveau supérieur.
Correspondance des titres de fenêtres : Implémentation de la correspondance de sous-chaînes pour identifier les applications cibles.
Fermeture automatique des fenêtres : Envoi. WM_CLOSE messages pour fermer les lecteurs PDF qui pourraient avoir des fichiers ouverts.
Prévention des conflits : Assurer qu'aucun conflit d'accès aux fichiers ne se produit lors de la création de nouveaux fichiers PDF.

3. Gestion des erreurs et des ressources.

Le programme illustre les meilleures pratiques pour :

Gestion de la mémoire : Création et suppression correctes des instances de composants.
Sécurité en cas d'exception : Utilisation de blocs try-finally pour garantir la libération des ressources.
Commentaires des utilisateurs : Fournir une sortie console pour informer les utilisateurs de l'avancement du programme.

Détails de l'implémentation technique :

Technologie de compression.

Le programme crée un document PDF avec la compression FlateDecode.

Stratégie de gestion des polices.

Le programme utilise une stratégie de sélection de polices sophistiquée :

Arial Unicode MS: Utilisé pour la plupart des langues en raison de sa large prise en charge des caractères.
Intégration des polices : Assure une apparence cohérente sur différents systèmes.

Compatibilité inter-versions.

Le code inclut des directives de compilation conditionnelle pour prendre en charge les versions modernes et anciennes de Delphi.

Prise en charge de XE2 et versions ultérieures. Utilise des unités avec espaces de noms (WinApi.Windows, System.SysUtils, etc.).
Prise en charge des versions antérieures. Recourt automatiquement les noms d'unités traditionnels pour les anciennes versions de Delphi.

Valeur éducative.

Cet exemple "HelloWorld" a plusieurs objectifs pédagogiques :

Introduction aux composants : Fournit une introduction simple à l'utilisation des composants HotPDF.
Bonnes pratiques : Illustre une gestion appropriée des ressources et la gestion des erreurs.
Intégration système : Montre comment intégrer la génération de PDF aux opérations du système Windows.
Internationalisation : Illustre la gestion de texte multilingue dans les documents PDF.

Démarrage.

Pour exécuter ce programme d'exemple :

Assurez-vous que le composant HotPDF est correctement installé dans votre IDE Delphi.
Ouvrez le fichier de projet HelloWorld.dpr.
Compilez et exécutez le programme.
Le programme créera automatiquement un fichier PDF avec compression.
Examinez les fichiers générés pour voir le rendu du texte multilingue.

Code source.

Voici le code source complet et bien documenté du programme de démonstration HelloWorld :

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

{************************************************************}

// HotPDF PDF Component

{************************************************************}

// HelloWorld Demo Program for HotPDF Component

// This program demonstrates basic PDF creation capabilities

// including multilingual text support and compression options

{************************************************************}

program HelloWorld;

{$APPTYPE CONSOLE} // Console application type

{$I ..\..\..\Lib\HotPDF.inc} // Include HotPDF configuration file

uses

// EurekaLog units for memory leak detection and debugging (optional)

{$IFDEF EurekaLog}

EMemLeaks, // Memory leak detection

EResLeaks, // Resource leak detection

EDebugJCL, // JCL debugging support

EDebugExports, // Export debugging information

EFixSafeCallException, // SafeCall exception handling

EMapWin32, // Win32 mapping support

EAppConsole, // Console application support

EDialogConsole, // Console dialog support

ExceptionLog7, // Exception logging

{$ENDIF EurekaLog}

// System units - different namespaces for XE2+ vs older versions

{$IFDEF XE2+}

WinApi.Windows, // Windows API functions

WinApi.Messages, // Windows message constants

System.SysUtils, // System utilities

System.Classes, // Base classes (TStringList, etc.)

Vcl.Graphics, // Graphics support

{$ELSE}

Windows, // Windows API functions (older Delphi)

Messages, // Windows message constants (older Delphi)

SysUtils, // System utilities (older Delphi)

Classes, // Base classes (older Delphi)

Graphics, // Graphics support (older Delphi)

{$ENDIF}

HPDFDoc; // HotPDF main component unit

// Creates a compressed PDF file with multilingual "Hello World" text

// Parameters:

// FileName: Output PDF file name

procedure CreatePDF(const FileName: string);

var

HotPDF: THotPDF; // Main HotPDF component instance

begin

// Create HotPDF component instance

HotPDF := THotPDF.Create(nil);

try

// Configure PDF properties

HotPDF.AutoLaunch := true; // Automatically open PDF after creation

HotPDF.FileName := FileName; // Set output file name

// Enable FlateDecode compression

HotPDF.Compression := cmFlateDecode; // Enable FlateDecode compression

WriteLn('Creating compressed PDF: ', FileName);

HotPDF.FontEmbedding := true; // Embed fonts for better compatibility

HotPDF.BeginDoc; // Start PDF document creation

// Set Unicode font for multilingual text support

// Arial Unicode MS supports most languages except Korean

// procedure SetFont ( FontName: AnsiString; FontStyle: TFontStyles; ASize: Single; FontCharset: TFontCharset = DEFAULT_CHARSET; IsVertical: boolean = false);

// DEFAULT_CHARSET: 1 - Font is chosen based on Name. If the described font is not available on the system, Windows will substitute another font

HotPDF.CurrentPage.SetFont('Arial Unicode MS', [], 12, 1, False);

// Display "Hello World" in multiple languages

// TextOut parameters: (X, Y, Angle, Text)

HotPDF.CurrentPage.TextOut(80, 50, 0, 'Hello, Delphi PDF world!'); // English

HotPDF.CurrentPage.TextOut(80, 70, 0, 'Hola, mundo Delphi PDF!'); // Spanish

HotPDF.CurrentPage.TextOut(80, 90, 0, 'Hallo, Delphi PDF Welt!'); // German

HotPDF.CurrentPage.TextOut(80, 110, 0, 'Bonjour, monde PDF Delphi!'); // French

HotPDF.CurrentPage.TextOut(80, 130, 0, 'Ciao, mondo Delphi PDF!'); // Italian

HotPDF.CurrentPage.TextOut(80, 150, 0, 'Olá, mundo Delphi PDF!'); // Portuguese

HotPDF.CurrentPage.TextOut(80, 170, 0, 'Здравствуйте, Delphi PDF мир!'); // Russian

HotPDF.CurrentPage.TextOut(80, 190, 0, 'こんにちは、Delphi PDFの世界！'); // Japanese

HotPDF.CurrentPage.TextOut(80, 210, 0, 'Merhaba, Delphi PDF dünyası!'); // Turkish

HotPDF.CurrentPage.TextOut(80, 230, 0, '你好，Delphi PDF世界'); // Chinese

HotPDF.CurrentPage.TextOut(80, 250, 0, '여보세요, Delphi PDF 세계!'); // Korean

HotPDF.EndDoc; // Finalize and save the PDF document

WriteLn('PDF created successfully: ', FileName);

finally HotPDF.Free; // Clean up HotPDF component

end;

// Global variables for window enumeration and PDF creation

var

Title: String; // Individual title string (unused in current implementation)

Titles: TStrings; // List of window titles to search for

Window: HWND; // Window handle (unused in current implementation)

WindowText: array [0 .. 255] of Char; // Buffer for window text (unused in current implementation)

WindowTitle: String; // Window title string (unused in current implementation)

I: Integer; // Loop counter (unused in current implementation)

// Callback function for EnumWindows API

// This function is called for each top-level window in the system

// Parameters:

// hWnd: Handle to the current window being enumerated

// lParam: User-defined data (in our case, pointer to TStrings with target titles)

// Returns: True to continue enumeration, False to stop

function EnumWindowsProc(HWND: HWND; lParam: lParam): BOOL; stdcall;

var

Titles: TStrings; // List of target window titles

I: Integer; // Loop counter

WindowText: array [0 .. 255] of Char; // Buffer to store window text

WindowTitle: String; // Current window's title as string

begin

Result := true; // Continue enumeration by default

Titles := TStrings(lParam); // Cast lParam back to TStrings

// Get the window title text

if GetWindowText(HWND, WindowText, SizeOf(WindowText)) > 0 then

begin

WindowTitle := String(WindowText); // Convert char array to string

// Check if window title contains any of our target strings

for I := 0 to Titles.Count - 1 do

begin

// Use Pos function to check if target string is contained in window title

if Pos(Titles[I], WindowTitle) > 0 then

begin

// Send WM_CLOSE message to close the window

PostMessage(HWND, WM_CLOSE, 0, 0);

Break; // Exit loop after finding first match

end;

// Main program execution begins here

begin

// Close any existing PDF files that might be open in PDF viewers

// This prevents file access conflicts when creating new PDFs with same names

Titles := TStringList.Create;

try

// Define list of window title substrings to search for

// Any window containing these strings will be closed

// This will close Adobe and Foxit PDF reader & editor and many other PDF apps

Titles.CommaText := '"HelloWorld.pdf", "Foxit"';

// Enumerate all top-level windows and close matching ones

// EnumWindows calls our callback function for each window

EnumWindows(@EnumWindowsProc, lParam(Titles));

finally Titles.Free; // Clean up string list

end;

// Display program header

WriteLn('=== HotPDF HelloWorld Demo ===');

WriteLn('This demo creates a compressed PDF file with multilingual text.');

WriteLn('');

// Create compressed PDF

CreatePDF('HelloWorld.pdf');

// Display completion message

WriteLn('');

WriteLn('PDF file created successfully!');

WriteLn('The PDF file uses FlateDecode compression for optimal file size.');

WriteLn('');

WriteLn('Press Enter to exit...');

ReadLn; // Wait for user input before closing console

end.