@syncfusion/ej2-pdf-export 23.2.6 → 24.1.41

package/dist/ts/implementation/pages/pdf-page.ts

@@ -0,0 +1,235 @@
+import { PdfPageBase } from './pdf-page-base';
+import { PdfDictionary, SaveTemplateEventHandler } from './../primitives/pdf-dictionary';
+import { PdfName } from './../primitives/pdf-name';
+import { PdfDocument } from './../document/pdf-document';
+import { PdfSection } from './pdf-section';
+import { PdfReferenceHolder } from './../primitives/pdf-reference';
+import { PdfCrossTable } from './../input-output/pdf-cross-table';
+import { SizeF, PointF, RectangleF } from './../drawing/pdf-drawing';
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { PdfArray } from './../primitives/pdf-array';
+import { PdfAnnotationCollection } from './../annotations/annotation-collection';
+import { PdfGraphics } from './../graphics/pdf-graphics';
+import { PdfPageLayer } from './pdf-page-layer';
+import { PdfAutomaticFieldInfo } from './../document/automatic-fields/automatic-field-info';
+/**
+ * Provides methods and properties to create pages and its elements. 
+ * `PdfPage` class inherited from the `PdfPageBase` class.
+ * ```typescript
+ * // create a new PDF document
+ * let document : PdfDocument = new PdfDocument();
+ * //
+ * // add a new page to the document
+ * let page1 : PdfPage = document.pages.add();
+ * //
+ * // set the font
+ * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+ * // create black brush
+ * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+ * // draw the text
+ * page1.graphics.drawString('Hello World', font, blackBrush, new PointF(0, 0));
+ * // save the document
+ * document.save('output.pdf');
+ * // destroy the document
+ * document.destroy();
+ * ```
+ */
+export class PdfPage extends PdfPageBase {
+    //Fields
+    /**
+     * Checks whether the `progress is on`.
+     * @hidden
+     * @private
+     */
+    private isProgressOn : boolean;
+    /**
+     * Stores the instance of `PdfAnnotationCollection` class.
+     * @hidden
+     * @default null
+     * @private
+     */
+    private annotationCollection : PdfAnnotationCollection = null;
+    /**
+     * Stores the instance of `PageBeginSave` event for Page Number Field.
+     * @default null
+     * @private
+     */
+    public beginSave : Function = null;
+    //constructors
+    /**
+     * Initialize the new instance for `PdfPage` class.
+     * @private
+     */
+    public constructor() {
+        super(new PdfDictionary());
+        this.initialize();
+    }
+    //Properties
+    /**
+     * Gets current `document`.
+     * @private
+     */
+    public get document() : PdfDocument {
+        if (this.section !== null && this.section.parent !== null) {
+            return this.section.parent.document;
+        } else {
+            return null;
+        }
+    }
+    /**
+     * Get the current `graphics`.
+     * ```typescript
+     * // create a new PDF document
+     * let document : PdfDocument = new PdfDocument();
+     * // add a new page to the document
+     * let page1 : PdfPage = document.pages.add();
+     * //
+     * // get graphics
+     * let graphics : PdfGraphics = page1.graphics;
+     * //
+     * // set the font
+     * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+     * // create black brush
+     * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+     * // draw the text
+     * graphics.drawString('Hello World', font, blackBrush, new PointF(0, 0));
+     * // save the document
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     */
+    public get graphics() : PdfGraphics {
+        let result : PdfGraphics = this.defaultLayer.graphics;
+        result.currentPage = this;
+        return result;
+    }
+    /**
+     * Gets the `cross table`.
+     * @private
+     */
+    public get crossTable() : PdfCrossTable {
+        if (this.section === null) {
+            throw new Error('PdfDocumentException : Page is not created');
+        }
+        return this.section.parent === null ? this.section.parentDocument.crossTable : this.section.parent.document.crossTable;
+    }
+    /**
+     * Gets the size of the PDF page- Read only.
+     * @public
+     */
+    public get size() : SizeF {
+        return this.section.pageSettings.size;
+    }
+    /**
+     * Gets the `origin` of the page.
+     * @private
+     */
+    public get origin() : PointF {
+        return this.section.pageSettings.origin;
+    }
+    /**
+     * Gets a collection of the `annotations` of the page- Read only.
+     * @private
+     */
+    public get annotations() : PdfAnnotationCollection {
+        if (this.annotationCollection == null) {
+            this.annotationCollection = new PdfAnnotationCollection(this);
+            // if (!this.Dictionary.ContainsKey(this.dictionaryProperties.annots)) {
+            this.dictionary.items.setValue(this.dictionaryProperties.annots, (this.annotationCollection as IPdfWrapper).element);
+            // }
+            this.annotationCollection.annotations = this.dictionary.items.getValue(this.dictionaryProperties.annots) as PdfArray;
+        }
+        return this.annotationCollection;
+    }
+    //Implementation
+    /**
+     * `Initializes` a page.
+     * @private
+     */
+    private initialize() : void {
+        this.dictionary.items.setValue(this.dictionaryProperties.type, new PdfName('Page'));
+        this.dictionary.pageBeginDrawTemplate = new SaveTemplateEventHandler(this);
+    }
+    /**
+     * Sets parent `section` to the page.
+     * @private
+     */
+    public setSection(section : PdfSection) : void {
+        this.section = section;
+        this.dictionary.items.setValue(this.dictionaryProperties.parent, new PdfReferenceHolder(section));
+    }
+    /**
+     * `Resets the progress`.
+     * @private
+     */
+    public resetProgress() : void {
+        this.isProgressOn = false;
+    }
+    /**
+     * Get the page size reduced by page margins and page template dimensions.
+     * ```typescript
+     * // create a new PDF document
+     * let document : PdfDocument = new PdfDocument();
+     * // add a pages to the document
+     * let page1 : PdfPage = document.pages.add();
+     * // create new standard font
+     * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+     * // set brush
+     * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+     * //
+     * // set the specified point using `getClientSize` method
+     * let point : PointF = new PointF(page1.getClientSize().width - 200, page1.getClientSize().height - 200);
+     * // draw the text
+     * page1.graphics.drawString('Hello World', font, blackBrush, point);
+     * //
+     * // save the document
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     */
+    public getClientSize() : SizeF {
+        let returnValue : RectangleF = this.section.getActualBounds(this, true);
+        return new SizeF(returnValue.width, returnValue.height);
+    }
+    /**
+     * Helper method to retrive the instance of `PageBeginSave` event for header and footer elements.
+     * @private
+     */
+    public pageBeginSave() : void {
+        let doc : PdfDocument = this.document as PdfDocument;
+        if (typeof doc !== undefined && doc != null) {
+            this.drawPageTemplates(doc);
+        }
+        if ( this.beginSave != null && typeof this.beginSave !== 'undefined') {
+            this.beginSave(this);
+        }
+    }
+    /**
+     * Helper method to draw template elements.
+     * @private
+     */
+    private drawPageTemplates(document : PdfDocument) : void {
+        // Draw Background templates.
+        let hasBackTemplates : boolean = this.section.containsTemplates(document, this, false);
+        if (hasBackTemplates) {
+            let backLayer : PdfPageLayer = new PdfPageLayer(this, false);
+            this.layers.insert(0, backLayer);
+            this.section.drawTemplates(this, backLayer, document, false);
+            if (backLayer.graphics !== null && typeof backLayer.graphics !== 'undefined') {
+                for (let i : number = 0; i < backLayer.graphics.automaticFields.automaticFields.length; i++) {
+                    let fieldInfo : PdfAutomaticFieldInfo = backLayer.graphics.automaticFields.automaticFields[i] as PdfAutomaticFieldInfo;
+                    fieldInfo.field.performDraw(backLayer.graphics, fieldInfo.location, fieldInfo.scalingX, fieldInfo.scalingY);
+                }
+            }
+        }
+        // Draw Foreground templates.
+        let hasFrontTemplates : boolean = this.section.containsTemplates(document, this, true);
+        if (hasFrontTemplates) {
+            let frontLayer : PdfPageLayer = new PdfPageLayer(this, false);
+            this.layers.add(frontLayer);
+            this.section.drawTemplates(this, frontLayer, document, true);
+        }
+    }
+}

