DynaPDF Manual

https://www.monkeybreadsoftware.com/DynaPDF-Manual
Admin
The DynaPDF Manual provides comprehensive API reference and usage details for the DynaPDF library,...
Tokens:780,123
Snippets:1,973
Trust Score:7.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Usage of OpenOutputFile() with DynaPDF

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_298

This C code snippet demonstrates the usage of the OpenOutputFile() function within the DynaPDF library. It initializes a PDF instance, sets document information, creates a new PDF, appends content, and sets the font for text rendering. This example focuses on the setup before potentially using OpenOutputFile.

```C
PPDF* pdf = pdfNewPDF();
if (!pdf) return 2; // Out of memory?
// No need to check return values.
pdfSetOnErrorProc(pdf, NULL, PDFError);
pdfSetDocInfo(pdf, diSubject, "Usage of OpenOutputFile()...");
pdfCreateNewPDF(pdf, NULL);
pdfAppend(pdf);
pdfSetFont(pdf, "Arial", fsItalic, 40.0, true, cp1252);
```

--------------------------------

### DynaPDF Font Selection Examples

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_155

Provides examples of font selection in DynaPDF, demonstrating correct usage with font names and styles, and highlighting incorrect formats.

```DynaPDF Syntax
"Arial,Bold"
```

```DynaPDF Syntax
"Arial, Bold"
```

```DynaPDF Syntax
"Courier New,BoldItalic"
```

--------------------------------

### Correct PDF String Formatting Example

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/Optimize

This example demonstrates the correct way to format a PDF string, ensuring that values for keys like /Placement are treated as name objects. It highlights the importance of correct brace usage and data types for PDF keys.

```PDF
/A<</BBox[50 450 200 500]/Placement/Inline/O/Layout>>
```

--------------------------------

### C++ DynaPDF Multi-Column Text Example

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_856

This C++ code demonstrates how to create a PDF with multi-column text using DynaPDF. It includes setting up an error callback, reading text from a file, configuring column layout, and writing the text to the PDF.

```C++
SI32 PDF_CALL PDFError(const void* Data, SI32 ErrCode, const char* ErrMessage, SI32 ErrType)
{
printf("%s\n", ErrMessage); return 0;
}

int main(int argc, char* argv[])
{
// The structure TOutRect holds all required variables to calculate
// the output rectangle.
TOutRect r;
// The text is stored in a text file
FILE* f = fopen("c:/sample.txt", "rb");
if (f == NULL) return 2;
char* fText;
UI32 bufSize;
fseek(f, 0, SEEK_END);
bufSize = ftell(f);
fseek(f, 0, SEEK_SET);
// allocate one more character for the null-terminator
fText = (char*)malloc(bufSize +1);
fread(fText, 1, bufSize, f);
fclose(f);
fText[bufSize] = 0;
// Do NOT forget to add a null-terminator!!!
r.iPDF = pdfNewPDF(); // Get a new PDF instance
if (!r.iPDF)
// Out of memory?
{
free(fText);
return 2;
}
pdfSetOnErrorProc(r.iPDF, NULL, PDFError);
pdfSetDocInfo(r.iPDF, diCreator, "C++ test app");
pdfSetDocInfo(r.iPDF, diSubject, "Multi-column text");
pdfSetDocInfo(r.iPDF, diTitle, " Multi-column text ");
// We use top-down coordinates
pdfSetPageCoords(r.iPDF, pcTopDown);
pdfCreateNewPDF(r.iPDF, "c:/cppout.pdf");
pdfAppend(r.iPDF);
pdfSetFont(r.iPDF, "Arial", fsNone, 8.0, true, cp1252);
r.ColCount = 3;
r.Column
= 0;
r.Distance = 5.0;
r.PosX
= 50.0;
r.PosY
= 50.0;
r.Height
= 150.0;
r.Width
= (pdfGetPageWidth(r.iPDF) - 100.0 - (r.ColCount -1) * r.Distance) / r.ColCount;
// The structure is passed to the callback function now
pdfSetOnPageBreakProc(r.iPDF, &r, OnPageBreakProc);
// Set the output rectangle first
pdfSetTextRect(r.iPDF, r.PosX, r.PosY, r.Width, r.Height);
pdfWriteFText(r.iPDF, taLeft, fText); // Now we can print the text
free(fText);
// free the text buffer
pdfEndPage(r.iPDF);
// Close the last page
pdfCloseFile(r.iPDF); // Close the file
pdfDeletePDF(r.iPDF); // Delete the PDF instance
}
```

