@syncfusion/ej2-pdf-export 19.4.52 → 20.2.36

package/dist/ts/implementation/input-output/pdf-writer.ts

@@ -0,0 +1,88 @@
+/**
+ * PdfWriter.ts class for EJ2-PDF
+ */
+import { StreamWriter } from '@syncfusion/ej2-file-utils';
+import { PdfDocumentBase } from './../document/pdf-document-base';
+import { IPdfWriter } from './../../interfaces/i-pdf-writer';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+/**
+ * Used to `write a string` into output file.
+ * @private
+ */
+export class PdfWriter implements IPdfWriter {
+    /**
+     * Specifies the current `position`.
+     * @private
+     */
+    private currentPosition : number;
+    /**
+     * Specifies the `length` of the stream.
+     * @private
+     */
+    private streamLength : number;
+    /**
+     * Check wheather the stream `can seek` or not.
+     * @private
+     */
+    private cannotSeek : boolean;
+    /**
+     * Specifies the parent `document`.
+     * @private
+     */
+    private pdfDocument : PdfDocumentBase;
+    /**
+     * Specifies the `stream`.
+     * @private
+     */
+    private streamWriter : StreamWriter;
+    /**
+     * Initialize an instance of `PdfWriter` class.
+     * @private
+     */
+    constructor(stream : StreamWriter) {
+        this.streamWriter = stream;
+    }
+    //properties
+    /**
+     * Gets and Sets the `document`.
+     * @private
+     */
+    public get document() : PdfDocumentBase {
+        return this.pdfDocument;
+    }
+    public set document(value : PdfDocumentBase) {
+        this.pdfDocument = value;
+    }
+    /**
+     * Gets the `position`.
+     * @private
+     */
+    public get position() : number {
+        return this.streamWriter.buffer.size;
+    }
+    /**
+     * Gets  the `length` of the stream'.
+     * @private
+     */
+    public get length() : number {
+        return this.streamWriter.buffer.size;
+    }
+    /**
+     * Gets the `stream`.
+     * @private
+     */
+    public get stream() : StreamWriter {
+        let result : StreamWriter = this.streamWriter;
+        return result;
+    }
+    //public Methods
+    /**
+     * `Writes the specified data`.
+     * @private
+     */
+    public write(overload : IPdfPrimitive|number|string|number[]) : void {
+        let data : number[] = [];
+        let tempOverload : string = <string>overload;
+        this.streamWriter.write(tempOverload);
+    }
+}

package/dist/ts/implementation/pages/enum.ts

@@ -0,0 +1,201 @@
+/**
+ * public Enum for `PdfPageOrientation`.
+ * @private
+ */
+export enum PdfPageOrientation {
+    /**
+     * Specifies the type of `Portrait`.
+     * @private
+     */
+    Portrait,
+    /**
+     * Specifies the type of `Landscape`.
+     * @private
+     */
+    Landscape,
+}
+/**
+ * public Enum for `PdfPageRotateAngle`.
+ * @private
+ */
+export enum PdfPageRotateAngle {
+    /**
+     * Specifies the type of `RotateAngle0`.
+     * @private
+     */
+    RotateAngle0,
+    /**
+     * Specifies the type of `RotateAngle90`.
+     * @private
+     */
+    RotateAngle90,
+    /**
+     * Specifies the type of `RotateAngle180`.
+     * @private
+     */
+    RotateAngle180,
+    /**
+     * Specifies the type of `RotateAngle270`.
+     * @private
+     */
+    RotateAngle270
+}
+/**
+ * public Enum for `PdfNumberStyle`.
+ * @private
+ */
+export enum PdfNumberStyle {
+    /**
+     * Specifies the type of `None`.
+     * @private
+     */
+    None = 0,
+    /**
+     * Specifies the type of `Numeric`.
+     * @private
+     */
+    Numeric,
+    /**
+     * Specifies the type of `LowerLatin`.
+     * @private
+     */
+    LowerLatin,
+    /**
+     * Specifies the type of `LowerRoman`.
+     * @private
+     */
+    LowerRoman,
+    /**
+     * Specifies the type of `UpperLatin`.
+     * @private
+     */
+    UpperLatin,
+    /**
+     * Specifies the type of `UpperRoman`.
+     * @private
+     */
+    UpperRoman
+}
+/**
+ * public Enum for `PdfDockStyle`.
+ * @private
+ */
+export enum PdfDockStyle {
+    /**
+     * Specifies the type of `None`.
+     * @private
+     */
+    None,
+    /**
+     * Specifies the type of `Bottom`.
+     * @private
+     */
+    Bottom,
+    /**
+     * Specifies the type of `Top`.
+     * @private
+     */
+    Top,
+    /**
+     * Specifies the type of `Left`.
+     * @private
+     */
+    Left,
+    /**
+     * Specifies the type of `Right`.
+     * @private
+     */
+    Right,
+    /**
+     * Specifies the type of `Fill`.
+     * @private
+     */
+    Fill
+}
+/**
+ * public Enum for `PdfAlignmentStyle`.
+ * @private
+ */
+export enum PdfAlignmentStyle {
+    /**
+     * Specifies the type of `None`.
+     * @private
+     */
+    None,
+    /**
+     * Specifies the type of `TopLeft`.
+     * @private
+     */
+    TopLeft,
+    /**
+     * Specifies the type of `TopCenter`.
+     * @private
+     */
+    TopCenter,
+    /**
+     * Specifies the type of `TopRight`.
+     * @private
+     */
+    TopRight,
+    /**
+     * Specifies the type of `MiddleLeft`.
+     * @private
+     */
+    MiddleLeft,
+    /**
+     * Specifies the type of `MiddleCenter`.
+     * @private
+     */
+    MiddleCenter,
+    /**
+     * Specifies the type of `MiddleRight`.
+     * @private
+     */
+    MiddleRight,
+    /**
+     * Specifies the type of `BottomLeft`.
+     * @private
+     */
+    BottomLeft,
+    /**
+     * Specifies the type of `BottomCenter`.
+     * @private
+     */
+    BottomCenter,
+    /**
+     * Specifies the type of `BottomRight`.
+     * @private
+     */
+    BottomRight,
+}
+/**
+ * public Enum for `TemplateType`.
+ * @private
+ */
+export enum TemplateType {
+    /**
+     * Specifies the type of `None`.
+     * @private
+     */
+    None,
+    /**
+     * Specifies the type of `Top`.
+     * @private
+     */
+    Top,
+    /**
+     * Specifies the type of `Bottom`.
+     * @private
+     */
+    Bottom,
+    /**
+     * Specifies the type of `Left`.
+     * @private
+     */
+    Left,
+    /**
+     * Specifies the type of `Right`.
+     * @private
+     */
+    Right
+}

