About
The fcl-pdf package contains a PDF generating unit fppdf that does not depend on any external libraries.
The PDF generator has the following features:
- Support for basic shapes.
- Support for basic line styles.
- Dictionary support.
- Multi-page PDF.
- Image support.
- TTF Font support.
- Font embedding.
- Unicode font support.
- Stream Compression.
- Image embedding.
- Several paper types.
- Portrait/Landscape.
- Support for multiple units.
- Rotation matrix system.
- PDF creator information.
- Output validates by several PDF validators.
Contains units:
- fppdf
- fpparsettf
- fpttf
- fpttfencodings
Examples
Official test project
Take a look at the "fcl-pdf/examples/testfppdf.lpr" project included with FPC's source code. It was purposely designed to help explain how to use the fcl-pdf package. Each page of that demo is defined in a separate method to help remove clutter, and explain the usage and functionality in smaller chucks of code.
Writing few lines, without embedded fonts
Example by forum member Moritz, fixed by member paweld. Code disables embedding of fonts into PDF.
procedure TMainForm.TestButtonClick(Sender: TObject);
var
FontID, FontBoldID: Integer;
Document: TPDFDocument;
Section: TPDFSection;
Page: TPDFPage;
begin
Document := TPDFDocument.Create(nil);
Document.FontDirectory := 'C:\Windows\Fonts';
Document.Options := Document.Options + [poPageOriginAtTop, poNoEmbeddedFonts];
Document.StartDocument;
FontID := Document.AddFont('arial.ttf', 'Arial');
FontBoldID := Document.AddFont('arialbd.ttf', 'Arial Bold');
Section := Document.Sections.AddSection;
Page := Document.Pages.AddPage;
Section.AddPage(Page);
Page.SetFont(FontID, 11);
Page.WriteText(20, 20, 'This is normal text');
Page.SetFont(FontBoldID, 11);
Page.WriteText(20, 30, 'This is bold text');
Document.SaveToFile('output.pdf');
end;
Enumerate available fonts
Example by forum member paweld.
uses
fppdf, fpttf;
procedure TForm1.FormCreate(Sender: TObject);
var
g: TFPFontCacheList;
i: Integer;
begin
g := TFPFontCacheList.Create;
g.SearchPath.Add('C:\Windows\Fonts');
g.BuildFontCache;
for i := 0 to g.Count - 1 do
Memo1.Lines.Add(Format('File name: %s > Font name: %s > Family: %s',
[g.Items[i].FileName, g.Items[i].HumanFriendlyName, g.Items[i].FamilyName]));
g.Free;
end;
Render picture to PDF
Example by forum member CynicRus changed by AlexTP. Note: on Ubuntu 20.04, default PDF viewer cannot show the picture correctly, it crops some top part of the picture.
uses
fppdf;
procedure WritePictureToPDF(const APictureFilename, APdfFilename: string);
var
PDF: TPDFDocument;
Page: TPDFPage;
Section: TPDFSection;
Paper: TPDFPaper;
Index: Integer;
W, H: Integer;
begin
PDF := TPDFDocument.Create(nil);
try
PDF.StartDocument;
Section := PDF.Sections.AddSection;
Page := PDF.Pages.AddPage;
Page.Orientation := ppoLandscape;
Page.UnitOfMeasure := uomPixels;
Section.AddPage(Page);
Index := PDF.Images.AddFromFile(APictureFilename);
W := PDF.Images[Index].Width;
H := PDF.Images[Index].Height;
paper.W := W;
paper.H := H;
Page.Paper := Paper;
Page.PaperType := ptCustom;
Page.DrawImageRawSize(0, 0, W, H, Index);
PDF.SaveToFile(APdfFilename);
finally
PDF.Free;
end;
end;
PDFs and Fonts
A draft, a work in progress so criticize, hack away, as you see fit ! dbannon.
A practical system to produce PDFs will have to cope with text and text means fonts. While the PDF engine is in the fppdf unit, including fpttf will give you access to the gTTFontCache, a tool that loads data about the fonts you will be using. The Cache will tell you the name and path to the actual font file and will give you dimensions of the specific text you are putting into a PDF, essential information as you adjust line spacing and width.
The PDF and Font Cache has had substantial developments, especially for Windows, after the release of of FPC3.2.2 so, probably a good idea to consider FPC-fixes as of mid 2024. But even then, there are some limitations, chief being that it cannot handle the newer font file format, 'collections' typically with an extension of .ttc (True Type Collection) or .otc (Open Type Collection). The cache, when scanning for font files, will ignore .ttc (and, perhaps .otc) but if you offer the PDF engine a .ttc file you will, later, cause an exception. Better to take the Cache's advice, skip .ttc.
Options, there is an option, poSubsetFont, who's purpose is unclear to this author that causes the DPF engine to crash when used with .otf fonts. And, interesting, with some Chinese .ttf fonts. Some pundits suggest that there are OpenTypeFonts packaged with .otc extensions, maybe, maybe not. In either case, leave that particular option out, does no apparent good, definite harm.
gTTFontCache
As mentioned above, gTTFontCache is brought into your application by including the fpttf unit. It does not need to be created (or freed) but does need a touch of setup and some initialization. Because its global, this only needs be done once for the app's run time, even if called repeatably (as long as the availability of fonts does not change during the run). Your code may look like this -
const HaveReadFonts : boolean = false;
...
...
if not HaveReadFonts then begin
{$if defined(CPU32) and defined(LINUX)}
gTTFontCache.SearchPath.Add('/usr/share/fonts/'); // Avoids a problem noted on 32bit linux where
gTTFontCache.BuildFontCache; // libfontconfig returns a nil pointer to font.cfg file
{$else}
{$ifdef WINDOWS}
gTTFontCache.SearchPath.Add('./'); // CHECK DAVO Also look for fonts where binary lives on Windows
{$endif}
gTTFontCache.ReadStandardFonts;
{$endif}
HaveReadFonts := True;
end;
The Font Cache looks for fonts in the appropriate places for each operating system but you can add to that list with the gTTFontCache.SearchPath.add() line. On Linux for example, it also looks in $HOME/.fonts, a great place for a user to add their own, perhaps short term fonts.
Its possible (but a bit slow) to iterate over the Cache's internal list once populated by the ReadStandardFonts;, see above. What is really useful is how you can find what you need by declaring a pointer to a Cache Item and using the Cache's Find() command -
var
CachedFont : TFPFontCacheItem;
DescenderH : single;
...
...
CachedFont := gTTFontCache.Find('Noto Sans CJK SC', Bold, Italic); // Bold and Italic are booleans
if Assigned(CachedFont) then begin
writeln('Width of ABC in a PDF at 12pt is ', CachedFont.TextWidth('ABC', 12));
writeln('Height of above is ', CachedFont.TextHeight('ABC', 12, DescenderH)
end else writeln('Sorry, don''t seem to have that font.');
That is key information if you are "flowing" text into a PDF, it tells you both the vertical and horizontal information in millimeters of each "word", you keep running totals to to tell you when to start a new line and how much further down the page to put it. You will have to deal with some offset issues if changing font sizes you its not difficult.