--------------------------------

### C# PDF Error Handling and Header/Footer Configuration

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_157

This example demonstrates setting up a custom error procedure for DynaPDF and configuring header and footer elements for a PDF. It includes setting import flags, adding Bates numbering, page numbering, and date formatting.

```C#
static int PDFError(IntPtr Data, int ErrCode, IntPtr ErrMessage, int ErrType)
{
MessageBox.Show( string.Format("{0}",
System.Runtime.InteropServices.Marshal.PtrToStringAnsi(ErrMessage)));
return 0; // We try to continue if an error occurrs. Any other return value breaks processing.
}
private void button1_Click(object sender, EventArgs e)
{
CPDF pdf = new CPDF();
pdf.SetOnErrorProc(IntPtr.Zero, new TErrorProc(PDFError));
pdf.CreateNewPDF("e:/cppout.pdf");
// Do not convert pages to templates.
pdf.SetImportFlags(TImportFlags.ifImportAll | TImportFlags.ifImportAsPage);
// This flag reduces the memory usage drastically
pdf.SetImportFlags2(TImportFlags2.if2UseProxy);
pdf.OpenImportFile("c:/PDFs/testfile.pdf", TPwdType.ptOpen, null);
pdf.ImportPDFFile(1, 1.0, 1.0);
// Three header / footer strings should be output in this example
TPDFHdrFtr[]
hdr
= new TPDFHdrFtr[3];
TPDFHeaderFooter init = new TPDFHeaderFooter();
// Initialize the structures with default values
pdf.InitHeaderFooter(ref init, ref hdr);
init.InitColor
= 0;
init.InitCodepage
= TCodepage.cpUnicode;
init.InitEmbed
= true;
init.InitFont
= "Arial";
init.InitFontSize
= 8.0f;
init.Margin.Left
= 50.0f;
init.Margin.Right
= 50.0f;
init.Margin.Top
= 30.0f;
init.Margin.Bottom = 20.0f;
hdr[0].IsHeader
= true;
hdr[0].Text
= "This is a bates number: <<Bates#8#1>>";
hdr[0].Position
= TTextAlign.taCenter;
hdr[1].Color
= 255;
hdr[1].CS
= TExtColorSpace.esDeviceRGB;
hdr[1].Codepage
= TCodepage.cpUnicode;
hdr[1].Font
= "Arial,Italic";
hdr[1].FontSize
= 8.0f;
hdr[1].Embed
= true;
hdr[1].IsHeader
= true;
hdr[1].Text
= "Page numbering: <<Page 1 of n>>";
hdr[1].Position
= TTextAlign.taRight;
hdr[2].IsHeader
= false;
hdr[2].Text
= "Multiple formats: <<yyyy/mm/dd>> <<Bates#8#1>> <<Page 1 of n>>";
hdr[2].Position
= TTextAlign.taLeft;
pdf.AddHeaderFooter(ref init, ref hdr);
pdf.CloseFile();
}
```

--------------------------------

### DynaPDF Initialization and Setup (C)

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_103

This C code snippet shows the initialization of a DynaPDF document, setting an error handling procedure, creating a new PDF file named 'test.pdf', and configuring the page coordinate system and color space.

```C
void* pdf = pdfNewPDF();
if (!pdf) return -1; // Out of memory
pdfSetOnErrorProc(pdf, NULL, PDFError);
pdfCreateNewPDF(pdf, "test.pdf");
pdfSetPageCoords(pdf, pcTopDown);
pdfSetColorSpace(pdf, csDeviceRGB);
TPDFExtGState gs, def;
pdfInitExtGState(&gs);
pdfInitExtGState(&def);
```

--------------------------------

### DynaPDF Bates Numbering Syntax

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_155

Demonstrates the correct syntax for Bates numbering in DynaPDF, specifying the number of digits and the starting number. Includes examples of valid and invalid formats.

```DynaPDF Syntax
<<Bates#0..10#1..2147483648>>
```

```DynaPDF Syntax
<<Bates#6#1>>
```