package/dist/ts/implementation/pages/pdf-section-collection.ts

@@ -0,0 +1,187 @@
+/**
+ * PdfSectionCollection.ts class for EJ2-PDF
+ */
+import { PdfDocument } from './../document/pdf-document';
+import { PdfNumber } from './../primitives/pdf-number';
+import { PdfName } from './../primitives/pdf-name';
+import { PdfArray } from './../primitives/pdf-array';
+import { PdfDictionary, SaveSectionCollectionEventHandler } from './../primitives/pdf-dictionary';
+import { PdfReferenceHolder } from './../primitives/pdf-reference';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { PdfPageSettings } from './pdf-page-settings';
+import { RectangleF, PointF } from './../drawing/pdf-drawing';
+import { PdfSection } from './pdf-section';
+import { DictionaryProperties } from './../input-output/pdf-dictionary-properties';
+/**
+ * Represents the `collection of the sections`.
+ * @private
+ */
+export class PdfSectionCollection implements IPdfWrapper {
+    //Fields
+    /**
+     * Rotate factor for page `rotation`.
+     * @default 90
+     * @private
+     */
+    public static readonly rotateFactor : number = 90;
+    /**
+     * the current `document`.
+     * @private
+     */
+    private pdfDocument : PdfDocument;
+    /**
+     * `count` of the sections.
+     * @private
+     */
+    private sectionCount : PdfNumber;
+    /**
+     * @hidden
+     * @private
+     */
+    private sections : PdfSection[] = [];
+    /**
+     * @hidden
+     * @private
+     */
+    private sectionCollection : PdfArray;
+    /**
+     * @hidden
+     * @private
+     */
+    private pages : PdfDictionary;
+    /**
+     * @hidden
+     * @private
+     */
+    private dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    //constructor
+    /**
+     * Initializes a new instance of the `PdfSectionCollection` class.
+     * @private
+     */
+    public constructor(document : PdfDocument) {
+        // if (document === null) {
+        //     throw new Error('ArgumentNullException : document');
+        // }
+        this.pdfDocument = document.clone();
+        this.initialize();
+    }
+    //Properties
+    /**
+     * Gets the `Section` collection.
+     */
+    public get section() : PdfSection[] {
+        return this.sections;
+    }
+    /**
+     * Gets a parent `document`.
+     * @private
+     */
+    public get document() : PdfDocument {
+        return this.pdfDocument;
+    }
+    /**
+     * Gets the `number of sections` in a document.
+     * @private
+     */
+    public get count() : number {
+        return this.sections.length;
+    }
+    /**
+     * Gets the wrapped `element`.
+     * @private
+     */
+    public get element() : IPdfPrimitive {
+        return this.pages;
+    }
+    //Methods
+    /**
+     * `Initializes the object`.
+     * @private
+     */
+    private initialize() : void {
+        this.sectionCount = new PdfNumber(0);
+        this.sectionCollection = new PdfArray();
+        this.pages = new PdfDictionary();
+        this.pages.beginSave = new SaveSectionCollectionEventHandler(this);
+        this.pages.items.setValue(this.dictionaryProperties.type, new PdfName('Pages'));
+        this.pages.items.setValue(this.dictionaryProperties.kids, this.sectionCollection);
+        this.pages.items.setValue(this.dictionaryProperties.count, this.sectionCount);
+        this.pages.items.setValue(this.dictionaryProperties.resources, new PdfDictionary());
+        this.setPageSettings(this.pages, this.pdfDocument.pageSettings);
+    }
+    /**
+     * Initializes a new instance of the `PdfSectionCollection` class.
+     * @private
+     */
+    public pdfSectionCollection(index : number) : PdfSection {
+        if (index < 0 || index >= this.count) {
+            throw new Error('IndexOutOfRangeException()');
+        }
+        return (this.sections[index] as PdfSection);
+    }
+    /**
+     * In fills dictionary by the data from `Page settings`.
+     * @private
+     */
+    private setPageSettings(container : PdfDictionary, pageSettings : PdfPageSettings) : void {
+        // if (container === null) {
+        //     throw new Error('ArgumentNullException : container');
+        // }
+        // if (pageSettings === null) {
+        //     throw new Error('ArgumentNullException : pageSettings');
+        // }
+        let bounds : RectangleF = new RectangleF(new PointF(), pageSettings.size);
+        container.items.setValue(this.dictionaryProperties.mediaBox, PdfArray.fromRectangle(bounds));
+    }
+    /**
+     * `Adds` the specified section.
+     * @private
+     */
+    public add(section? : PdfSection) : number|PdfSection {
+        if (typeof section === 'undefined') {
+            let section : PdfSection = new PdfSection(this.pdfDocument);
+            this.add(section);
+            return section;
+        } else {
+            // if (section === null) {
+            //     throw new Error('ArgumentNullException : section');
+            // }
+            let r : PdfReferenceHolder = this.checkSection(<PdfSection>section);
+            this.sections.push(section);
+            section.parent = this;
+            this.sectionCollection.add(r);
+            return this.sections.indexOf(section);
+        }
+    }
+    /**
+     * `Checks` if the section is within the collection.
+     * @private
+     */
+    private checkSection(section : PdfSection) : PdfReferenceHolder {
+        let r : PdfReferenceHolder = new PdfReferenceHolder(section);
+        let contains : boolean = this.sectionCollection.contains(r);
+        // if (contains) {
+        //     throw new Error('ArgumentException : The object can not be added twice to the collection,section');
+        // }
+        return r;
+    }
+    /**
+     * Catches the Save event of the dictionary to `count the pages`.
+     * @private
+     */
+    public countPages() : number {
+        let count : number = 0;
+        this.sections.forEach((n : PdfSection) => (count += n.count));
+        return count;
+    }
+    /**
+     * Catches the Save event of the dictionary to `count the pages`.
+     * @hidden
+     * @private
+     */
+    public beginSave() : void {
+        this.sectionCount.intValue = this.countPages();
+    }
+}