package/dist/ts/implementation/pages/page-added-event-arguments.ts

@@ -0,0 +1,39 @@
+/**
+ * PageAddedEventArguments.ts class for EJ2-PDF
+ */
+import { PdfPage } from './pdf-page';
+/**
+ * Provides data for `PageAddedEventHandler` event.
+ * This event raises when adding the new PDF page to the PDF document.
+ */
+export class PageAddedEventArgs {
+    /**
+     * Represents added `page`.
+     * @private
+     */
+    private pdfPage : PdfPage;
+    /**
+     * Gets the `newly added page`.
+     * @private
+     */
+    public get page() : PdfPage {
+        return this.pdfPage;
+    }
+    /**
+     * Initializes a new instance of the `PageAddedEventArgs` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `PageAddedEventArgs` class with 'PdfPage'.
+     * @private
+     */
+    public constructor(page : PdfPage)
+    public constructor(page? : PdfPage) {
+        if (typeof page !== 'undefined') {
+            this.pdfPage = page;
+        } else {
+            this.pdfPage = null;
+        }
+    }
+}

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

@@ -0,0 +1,180 @@
+import { PdfDocument } from './../document/pdf-document';
+import { PdfPage } from './pdf-page';
+import { PdfSection } from './pdf-section';
+import { PdfSectionCollection } from './pdf-section-collection';
+import { PageAddedEventArgs } from './../pages/page-added-event-arguments';
+import { Dictionary } from './../collections/dictionary';
+/**
+ * Represents a virtual collection of all the pages in the document.
+ * @private
+ */
+export class PdfDocumentPageCollection {
+    /**
+     * Parent `document`.
+     * @private
+     */
+    private document : PdfDocument;
+    /**
+     * It holds the page collection with the `index`.
+     * @private
+     */
+    private pdfPageCollectionIndex : Dictionary<PdfPage, number> = new Dictionary<PdfPage, number>();
+    /**
+     * Internal variable for `page added event`.
+     * @private
+     */
+    public pageAdded : PageAddedEventArgs; //event
+    //Property
+    /**
+     * Gets the total `number of the pages`.
+     * @private
+     */
+    public get count() : number {
+        return this.countPages();
+    }
+    /**
+     * Gets a `page index` from the document.
+     * @private
+     */
+    public get pageCollectionIndex() : Dictionary<PdfPage, number> {
+        return this.pdfPageCollectionIndex;
+    }
+    //constructor
+    /**
+     * Initializes a new instance of the `PdfPageCollection` class.
+     * @private
+     */
+    constructor(document : PdfDocument) {
+        this.document = document;
+    }
+    /**
+     * Creates a page and `adds` it to the last section in the document.
+     * @private
+     */
+    public add() : PdfPage
+    /**
+     * Creates a page and `adds` it to the last section in the document.
+     * @private
+     */
+    public add(page : PdfPage) : void
+    public add(page? : PdfPage) : PdfPage|void {
+        if (typeof page === 'undefined') {
+            let page : PdfPage = new PdfPage();
+            this.add(page);
+            return page;
+        } else {
+            let section : PdfSection = this.getLastSection();
+            section.add(page);
+        }
+    }
+    /**
+     * Returns `last section` in the document.
+     * @private
+     */
+    private getLastSection() : PdfSection {
+        let sc : PdfSectionCollection = this.document.sections;
+        if (sc.section.length === 0) {
+            sc.add();
+        }
+        let section : PdfSection = sc.section[sc.section.length - 1];
+        return section;
+    }
+    /**
+     * Called when `new page has been added`.
+     * @private
+     */
+    public onPageAdded(args : PageAddedEventArgs) : void {
+        // if (PageAdded !== null)
+        // {
+        //     PageAdded(this, args);
+        // }
+    }
+    /**
+     * Gets the `total number of pages`.
+     * @private
+     */
+    private countPages() : number {
+        let sc : PdfSectionCollection = this.document.sections;
+        let count : number = 0;
+        for (let index : number = 0; index < sc.section.length; index++) {
+            count += sc.section[index].count;
+        }
+        return count;
+    }
+    /**
+     * Gets the `page object` from page index.
+     * @private
+     */
+    public getPageByIndex(index : number) : PdfPage {
+        return this.getPage(index);
+    }
+    /**
+     * Gets a page by its `index` in the document.
+     * @private
+     */
+    private getPage(index : number) : PdfPage {
+        if ((index < 0) || (index >= this.count)) {
+            throw Error('ArgumentOutOfRangeException("index", "Value can not be less 0")');
+        }
+        let page : PdfPage = null;
+        let sectionStartIndex : number = 0;
+        let sectionCount : number = 0;
+        let pageIndex : number = 0;
+        let length : number = this.document.sections.count;
+        for (let i : number = 0; i < length; i++) {
+            let section : PdfSection = this.document.sections.section[i];
+            sectionCount = section.count;
+            pageIndex = index - sectionStartIndex;
+            // We found a section containing the page.
+            if ((index >= sectionStartIndex && pageIndex < sectionCount)) {
+                page = section.getPages()[pageIndex] as PdfPage;
+                break;
+            }
+            sectionStartIndex += sectionCount;
+        }
+        return page;
+    }
+    /**
+     * Gets the `index of` the page in the document.
+     * @private
+     */
+    public indexOf(page : PdfPage) : number {
+        let index : number = -1;
+        if (page == null) {
+            throw new Error('ArgumentNullException: page');
+        } else {
+            let numPages : number = 0;
+            for (let i : number = 0, len : number = this.document.sections.count; i < len; i++) {
+                let section : PdfSection = this.document.sections.pdfSectionCollection(i);
+                index = section.indexOf(page);
+                if (index >= 0) {
+                    index += numPages;
+                    break;
+                } else {
+                    index = -1;
+                }
+                numPages += section.count;
+            }
+        }
+        return index;
+    }
+    /**
+     * `Removes` the specified page.
+     * @private
+     */
+    public remove(page : PdfPage) : PdfSection {
+        if (page == null) {
+            throw Error('ArgumentNullException("page")');
+        }
+        let section : PdfSection = null;
+        let len : number;
+        for (let i : number = 0, len : number = this.document.sections.count; i < len; i++) {
+            section = this.document.sections.pdfSectionCollection(i);
+            if (section.pages.contains(page)) {
+                section.pages.remove(page);
+                break;
+            }
+        }
+        return section;
+    }
+}

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