```DynaPDF Syntax
<<Bates#10#5>>
```

```DynaPDF Syntax
<< Bates#6#1>>
```

```DynaPDF Syntax
<<bates#6#1>>
```

--------------------------------

### Setting DynaPDF Update Flags

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_670

Demonstrates how to set update flags for the TPDFRasterImage structure in DynaPDF. The example shows combining the structure size with SKIP_INIT_SCREEN and SKIP_UPDATE_SCREEN flags to control initial screen setup and final screen updates during rendering.

```C++
TPDFRasterImage img;
img.StructSize = sizeof(img) | SKIP_INIT_SCREEN | SKIP_UPDATE_SCREEN;
```

--------------------------------

### CreateLaunchActionEx Function Syntax

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/CreateLaunchActionEx

Provides the C-style syntax for the CreateLaunchActionEx function, used to create a launch action for opening files or applications. It outlines the parameters required for its operation.

```C
SI32 pdfCreateLaunchActionEx(
const PPDF* IPDF,
// Instance pointer
const char* FileName, // Should be a relative path
LBOOL NewWindow)
// Meaningful for PDF files only
```

--------------------------------

### CreateRectilinearMeasure in C++

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_308

This C++ example demonstrates how to use the CreateRectilinearMeasure function to set up measurements for distance and area tools within a PDF document. It includes setting up the PDF, creating a rectangle, getting its bounding box, creating a viewport, and finally calling CreateRectilinearMeasure with conversion factors and unit labels.

```C++
PPDF* pdf = pdfNewPDF();
if (!pdf) return -1; // Out of memory?
pdfCreateNewPDF(pdf, "e:/cppout.pdf");
// We use top down coordinates in this example
pdfSetPageCoords(pdf, pcTopDown);
pdfAppend(pdf);
// Just a test object of a known size that can be measured...
pdfSetLineWidth(pdf, 0.5);
pdfRectangle(pdf, 50.0, 50.0, 144, 72.0, fmStroke);
TPDFRect bbox;
pdfGetBBox(pdf, pbMediaBox, bbox);
SI32 vp = pdfCreateViewport(
pdf,
// Instance pointer
NULL,
// Optional viewport name
bbox.Left,
// Lowever left corner
bbox.Bottom,
// Lowever left corner
bbox.Right,
// Upper right corner
bbox.Top);
// Upper right corner
pdfCreateRectilinearMeasure(
pdf,
// Instance pointer
vp,
// Viewport handle
25.4/72.0,
// Conversion factor from 1/72 inch to mm
"inch to mm",
// Description of the measure dictionary
"mm",
// Unit label for the distance tool
"mm²");
// Unit label for the area tool
pdfEndPage(pdf);
pdfCloseFile(pdf);
pdfDeletePDF(pdf);
```

--------------------------------

### Create and Apply Standard Hatch Patterns in C++

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_321

This C++ code snippet demonstrates how to create and apply standard hatch patterns using the DynaPDF library. It includes creating patterns with different styles, colors, and densities, applying them to rectangles for filling and stroking, and setting line widths. The example also shows basic DynaPDF initialization and cleanup.

```C++
int main(int argc, char* argv[])
{
SI32 pat1, pat2, pat3;
PPDF* pdf = pdfNewPDF();
if (!pdf) return 2; // Out of memory?
pdfSetOnErrorProc(pdf, NULL, PDFError);
pdfSetDocInfo(pdf, diSubject, "Standard hatch patterns");
pdfSetDocInfo(pdf, diCreator, "C example test project");
pdfSetDocInfo(pdf, diTitle, "Standard hatch patterns");
pdfSetPageCoords(pdf, pcTopDown);
pdfCreateNewPDF(pdf, "c:/cppout.pdf");
pdfAppend(pdf);
pat1 = pdfCreateStdPattern(pdf, spCross,2,8,PDF_RED,NO_COLOR);
pat2 = pdfCreateStdPattern(pdf, spDiaCross,1,4,PDF_BLUE,PDF_YELLOW);
pat3 = pdfCreateStdPattern(pdf, spDiaCross,1,4,PDF_BLUE,NO_COLOR);
pdfApplyPattern(pdf, pat1, cmFill, 0);
pdfApplyPattern(pdf, pat2, cmStroke, 0);
pdfSetLineWidth(pdf, 10.0);
pdfRectangle(pdf, 50, 50, 50, 50, fmFillStroke);
pdfApplyPattern(pdf, pat3, cmStroke, 0);
pdfRectangle(pdf, 120, 50, 50, 50, fmFillStroke);
pdfEndPage(pdf);
pdfCloseFile(pdf);
pdfDeletePDF(pdf); // Do not forget to delete the PDF instance
}
```

