@syncfusion/ej2-pdf-export 20.1.55 → 20.2.36

package/dist/ts/implementation/collections/object-object-pair/dictionary.ts

@@ -0,0 +1,125 @@
+/**
+ * Dictionary class
+ * @private
+ * @hidden
+ */
+export class TemporaryDictionary<K, V> {
+    /**
+     * @hidden
+     * @private
+     */
+    private mKeys: K[] = [];
+    /**
+     * @hidden
+     * @private
+     */
+    private mValues: V[] = [];
+    /**
+     * @hidden
+     * @private
+     */
+    public size(): number {
+        return this.mKeys.length;
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public add(key: K, value: V): number {
+        if (key === undefined || key === null || value === undefined || value === null) {
+            throw new ReferenceError('Provided key or value is not valid.');
+        }
+        let index: number = this.mKeys.indexOf(key);
+        if (index < 0) {
+            this.mKeys.push(key);
+            this.mValues.push(value);
+            return 1;
+        } else {
+            throw new RangeError('An item with the same key has already been added.');
+        }
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public keys(): K[] {
+        return this.mKeys;
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public values(): V[] {
+        return this.mValues;
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public getValue(key: K): V {
+        if (key === undefined || key === null) {
+            throw new ReferenceError('Provided key is not valid.');
+        }
+        let index: number = this.mKeys.indexOf(key);
+        if (index < 0) {
+            throw new RangeError('No item with the specified key has been added.');
+        } else {
+            return this.mValues[index];
+        }
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public setValue(key: K, value: V): void {
+        if (key === undefined || key === null) {
+            throw new ReferenceError('Provided key is not valid.');
+        }
+        let index: number = this.mKeys.indexOf(key);
+        if (index < 0) {
+            this.mKeys.push(key);
+            this.mValues.push(value);
+        } else {
+            this.mValues[index] = value;
+        }
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public remove(key: K): boolean {
+        if (key === undefined || key === null) {
+            throw new ReferenceError('Provided key is not valid.');
+        }
+        let index: number = this.mKeys.indexOf(key);
+        if (index < 0) {
+            throw new RangeError('No item with the specified key has been added.');
+        } else {
+            this.mKeys.splice(index, 1);
+            this.mValues.splice(index, 1);
+            return true;
+        }
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public containsKey(key: K): boolean {
+        if (key === undefined || key === null) {
+            throw new ReferenceError('Provided key is not valid.');
+        }
+        let index: number = this.mKeys.indexOf(key);
+        if (index < 0) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * @hidden
+     * @private
+     */
+    public clear(): void {
+        this.mKeys = [];
+        this.mValues = [];
+    }
+}

package/dist/ts/implementation/collections/utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Utils.ts class for EJ2-PDF
+ * @private
+ * @hidden
+ */
+export interface ICompareFunction<T> {
+    (a: T, b: T): number;
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface IEqualsFunction<T> {
+    (a: T, b: T): boolean;
+}
+/**
+ * @private
+ * @hidden
+ */
+export interface ILoopFunction<T> {
+    (a: T): boolean | void;
+}
+/**
+ * @private
+ * @hidden
+ */
+export function defaultToString(item: string|number|string[]|number[]|Object|Object[]|boolean): string {
+    // if (item === null) {
+    //     return 'COLLECTION_NULL';
+    // } else if (typeof item === 'undefined') {
+    //     return 'COLLECTION_UNDEFINED';
+    // } else if (Object.prototype.toString.call(item) === '[object String]') {
+    if (Object.prototype.toString.call(item) === '[object String]') {
+        return '$s' + item;
+    } else {
+        return '$o' + item.toString();
+    }
+}

package/dist/ts/implementation/document/automatic-fields/automatic-field-info-collection.ts

@@ -0,0 +1,39 @@
+/**
+ * PdfAutomaticFieldInfoCollection.ts class for EJ2-PDF
+ * @private
+ */
+import { PdfAutomaticFieldInfo } from './automatic-field-info';
+/**
+ * Represent a `collection of automatic fields information`.
+ * @private
+ */
+export class PdfAutomaticFieldInfoCollection {
+    /**
+     * Internal variable to store instance of `pageNumberFields` class.
+     * @private
+     */
+    private automaticFieldsInformation : PdfAutomaticFieldInfo[] = [];
+    /**
+     * Gets the `page number fields collection`.
+     * @private
+     */
+    public get automaticFields() : PdfAutomaticFieldInfo[] {
+        return this.automaticFieldsInformation;
+    }
+    /**
+     * Initializes a new instance of the 'PdfPageNumberFieldInfoCollection' class.
+     * @private
+     */
+    public constructor() {
+        //
+    }
+    // Public methods
+    /// Adds the specified field info.
+    /**
+     * Add page number field into collection.
+     * @private
+     */
+    public add(fieldInfo : PdfAutomaticFieldInfo) : number {
+        return this.automaticFields.push(fieldInfo);
+    }
+}

package/dist/ts/implementation/document/automatic-fields/automatic-field-info.ts

@@ -0,0 +1,108 @@
+/**
+ * PdfAutomaticFieldInfo.ts class for EJ2-PDF
+ * @private
+ */
+import { PointF } from './../../drawing/pdf-drawing';
+import { PdfAutomaticField } from './automatic-field';
+/**
+ * Represents information about the automatic field.
+ * @private
+ */
+export class PdfAutomaticFieldInfo {
+    // Fields
+    /**
+     * Internal variable to store location of the field.
+     * @private
+     */
+    private pageNumberFieldLocation : PointF = new PointF();
+    /**
+     * Internal variable to store field.
+     * @private
+     */
+    private pageNumberField : PdfAutomaticField = null;
+    /**
+     * Internal variable to store x scaling factor.
+     * @private
+     */
+    private scaleX : number = 1;
+    /**
+     * Internal variable to store y scaling factor.
+     * @private
+     */
+    private scaleY : number = 1;
+    // Constructor
+    /**
+     * Initializes a new instance of the 'PdfAutomaticFieldInfo' class.
+     * @private
+     */
+    public constructor(field : PdfAutomaticFieldInfo)
+    /**
+     * Initializes a new instance of the 'PdfAutomaticFieldInfo' class.
+     * @private
+     */
+    public constructor(field : PdfAutomaticField, location : PointF)
+    /**
+     * Initializes a new instance of the 'PdfAutomaticFieldInfo' class.
+     * @private
+     */
+    /* tslint:disable */
+    public constructor(field : PdfAutomaticField, location : PointF, scaleX : number, scaleY : number)
+    public constructor(field : PdfAutomaticField | PdfAutomaticFieldInfo, location ?: PointF, scaleX ?: number, scaleY ?: number) {
+        if (typeof location === 'undefined' && field instanceof PdfAutomaticFieldInfo) {
+            this.pageNumberField = field.field;
+            this.pageNumberFieldLocation = field.location;
+            this.scaleX = field.scalingX;
+            this.scaleY = field.scalingY;
+        } else if (typeof scaleX === 'undefined' && location instanceof PointF && field instanceof PdfAutomaticField) {
+            this.pageNumberField = field;
+            this.pageNumberFieldLocation = location;
+        } else {
+            this.pageNumberField = field as PdfAutomaticField;
+            this.pageNumberFieldLocation = location;
+            this.scaleX = scaleX;
+            this.scaleY = scaleY;
+        }
+    }
+    /* tslint:enable */
+    // Properties
+    /**
+     * Gets or sets the location.
+     * @private
+     */
+    public get location() : PointF {
+        return this.pageNumberFieldLocation;
+    }
+    public set location(value : PointF) {
+        this.pageNumberFieldLocation = value;
+    }
+    /**
+     * Gets or sets the field.
+     * @private
+     */
+    public get field() : PdfAutomaticField {
+        return this.pageNumberField;
+    }
+    public set field(value : PdfAutomaticField) {
+        this.pageNumberField = value;
+    }
+    /**
+     * Gets or sets the scaling X factor.
+     * @private
+     */
+    public get scalingX() : number {
+        return this.scaleX;
+    }
+    public set scalingX(value : number) {
+        this.scaleX = value;
+    }
+    /**
+     * Gets or sets the scaling Y factor.
+     * @private
+     */
+    public get scalingY() : number {
+        return this.scaleY;
+    }
+    public set scalingY(value : number) {
+        this.scaleY = value;
+    }
+}

package/dist/ts/implementation/document/automatic-fields/automatic-field.ts

@@ -0,0 +1,127 @@
+/**
+ * PdfAutomaticField.ts class for EJ2-PDF
+ */
+import { RectangleF, SizeF, PointF } from './../../drawing/pdf-drawing';
+import { PdfFont } from './../../graphics/fonts/pdf-font';
+import { PdfBrush } from './../../graphics/brushes/pdf-brush';
+import { PdfSolidBrush } from './../../graphics/brushes/pdf-solid-brush';
+import { PdfStringFormat } from './../../graphics/fonts/pdf-string-format';
+import { PdfPen } from './../../graphics/pdf-pen';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+import { PdfColor } from './../../graphics/pdf-color';
+import { PdfDocument } from './../pdf-document';
+import { PdfGraphicsElement } from './../../graphics/figures/base/graphics-element';
+import { PdfAutomaticFieldInfo } from './automatic-field-info';
+import { PdfPage } from './../../pages/pdf-page';
+/**
+ * Represents a fields which is calculated before the document saves.
+ */
+export abstract class PdfAutomaticField extends PdfGraphicsElement {
+    // Fields
+    private internalBounds : RectangleF = new RectangleF(0, 0, 0, 0);
+    private internalFont : PdfFont;
+    private internalBrush : PdfBrush;
+    private internalPen : PdfPen;
+    private internalStringFormat : PdfStringFormat;
+    private internalTemplateSize : SizeF = new SizeF(0, 0);
+    // Constructors
+    protected constructor() {
+        super();
+    }
+    // Properties
+    public get bounds() : RectangleF {
+        return this.internalBounds;
+    }
+    public set bounds(value : RectangleF) {
+        this.internalBounds = value;
+    }
+    public get size() : SizeF {
+        return new SizeF(this.bounds.width, this.bounds.height);
+    }
+    public set size(value : SizeF) {
+        this.bounds.width = value.width;
+        this.bounds.height = value.height;
+    }
+    public get location() : PointF {
+        return new PointF(this.bounds.x, this.bounds.y);
+    }
+    public set location(value : PointF) {
+        this.bounds.x = value.x;
+        this.bounds.y = value.y;
+    }
+    public get font() : PdfFont {
+        return this.internalFont;
+    }
+    public set font(value : PdfFont) {
+        this.internalFont = value;
+    }
+    public get brush() : PdfBrush {
+        return this.internalBrush;
+    }
+    public set brush(value : PdfBrush) {
+        this.internalBrush = value;
+    }
+    public get pen() : PdfPen {
+        return this.internalPen;
+    }
+    public set pen(value : PdfPen) {
+        this.internalPen = value;
+    }
+    public get stringFormat() : PdfStringFormat {
+        return this.internalStringFormat;
+    }
+    public set stringFormat(value : PdfStringFormat) {
+        this.internalStringFormat = value;
+    }
+    // Implementation
+    public abstract getValue(graphics : PdfGraphics) : string;
+    public abstract performDraw(graphics : PdfGraphics, location : PointF, scalingX : number, scalingY : number) : void;
+    public performDrawHelper(graphics : PdfGraphics, location : PointF, scalingX : number, scalingY : number) : void {
+        if (this.bounds.height === 0 || this.bounds.width === 0) {
+            let text : string = this.getValue(graphics);
+            this.internalTemplateSize = this.getFont().measureString(text, this.size, this.stringFormat);
+        }
+    }
+    public draw(graphics : PdfGraphics) : void
+    public draw(graphics : PdfGraphics, location : PointF) : void
+    public draw(graphics : PdfGraphics, x : number, y : number) : void
+    public draw(arg1 ?: PdfGraphics, arg2 ?: number | PointF, arg3 ?: number) : void {
+        if (typeof arg2 === 'undefined') {
+            let location : PointF = new PointF(0, 0);
+            this.draw(arg1, location);
+        } else if (arg2 instanceof PointF) {
+            this.draw(arg1, arg2.x, arg2.y);
+        } else {
+            this.drawHelper(arg1, arg2, arg3);
+            let info : PdfAutomaticFieldInfo = new PdfAutomaticFieldInfo(this, new PointF(arg2, arg3));
+            arg1.automaticFields.add(info);
+        }
+    }
+    protected getSize() : SizeF {
+        if (this.bounds.height === 0 || this.bounds.width === 0) {
+            return this.internalTemplateSize;
+        } else {
+            return this.size;
+        }
+    }
+    protected drawInternal(graphics : PdfGraphics) : void {
+        //
+    }
+    /* tslint:disable */
+    protected getBrush() : PdfBrush {
+        return (typeof this.internalBrush === 'undefined' || this.internalBrush == null) ? new PdfSolidBrush(new PdfColor(0, 0, 0)) : this.internalBrush;
+    }
+    protected getFont() : PdfFont {
+        return (typeof this.internalFont === 'undefined' || this.internalFont == null) ? PdfDocument.defaultFont : this.internalFont;
+    }
+    /* tslint:enable */
+    public getPageFromGraphics(graphics : PdfGraphics) : PdfPage {
+        if (typeof graphics.page !== 'undefined' && graphics.page !== null) {
+            let page : PdfPage = graphics.page as PdfPage;
+            return page;
+        } else {
+            let page : PdfPage = graphics.currentPage as PdfPage;
+            return page;
+        }
+    }
+}

package/dist/ts/implementation/document/automatic-fields/composite-field.ts

@@ -0,0 +1,76 @@
+/**
+ * PdfCompositeField.ts class for EJ2-PDF
+ */
+import { PdfMultipleValueField } from './multiple-value-field';
+import { PdfAutomaticField } from './automatic-field';
+import { PdfFont } from './../../graphics/fonts/pdf-font';
+import { PdfBrush } from './../../graphics/brushes/pdf-brush';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+/**
+ * Represents class which can concatenate multiple automatic fields into single string.
+ */
+export class PdfCompositeField extends PdfMultipleValueField {
+    // Fields
+    /**
+     * Stores the array of automatic fields.
+     * @private
+     */
+    private internalAutomaticFields : PdfAutomaticField[] = null;
+    /**
+     * Stores the text value of the field.
+     * @private
+     */
+    private internalText : string = '';
+    // Constructor
+    /**
+     * Initialize a new instance of `PdfCompositeField` class.
+     * @param font Font of the field.
+     * @param brush Color of the field.
+     * @param text Content of the field.
+     * @param list List of the automatic fields in specific order based on the text content.
+     */
+    public constructor(font : PdfFont, brush : PdfBrush, text : string, ...list : PdfAutomaticField[]) {
+        super();
+        this.font = font;
+        this.brush = brush;
+        this.text = text;
+        this.automaticFields = list;
+    }
+    // Properties
+    /**
+     * Gets and sets the content of the field.
+     * @public
+     */
+    public get text() : string {
+        return this.internalText;
+    }
+    public set text(value : string) {
+        this.internalText = value;
+    }
+    /**
+     * Gets and sets the list of the field to drawn.
+     * @public
+     */
+    public get automaticFields() : PdfAutomaticField[] {
+        return this.internalAutomaticFields;
+    }
+    public set automaticFields(value : PdfAutomaticField[]) {
+        this.internalAutomaticFields = value;
+    }
+    // Implementation
+    /**
+     * Return the actual value generated from the list of automatic fields.
+     * @public
+     */
+    public getValue(graphics : PdfGraphics) : string {
+        let values : string[] = [];
+        let text : string = this.text.toString();
+        if (typeof this.automaticFields !== 'undefined' && this.automaticFields != null && this.automaticFields.length > 0) {
+            for (let i : number = 0; i < this.automaticFields.length; i++) {
+                let automaticField : PdfAutomaticField = this.automaticFields[i];
+                text = text.replace('{' + i + '}', automaticField.getValue(graphics));
+            }
+        }
+        return text;
+    }
+}

package/dist/ts/implementation/document/automatic-fields/multiple-value-field.ts

@@ -0,0 +1,37 @@
+/**
+ * PdfAutomaticField.ts class for EJ2-PDF
+ */
+import { PdfAutomaticField } from  './automatic-field';
+import { TemporaryDictionary } from './../../collections/object-object-pair/dictionary';
+import { PdfTemplateValuePair } from './pdf-template-value-pair';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+import { SizeF, PointF } from './../../drawing/pdf-drawing';
+import { PdfTemplate } from './../../graphics/figures/pdf-template';
+/**
+ * Represents automatic field which has the same value within the `PdfGraphics`.
+ */
+export abstract class PdfMultipleValueField extends PdfAutomaticField {
+    //  Fields
+    /**
+     * Stores the instance of dictionary values of `graphics and template value pair`.
+     * @private
+     */
+    private list : TemporaryDictionary<PdfGraphics, PdfTemplateValuePair> = new TemporaryDictionary<PdfGraphics, PdfTemplateValuePair>();
+    public constructor() {
+        super();
+    }
+    // Implementation
+    /* tslint:disable */
+    public performDraw(graphics : PdfGraphics, location : PointF, scalingX : number, scalingY : number) : void {
+        super.performDrawHelper(graphics, location, scalingX, scalingY);
+        let value : string = this.getValue(graphics);
+        let template : PdfTemplate = new PdfTemplate(this.getSize());
+        this.list.setValue(graphics, new PdfTemplateValuePair(template, value));
+        let g : PdfGraphics = template.graphics;
+        let size : SizeF = this.getSize();
+        template.graphics.drawString(value, this.getFont(), this.pen, this.getBrush(), 0, 0, size.width, size.height, this.stringFormat);
+        let drawLocation : PointF = new PointF(location.x + this.location.x, location.y + this.location.y);
+        graphics.drawPdfTemplate(template, drawLocation, new SizeF(template.width * scalingX, template.height * scalingY));
+    }
+    /* tslint:enable */
+}

package/dist/ts/implementation/document/automatic-fields/page-count-field.ts

@@ -0,0 +1,75 @@
+/**
+ * PdfPageCountField.ts class for EJ2-PDF
+ */
+import { PdfSingleValueField } from './single-value-field';
+import { PdfNumberStyle } from './../../pages/enum';
+import { PdfFont } from './../../graphics/fonts/pdf-font';
+import { PdfBrush } from './../../graphics/brushes/pdf-brush';
+import { RectangleF } from './../../drawing/pdf-drawing';
+import { PdfGraphics } from './../../graphics/pdf-graphics';
+import { PdfPage } from './../../pages/pdf-page';
+import { PdfDocument } from './../pdf-document';
+import { PdfNumbersConvertor } from './pdf-numbers-convertor';
+/**
+ * Represents total PDF document page count automatic field.
+ */
+export class PdfPageCountField extends PdfSingleValueField {
+    // Fields
+    /**
+     * Stores the number style of the field.
+     * @private
+     */
+    private  internalNumberStyle : PdfNumberStyle = PdfNumberStyle.Numeric;
+    // Constructors
+    /**
+     * Initialize a new instance for page number field.
+     * @public
+     */
+    public constructor(font : PdfFont)
+    /**
+     * Initialize a new instance for page number field.
+     * @public
+     */
+    public constructor(font : PdfFont, bounds : RectangleF)
+    /**
+     * Initialize a new instance for page number field.
+     * @public
+     */
+    public constructor(font : PdfFont, brush: PdfBrush)
+    public constructor(font : PdfFont, arg2 ?: RectangleF|PdfBrush) {
+        super();
+        if (typeof arg2 === 'undefined') {
+            this.font = font;
+        } else if ( arg2 instanceof PdfBrush) {
+            this.font = font;
+            this.brush = arg2;
+        } else {
+            this.font = font;
+            this.bounds = arg2;
+        }
+    }
+    // Properties
+    /**
+     * Gets and sets the number style of the field.
+     * @public
+     */
+    public get numberStyle() : PdfNumberStyle {
+        return this.internalNumberStyle;
+    }
+    public set numberStyle(value : PdfNumberStyle) {
+        this.internalNumberStyle = value;
+    }
+    // Implementation
+    /**
+     * Return the actual value of the content to drawn.
+     * @public
+     */
+    public getValue(graphics : PdfGraphics) : string {
+        let result : string = null;
+        let page : PdfPage = this.getPageFromGraphics(graphics);
+        let document : PdfDocument = page.section.parent.document;
+        let count : number = document.pages.count;
+        result = PdfNumbersConvertor.convert(count, this.numberStyle);
+        return result;
+    }
+}