package/dist/ts/implementation/pages/pdf-section-page-collection.ts

@@ -0,0 +1,61 @@
+/**
+ * PdfSectionPageCollection.ts class for EJ2-PDF
+ */
+import { PdfPage } from './pdf-page';
+import { PdfSection } from './pdf-section';
+/**
+ * Represents the `collection of pages in a section`.
+ * @private
+ */
+export class PdfSectionPageCollection {
+    //  Fields
+    /**
+     * @hidden
+     * @private
+     */
+    private pdfSection : PdfSection = null;
+    // Properties
+    /**
+     * Gets the `PdfPage` at the specified index.
+     * @private
+     */
+    public get section() : PdfSection {
+        return this.pdfSection;
+    }
+    public set section(value : PdfSection) {
+        this.pdfSection = value;
+    }
+    // Constructors
+    /**
+     * Initializes a new instance of the `PdfSectionPageCollection` class.
+     * @private
+     */
+    public constructor(section : PdfSection) {
+        if (section == null) {
+            throw Error('ArgumentNullException("section")');
+        }
+        this.section = section;
+    }
+    // Public Methods
+    /**
+     * `Determines` whether the specified page is within the collection.
+     * @private
+     */
+    public contains(page : PdfPage) : boolean {
+        return this.section.contains(page);
+    }
+    /**
+     * `Removes` the specified page from collection.
+     * @private
+     */
+    public remove(page : PdfPage) : void {
+        this.section.remove(page);
+    }
+    /**
+     * `Adds` a new page from collection.
+     * @private
+     */
+    public add() : PdfPage {
+        return this.section.add() as PdfPage;
+    }
+}