--------------------------------

### Get Field Index - C

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/GetFieldHighlightMode

Returns the page index or tab order of a PDF field. Newly created fields start with an index of 1000, facilitating tab order adjustments. The field index can be modified using SetFieldIndex, and fields must be sorted by index per page using SortFieldsByIndex.

```C
SI32 pdfGetFieldIndex(
const PPDF* IPDF, // Instance pointer
UI32 AField) // Field handle
```

--------------------------------

### Create Launch Action with DynaPDF

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/CreateJSAction

Launches an application or opens/prints a document using the ShellExecute API. It takes parameters for the file name, default directory, optional parameters, and whether to open in a new window. Supports opening or printing files.

```C
SI32 pdfCreateLaunchAction(
const PPDF* IPDF,
// Instance pointer
TFileOP OP,
// Kind of operation (open or print the file)
const char* FileName, // File name (required)
const char* DefDir,
// Default directory (can be NULL)
const char* Param,
// Optional parameters (can be NULL)
LBOOL NewWindow)
// Open the file in a new window?
```

--------------------------------

### Get Object Actions

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/index

Retrieves actions associated with specific objects within a PDF, with functions for getting the count and the actions themselves.

```DynaPDF
GetObjActions
GetObjActionCount (obsolete)
```

--------------------------------

### Initialize DynaPDF and Create PDF in C

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_087

The main function in C for initializing DynaPDF and creating a new PDF document. It demonstrates the basic steps to start a PDF generation process, including error checking for PDF creation.

```C
int main(int argc, char* argv[])
{
void* pdf = pdfNewPDF();
if (!pdf) return 2;
  
```

--------------------------------

### Initialize TPDFRasterImage Structure

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/Basics

Demonstrates the minimal initialization for the TPDFRasterImage structure in C. It shows how to set the structure size and initialize the transformation matrix to an identity matrix, which is crucial for correct rendering.

```C
TPDFRasterImage img;
memset(&img, 0, sizeof(img));
img.StructSize = sizeof(img);
img.Matrix.a
= 1.0; // Identity matrix
img.Matrix.d
= 1.0; // Identity matrix (1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
```

--------------------------------

### Get Named Destinations

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/index

Retrieves named destinations within a PDF document, which are specific locations that can be linked to. Includes functions for getting the count and the destinations themselves.

```DynaPDF
GetNamedDest
GetNamedDestCount
GetInNamedDest (obsolete)
GetInNamedDestCount (obsolete)
```

--------------------------------

### Create Text Fields and Manage Tab Order in C++

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_743

This C++ example demonstrates how to create 50 text fields in two columns within a PDF document using the DynaPDF library. It shows how to set field indices to control the tab order, either line by line or column by column, by commenting out the SortFieldsByIndex() function call. The code includes an error callback function and basic PDF creation setup.

```C++
#include "dynapdf.h"
using namespace DynaPDF;
// First we declare our error callback function
SI32 PDF_CALL PDFError(const void* Data, SI32 ErrCode, const char*
ErrMessage, SI32 ErrType)
{
printf("%s\n", ErrMessage);
return 0;
}
int main(int argc, char* argv[])
{
char tmp[30]; double y; SI32 field, index;
PPDF* pdf = pdfNewPDF(); // Create a PDF instance
if (!pdf) return 2;
// Out of memory?
pdfSetOnErrorProc(pdf, NULL, PDFError);
pdfSetDocInfo(pdf, diCreator, "C++ sample project");
pdfSetDocInfo(pdf, diSubject, "Tab order");
pdfSetDocInfo(pdf, diCreator, "Tab order");
pdfCreateNewPDF(pdf, "c:/cppout.pdf");
pdfSetPageCoords(pdf, pcTopDown);
pdfAppend(pdf);
y = 50.0; index = 0;
for (SI32 i = 0; i < 50; i++)
{
sprintf(tmp, "Field %d", i);
if (i & 1)
{
// This is the second column, the field indices can be left
// unchanged because they are above 1000.
pdfCreateTextField(pdf, tmp, -1, false, 0, 210, y, 150, 20);
y += 25.0; // goto the next line
}
else
{
field = pdfCreateTextField(pdf, tmp, -1, false,0,50,y,150,20);
  

```