@@ -0,0 +1,181 @@
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { PdfArray } from './../primitives/pdf-array';
+import { PointF, SizeF } from './../drawing/pdf-drawing';
+import { PdfPageLayerCollection } from './pdf-page-layer-collection';
+import { PdfPageLayer } from './pdf-page-layer';
+import { DictionaryProperties } from './../input-output/pdf-dictionary-properties';
+import { PdfReferenceHolder } from './../primitives/pdf-reference';
+import { PdfResources } from './../graphics/pdf-resources';
+import { PdfSection } from './pdf-section';
+/**
+ * The abstract base class for all pages,
+ * `PdfPageBase` class provides methods and properties to create PDF pages and its elements.
+ * @private
+ */
+export abstract class PdfPageBase implements IPdfWrapper {
+    /**
+     * Collection of the `layers` of the page.
+     * @private
+     */
+    private layerCollection : PdfPageLayerCollection;
+    /**
+     * Stores the instance of `PdfDictionary` class.
+     * @private
+     */
+    private pageDictionary : PdfDictionary;
+    /**
+     * `Index` of the default layer.
+     * @default -1.
+     * @private
+     */
+    private defLayerIndex : number = -1;
+    /**
+     * Local variable to store if page `updated`.
+     * @default false.
+     * @private
+     */
+    private modified : boolean = false;
+    /**
+     * Stores the instance of `PdfResources`.
+     * @hidden
+     * @private
+     */
+    private resources : PdfResources;
+    /**
+     * Instance of `DictionaryProperties` class.
+     * @hidden
+     * @private
+     */
+    protected dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    /**
+     * Specifies the current `section`.
+     * @hidden
+     * @private
+     */
+    private pdfSection : PdfSection;
+    //Properties
+    /**
+     * Gets the `section` of a page.
+     * @private
+     */
+    public get section() : PdfSection {
+        // if (this.pdfSection === null) {
+        //     throw new Error('PdfException : Page must be added to some section before using.');
+        // }
+        return this.pdfSection;
+    }
+    public set section(value : PdfSection) {
+        this.pdfSection = value;
+    }
+    /**
+     * Gets the page `dictionary`.
+     * @private
+     */
+    public get dictionary() : PdfDictionary {
+        return this.pageDictionary;
+    }
+    /**
+     * Gets the wrapped `element`.
+     * @private
+     */
+    public get element() : IPdfPrimitive {
+        return this.pageDictionary;
+    }
+    /**
+     * Gets the `default layer` of the page (Read only).
+     * @private
+     */
+    public get defaultLayer() : PdfPageLayer {
+        let layer : PdfPageLayerCollection = this.layers;
+        let index : number = this.defaultLayerIndex;
+        let returnlayer : PdfPageLayer = layer.items(index) as PdfPageLayer;
+        return returnlayer;
+    }
+    /**
+     * Gets or sets `index of the default layer`.
+     * @private
+     */
+    public get defaultLayerIndex() : number {
+        if (this.layerCollection.count === 0 || this.defLayerIndex === -1) {
+            let layer : PdfPageLayer = this.layerCollection.add();
+            this.defLayerIndex = this.layerCollection.indexOf(layer);
+        }
+        return this.defLayerIndex;
+    }
+    /**
+     * Gets the collection of the page's `layers` (Read only).
+     * @private
+     */
+    public get layers() : PdfPageLayerCollection {
+        if (this.layerCollection == null || typeof this.layerCollection === 'undefined') {
+            this.layerCollection = new PdfPageLayerCollection(this);
+        }
+        return this.layerCollection;
+    }
+    /**
+     * Return an instance of `PdfResources` class.
+     * @private
+     */
+    public getResources() : PdfResources {
+        if (this.resources == null) {
+            this.resources = new PdfResources();
+            this.dictionary.items.setValue(this.dictionaryProperties.resources, this.resources);
+        }
+        return this.resources;
+    }
+    /**
+     * Gets `array of page's content`.
+     * @private
+     */
+    public get contents(): PdfArray {
+        let obj : IPdfPrimitive = this.pageDictionary.items.getValue(this.dictionaryProperties.contents);
+        let contents : PdfArray = obj as PdfArray;
+        let rh : PdfReferenceHolder = obj as PdfReferenceHolder;
+        if (contents == null) {
+            contents = new PdfArray();
+            this.pageDictionary.items.setValue(this.dictionaryProperties.contents, contents);
+        }
+        return contents;
+    }
+    /**
+     * Gets or sets` index of the default layer`.
+     * @private
+     */
+    public set defaultLayerIndex(value : number) {
+        if (value < 0 || value > this.layers.count - 1) {
+            throw new Error('ArgumentOutOfRangeException : value, Index can not be less 0 and greater Layers.Count - 1');
+        } else {
+            this.defLayerIndex = value;
+            this.modified = true;
+        }
+    }
+    /**
+     * Sets the `resources`.
+     * @private
+     */
+    public setResources(res : PdfResources) : void {
+        this.resources = res;
+        this.dictionary.items.setValue(this.dictionaryProperties.resources, this.resources);
+        this.modified = true;
+    }
+    /**
+     * Gets the `size of the page` (Read only).
+     * @private
+     */
+    public abstract get size() : SizeF;
+    /**
+     * Gets the `origin of the page`.
+     * @private
+     */
+    public abstract get origin() : PointF;
+    //constructors
+    /**
+     * Initializes a new instance of the `PdfPageBase` class.
+     * @private
+     */
+    constructor(dictionary : PdfDictionary) {
+        this.pageDictionary = dictionary;
+    }
+}