package/dist/ts/implementation/pages/pdf-section-templates.ts

@@ -0,0 +1,96 @@
+/**
+ * PdfSectionTemplate.ts class for EJ2-PDF
+ */
+import { PdfDocumentTemplate } from './../document/pdf-document-template';
+/**
+ * Represents a `page template` for all the pages in the section.
+ */
+export class PdfSectionTemplate extends PdfDocumentTemplate {
+    // Fields
+    /**
+     * `Left` settings.
+     * @private
+     */
+    private leftValue : boolean;
+    /**
+     * `Top` settings.
+     * @private
+     */
+    private topValue : boolean;
+    /**
+     * `Right` settings.
+     * @private
+     */
+    private rightValue : boolean;
+    /**
+     * `Bottom` settings.
+     * @private
+     */
+    private bottomValue : boolean;
+    /**
+     * `Other templates settings`.
+     * @private
+     */
+    private stampValue : boolean;
+
+    // Properties
+    /**
+     * Gets or sets value indicating whether parent `Left page template should be used or not`.
+     * @private
+     */
+    public get applyDocumentLeftTemplate() : boolean {
+        return this.leftValue;
+    }
+    public set applyDocumentLeftTemplate(value : boolean) {
+        this.leftValue = value;
+    }
+    /**
+     * Gets or sets value indicating whether parent `Top page template should be used or not`.
+     * @private
+     */
+    public get applyDocumentTopTemplate() : boolean {
+        return this.topValue;
+    }
+    public set applyDocumentTopTemplate(value : boolean) {
+        this.topValue = value;
+    }
+    /**
+     * Gets or sets value indicating whether parent `Right page template should be used or not`.
+     * @private
+     */
+    public get applyDocumentRightTemplate() : boolean {
+        return this.rightValue;
+    }
+    public set applyDocumentRightTemplate(value : boolean) {
+        this.rightValue = value;
+    }
+    /**
+     * Gets or sets value indicating whether parent `Bottom page template should be used or not`.
+     * @private
+     */
+    public get applyDocumentBottomTemplate() : boolean {
+        return this.bottomValue;
+    }
+    public set applyDocumentBottomTemplate(value : boolean) {
+        this.bottomValue = value;
+    }
+    /**
+     * Gets or sets value indicating whether the `stamp value` is true or not.
+     * @private
+     */
+    public get applyDocumentStamps() : boolean {
+        return this.stampValue;
+    }
+    public set applyDocumentStamps(value : boolean) {
+        this.stampValue = value;
+    }
+    // Constructors
+    /**
+     * `Creates a new object`.
+     * @private
+     */
+    public constructor() {
+        super();
+        this.leftValue = this.topValue = this.rightValue = this.bottomValue = this.stampValue = true;
+    }
+}