--------------------------------

### DynaPDF Initialization and PDF Creation

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_088

Initializes DynaPDF, sets error handling, document information, viewer preferences, and creates a new PDF file. It then sets page coordinates and appends the page.

```C
pdfSetOnErrorProc(pdf, NULL, PDFError);
pdfSetDocInfo(pdf, diAuthor, "Jens Boschulte");
pdfSetDocInfo(pdf, diCreator, "C sample project");
pdfSetDocInfo(pdf, diSubject, "How to use clipping paths");
pdfSetDocInfo(pdf, diTitle, "Clipping paths");
pdfSetViewerPreferences(pdf, vpDisplayDocTitle, avNone);
pdfCreateNewPDF(pdf, "c:/cppout.pdf");
pdfSetPageCoords(pdf, pcTopDown);
pdfAppend(pdf);
```

--------------------------------

### Create PDF with C# using DynaPDF

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_043

This C# code snippet demonstrates the basic usage of the DynaPDF library to create a PDF file. It includes setting up an error callback, creating a new PDF document, adding a page, setting a font, writing text, and saving the output file. The code also handles potential exceptions during the process.

```C#
using System;
using System.Runtime.InteropServices;

namespace DynaPDFExample
{
    public class CPDF
    {
        // Placeholder for DynaPDF methods and types
        public enum TPageCoord { pcTopDown }
        public enum TFStyle { fsItalic }
        public enum TCodepage { cp1252 }

        public delegate int TErrorProc(IntPtr ErrMessage, int ErrType);

        public void SetOnErrorProc(IntPtr zero, TErrorProc errorProc) { }
        public void CreateNewPDF(object p0) { }
        public void SetPageCoords(TPageCoord pcTopDown) { }
        public void Append() { }
        public void SetFont(string name, TFStyle style, int size, bool bold, TCodepage codepage) { }
        public void WriteText(double x, double y, string text) { }
        public void EndPage() { }
        public bool HaveOpenDoc() { return true; }
        public bool OpenOutputFile(string outFile) { return true; }
        public bool CloseFile() { return true; }
    }

    public class Program
    {
        // The error type is a bitmask.
        static int PDFError(IntPtr ErrMessage, int ErrType)
        {
            Console.Write("{0}\n", PtrToStringAnsi(ErrMessage));
            Console.Write("\n");
            return 0; // We try to continue if an error occurs.
        }

        // Placeholder for PtrToStringAnsi
        static string PtrToStringAnsi(IntPtr ptr) { return "Error Message"; }

        [STAThread]
        static void Main(string[] args)
        {
            try
            {
                String outFile = "c:/c#out.pdf";
                CPDF pdf = new CPDF();
                // Error messages are passed to the callback function.
                pdf.SetOnErrorProc(IntPtr.Zero, new DynaPDF.TErrorProc(PDFError));
                // We open the output file later if no error occurs.
                pdf.CreateNewPDF(null);
                // We use top down coordinates in this example
                pdf.SetPageCoords(DynaPDF.TPageCoord.pcTopDown);
                // Add an empty page to the file
                pdf.Append();
                // Before printing text you must set a font
                pdf.SetFont("Arial", DynaPDF.TFStyle.fsItalic, 20, true, DynaPDF.TCodepage.cp1252);
                pdf.WriteText(50.0, 50.0, "My first PDF output...");
                pdf.WriteText(50.0, 80.0, "File created: " + DateTime.Now.ToString());
                pdf.EndPage(); // Close the open page
                // No fatal error occurred?
                if (pdf.HaveOpenDoc())
                {
                    // OK, now we can open the output file.
                    if (!pdf.OpenOutputFile(outFile))
                    {
                        // An error message was already passed to the error callback function
                        Console.Read();
                        return;
                    }
                    if (pdf.CloseFile())
                    {
                        Console.Write("PDF file \"{0}\" successfully created!\n", outFile);
                    }
                }
                pdf = null;
            }catch(Exception e)
            {
                Console.Write(e.Message);
            }
            Console.Read();
        }
    }
}
```

--------------------------------

### Get Layer Configuration

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/index

Manages and retrieves information about Optional Content Groups (OCGs) or layers within a PDF. This includes getting configuration, count, and usage details.

```DynaPDF
GetLayerConfig
GetLayerConfigCount
InitOCGContUsage
GetOCGContUsage
GetOCGUsageUserName
```

--------------------------------

### DynaPDF Main Function Example (C++)

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_219

This C++ main function demonstrates how to initialize and use the DynaPDF library for PDF processing, specifically calling the PDFToPDFA function. It includes setting up error handlers, license keys, and CMap directories, and then processes a PDF file for conversion.

```C++
int main(int argc, char* argv[])
{
// Process as many files as possible with one instance
void* pdf = pdfNewPDF();
if (!pdf) return -3; // Out of memory?
pdfSetOnErrorProc(pdf, NULL, PDFError);
pdfSetLicenseKey(pdf, "...");
// Not required but strongly recommended. External CMaps should be available when converting
// imported PDF files. The files are only loaded if necessary.
// Use an absolute path if possible! Otherwise the CMaps cannot be loaded if the working
// directory was changed.
pdfSetCMapDir("c:/MyAppPath/Resource/CMap/", TLoadCMapFlags(lcmDelayed | lcmRecursive));
SI32 retval = PDFToPDFA(pdf, "c:/test.pdf", "c:/cppout.pdf");
pdfDeletePDF(pdf);
return retval;
}
```

--------------------------------

### Get JavaScript Actions

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/index

Retrieves JavaScript actions embedded within a PDF document. Includes functions for getting actions, their count, and specific names, with some functions marked as obsolete.

```DynaPDF
GetJavaScriptAction (obsolete)
GetJavaScriptAction2 (obsolete)
GetJavaScriptActionEx
GetJavaScriptCount
GetJavaScriptEx
GetJavaScriptName
```

--------------------------------

### Delphi DynaPDF Initialization and Pattern Creation

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_174

Demonstrates initializing a DynaPDF object in Delphi, setting an error callback, document information, and viewer preferences. It then proceeds to create a new PDF file and append a page, followed by the creation of a colored tiling pattern.

```Delphi
procedure TForm1.Button1Click(Sender: TObject);
var pdf: TPDF; pat: Integer; cw, h: Single;
begin
pdf := nil;
try
pdf := TPDF.Create;
// Set the error callback first. No need to check return values.
pdf.SetOnErrorProc(nil, @ErrProc);
pdf.SetDocInfoA(diAuthor, 'Jens Boschulte');
pdf.SetDocInfoA(diCreator, 'Delphi sample project');
pdf.SetDocInfoA(diSubject, 'How to use patterns');
pdf.SetDocInfoA(diTitle, 'Vector graphics');
pdf.SetViewerPreferences(vpDisplayDocTitle, avNone);
pdf.CreateNewPDFA('c:\dout.pdf');
pdf.Append;
// create a colored tiling pattern
pat := pdf.BeginPattern(ptColored, ttFastConstSpacing, 20, 20);
pdf.SetFontA('ZapfDingbats', fsNone, 12, false, cp1252);
h := pdf.GetAscent;
cw := pdf. GetTextWidthA(#171);
pdf.SetFillColor(clRed);
pdf.WriteTextA(0, 0, #171);
```

--------------------------------

### Get Metadata Preview (C++)

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/GetMissingGlyphs

Demonstrates how to get a preview of the global XMP stream using the pdfGetMetadata function. It checks if metadata is available and processes the data if the buffer size is greater than zero.

```C++
BYTE* buffer = NULL;
UI32 bufSize = 0;

// Get a preview of the global XMP stream
if (pdfGetMetadata(pdf, mdoCatalog, -1, &buffer, &bufSize))
{
  if (bufSize > 0)
  {
    // Do something with the data
  }
}
```

--------------------------------

### GetLaunchAction Function Syntax

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/GetLaunchAction

Provides the C-style syntax for the pdfGetLaunchAction function, used to retrieve the properties of a launch action within the DynaPDF library. It takes an instance pointer, an action handle, and a pointer to a TPDFLaunchAction structure.

```c
LBOOL pdfGetLaunchAction(
const PPDF* IPDF,
// Instance pointer
UI32 Handle,
// Action handle
struct TPDFLaunchAction* Action)
// see below
```

--------------------------------

### DynaPDF: Font Color and Reset Example

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_848

Demonstrates setting font color using \FC[UI32] and resetting it. The example shows how to make text red and then reset the color.

```DynaPDF
"This is a \ul#\FC[255]red\FC[0]\ul# string!"
```

--------------------------------

### Visual Basic .Net: Initialize CPDF and Create PDF

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_039

This Visual Basic .Net code demonstrates the initialization of the CPDF class and the creation of a new PDF file. It includes setting document information like author and subject, appending a page, setting a font, writing text, and closing the file.

```Visual Basic .Net
Private WithEvents FPDF As CPDF 'Enable event support

Private Sub Form1_Load(ByVal eventSender As System.Object, ByVal
eventArgs As System.EventArgs) Handles MyBase.Load
    ' We hold one instance of the class CPDF in memory
    FPDF = New CPDF()
End Sub

Private Sub Command1_Click(ByVal eventSender As System.Object, ByVal
eventArgs As System.EventArgs) Handles Command1.Click
    FPDF.CreateNewPDFA("c:/vbout.pdf")
    FPDF.SetDocInfoA(CPDF.TDocumentInfo.diAuthor, "Jens Boschulte")
    FPDF.SetDocInfoA(CPDF.TDocumentInfo.diSubject, "My first VB output")
    FPDF.SetDocInfoA(CPDF.TDocumentInfo.diTitle, "My first VB output")
    FPDF.Append()
    ' The data type TFStyle is defined in DynaPDFInt.vb
    FPDF.SetFontA("Arial", TFStyle.fsItalic, 30.0, True, CPDF.TCodepage.cp1252)
    FPDF.WriteFTextA(CPDF.TTextAlign.taCenter, "My first VB .Net output")
    FPDF.EndPage()
    FPDF.CloseFile()
End Sub
```

--------------------------------

### SetBookmarkDest Example - Retain Zoom Factor

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/SetBookmarkDest

An example demonstrating the use of SetBookmarkDest with the dtXY_Zoom destination type, specifically showing how to retain the current zoom factor by passing 0 for the zoom parameter.

```c
// The zoom factor is left unchanged
SetBookmarkDest(pdf, bmk, dtXY_Zoom, 50, 750, 0, 0);
```

--------------------------------

### Create PDF with Transparency (C++)

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_099

This C++ code snippet demonstrates the basic creation of a PDF document using DynaPDF, which is a prerequisite for applying transparency features. It initializes the DynaPDF object and specifies an output file path.

```C++
int main(int argc, char* argv[])
{
pdfCreateNewPDF(PDF, "c:/cppout.pdf");
  

```

--------------------------------

### DynaPDF Link Annotation Examples

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_853

Demonstrates the usage of the \LK and \EK# tags for creating link annotations in DynaPDF. It shows examples with boolean parameters, URLs, named destinations, and file names, including handling of spaces.

```DynaPDF Script
\LK[false, TRUE, false, https://www.dynaforms.com]Test\EK# // Ok
```

```DynaPDF Script
\LK[0,1,0,https://www.dynaforms.com]Test\EK# // Same as above
```

```DynaPDF Script
\LK[true, true, true, NameOfADestination, test.pdf]Test\EK# // Ok
```

```DynaPDF Script
\LK[false, true, false, www.dyna forms.com
]Test\EK# // Invalid URL!
```

```DynaPDF Script
\LK[true, true, true, DestName, file name with spaces.pdf ]Test\EK# // Ok
```

--------------------------------

### Incorrect PDF String Formatting Example

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/Optimize

This example shows an incorrect approach to formatting PDF strings, leading to errors. It illustrates the problem of improperly quoting values and the consequences of not adhering to the expected data types for PDF keys.

```JavaScript
const char attr[] = "\"BBox\":[50 450 200 500]\"Placement\"\"Inline\"\"; // Wrong!
```

--------------------------------

### OpenTagEx JSON Attribute Examples (C/C++)

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/OpenTagBBox

Illustrates various valid ways to format the JSON-like attribute string for the OpenTagEx function in C/C++. These examples demonstrate different syntaxes for specifying attributes like BBox and Placement.

```C/C++
const char attr[] = "{/BBox[50, 450, 200, 500]/Placement/Inline}";
// Ok
```

```C/C++
const char attr[] = "/BBox :[50 450 200 500]/Placement/Inline";
// Ok
```

```C/C++
const char attr[] = "{{{{/BBox :[50 450 200 500]/Placement/Inline";
// Ok
```

```C/C++
const char attr[] = "/BBox :[50 450 200 500]/Placement/Inline}}}} ";
// Ok
```

```C/C++
const char attr[] = "\"BBox\":[50 450 200 500]\"Placement\"/Inline"; // Ok
```

```C/C++
const char attr[] = "/BBox,[50 450 200 500]\"Placement\"/Inline";
// Ok
```

```C/C++
const char attr[] = "/BBox:[50 450 200 500]/Placement/Inline";
// Ok
```

--------------------------------

### BeginTemplate Function Syntax

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/BeginTemplate

This snippet shows the C syntax for the BeginTemplate function in DynaPDF. It takes an instance pointer, width, and height as parameters to create a new template.

```c
SI32 pdfBeginTemplate(
const PPDF* IPDF, // Instance pointer
double Width,
// Width of the template
double Height)
// Height of the template
```

--------------------------------

### DynaPDF Error Callback Function Example (C)

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_597

This C code example demonstrates how to declare and use an error callback function for DynaPDF. The PDFError function prints error messages and is essential for debugging and understanding issues during PDF processing.

```C
SI32 PDF_CALL PDFError(const void* Data, SI32 ErrCode, const char*
ErrMessage, SI32 ErrType)
{
printf("%s\n", ErrMessage);
  
}
```

--------------------------------

### Basic DynaPDF PDF Creation and Formatting in Visual Basic

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_035

This Visual Basic code demonstrates the basic usage of DynaPDF to create a new PDF file, set document information (author, subject, title), and set a font with specific properties. It assumes the FPDF object has already been initialized.

```vb
Private Sub Command1_Click()
    FPDF.CreateNewPDFA "c:/vbout.pdf"
    FPDF.SetDocInfoA diAuthor, "Jens Boschulte"
    FPDF.SetDocInfoA diSubject, "My first VB output"
    FPDF.SetDocInfoA diTitle, "My first VB output"
    FPDF.Append
    FPDF.SetFont "Arial", fsItalic, 30#, True, cp1252
end sub
```

--------------------------------

### DynaPDF spcFlushPages Example in C++

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/dynapdf_241

This C++ example demonstrates how to use the spcFlushPages flag with the pdfConvertEMFSpool function to reduce memory usage. It also shows how to add an output intent for consistent color results and close the PDF file.

```C++
SI32 PDF_CALL PDFError(const void* Data, SI32 ErrCode,
    const char* ErrMessage, SI32 ErrType)
{
    printf("%s\n", ErrMessage);
    return 0; // We try to continue
}
SI32 ConvertSpoolFile(const void* PDF, const char* FileName,
    const char* OutFile)
{
    if (pdfCreateNewPDF(PDF, OutFile) < 0) return -3;
    // In this example we don't need to access the converted pages.
    // We can set the flag spcFlushPages to reduce the memory usage.
    pdfConvertEMFSpool(PDF, FileName, 0.0, 0.0, spcFlushPages);
    // The output intent represents the destination color space for which
    // the file was created. It makes sure that we get consistent color
    // results in different PDF viewers and when printing the PDF file.
    pdfAddOutputIntent(PDF, "../icc/sRGB.icc"); // Optional but recommended
    pdfCloseFile(PDF);
    
}
```

--------------------------------

### CreateGoToRActionEx Function Syntax

Source: https://www.monkeybreadsoftware.com/DynaPDF-Manual/CreateGoToRActionEx

This C syntax defines the CreateGoToRActionEx function, used to create a go-to-remote action. It takes an instance pointer, the file path to the target PDF, the named destination within that file, and a flag to open the file in a new window.

```C
SI32 pdfCreateGoToRActionEx(
const PPDF* IPDF,
// Instance pointer
const char* FileName, // File path to another PDF file
char* DestName,
// Named Destination to access
LBOOL NewWindow)
// If true, the file is opened in a new window
```
Tokens:
Raw