@syncfusion/ej2-pdf-export 20.2.45 → 20.3.47

package/dist/ts/implementation/graphics/pdf-resources.ts

@@ -0,0 +1,300 @@
+/**
+ * PdfResources.ts class for EJ2-PDF
+ */
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { Dictionary } from './../collections/dictionary';
+import { TemporaryDictionary } from './../collections/object-object-pair/dictionary';
+import { PdfName } from './../primitives/pdf-name';
+import { PdfArray } from './../primitives/pdf-array';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { PdfDocument } from './../document/pdf-document';
+import { PdfReferenceHolder } from './../primitives/pdf-reference';
+import { PdfCrossTable } from './../input-output/pdf-cross-table';
+import { PdfFont } from './fonts/pdf-font';
+import { PdfTemplate } from './figures/pdf-template';
+import { PdfBrush } from './brushes/pdf-brush';
+import { PdfTransparency } from './pdf-transparency';
+import { PdfBitmap } from './../graphics/images/pdf-bitmap';
+import { PdfImage } from './../graphics/images/pdf-image';
+import { PdfStream } from './../primitives/pdf-stream';
+import { PdfGradientBrush } from './brushes/pdf-gradient-brush';
+import { PdfTilingBrush } from './brushes/pdf-tiling-brush';
+/**
+ * `PdfResources` class used to set resource contents like font, image.
+ * @private
+ */
+export class PdfResources extends PdfDictionary {
+    //Fields
+    /**
+     * Dictionary for the `objects names`.
+     * @private
+     */
+    private pdfNames : TemporaryDictionary<IPdfPrimitive, PdfName>;
+    /**
+     * Dictionary for the `properties names`.
+     * @private
+     */
+    private properties : PdfDictionary = new PdfDictionary();
+    /**
+     * `Font name`.
+     * @private
+     */
+    private fontName : string;
+    /**
+     * Stores instance of `parent document`.
+     * @private
+     */
+    private pdfDocument : PdfDocument;
+    //Constructors
+    /**
+     * Initializes a new instance of the `PdfResources` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `PdfResources` class.
+     * @private
+     */
+    public constructor(baseDictionary : PdfDictionary)
+    public constructor(baseDictionary ?: PdfDictionary) {
+        super(baseDictionary);
+    }
+    //Properties
+    /**
+     * Gets the `font names`.
+     * @private
+     */
+    private get names() : TemporaryDictionary<IPdfPrimitive, PdfName> {
+        return this.getNames();
+    }
+    /**
+     * Get or set the `page document`.
+     * @private
+     */
+    public get document() : PdfDocument {
+        return this.pdfDocument;
+    }
+    public set document(value : PdfDocument) {
+        this.pdfDocument = value;
+    }
+    //Public Methods
+    /**
+     * `Generates name` for the object and adds to the resource if the object is new.
+     * @private
+     */
+    public getName(obj : IPdfWrapper) : PdfName {
+        let primitive : IPdfPrimitive = obj.element;
+        let name : PdfName = null;
+        if (this.names.containsKey(primitive)) {
+                name = this.names.getValue(primitive);
+        }
+        // Object is new.
+        if (name == null) {
+            let sName : string = this.generateName();
+            name = new PdfName(sName);
+            this.names.setValue(primitive, name);
+            if (obj instanceof PdfFont) {
+                this.add(obj, name);
+            } else if (obj instanceof PdfTemplate) {
+                this.add(obj, name);
+            } else if (obj instanceof PdfGradientBrush || obj instanceof PdfTilingBrush) {
+                this.add(obj, name);
+            } else if (obj instanceof PdfTransparency) {
+                this.add(obj, name);
+            } else if (obj instanceof PdfImage || obj instanceof PdfBitmap) {
+                this.add(obj, name);
+            }
+        }
+        return name;
+    }
+    /**
+     * Gets `resource names` to font dictionaries.
+     * @private
+     */
+    public getNames() : TemporaryDictionary<IPdfPrimitive, PdfName> {
+        if (this.pdfNames == null) {
+            this.pdfNames = new TemporaryDictionary<IPdfPrimitive, PdfName>();
+        }
+        let fonts : IPdfPrimitive = this.items.getValue(this.dictionaryProperties.font);
+        if (fonts != null) {
+            let reference : PdfReferenceHolder = fonts as PdfReferenceHolder;
+            let dictionary : PdfDictionary = fonts as PdfDictionary;
+            dictionary = PdfCrossTable.dereference(fonts) as PdfDictionary;
+        }
+        return this.pdfNames;
+    }
+    /**
+     * Add `RequireProcedureSet` into procset array.
+     * @private
+     */
+    public requireProcedureSet(procedureSetName : string) : void {
+        if (procedureSetName == null) {
+            throw new Error('ArgumentNullException:procedureSetName');
+        }
+        let procSets : PdfArray = this.items.getValue(this.dictionaryProperties.procset) as PdfArray;
+        if (procSets == null) {
+            procSets = new PdfArray();
+            this.items.setValue(this.dictionaryProperties.procset, procSets);
+        }
+        let name : PdfName = new PdfName(procedureSetName);
+        if (!procSets.contains(name)) {
+            procSets.add(name);
+        }
+    }
+    //Helper Methods
+    /**
+     * `Remove font` from array.
+     * @private
+     */
+    public removeFont(name : string) : void {
+        let key : IPdfPrimitive = null;
+        let keys : IPdfPrimitive[] = this.pdfNames.keys();
+        for (let index : number = 0; index < this.pdfNames.size(); index++) {
+            if (this.pdfNames.getValue(keys[index]) === new PdfName(name)) {
+                key = keys[index];
+                break;
+            }
+        }
+        if (key != null) {
+            this.pdfNames.remove(key);
+        }
+    }
+    /**
+     * Generates `Unique string name`.
+     * @private
+     */
+    private generateName() : string {
+        let name : string = Guid.getNewGuidString();
+        return name;
+    }
+    /**
+     * `Adds object` to the resources.
+     * @private
+     */
+    public add(font : PdfFont, name : PdfName) : void
+    /**
+     * `Adds object` to the resources.
+     * @private
+     */
+    public add(template : PdfTemplate, name : PdfName) : void
+    /**
+     * `Adds object` to the resources.
+     * @private
+     */
+    public add(brush : PdfBrush, name : PdfName) : void
+    /**
+     * `Adds object` to the resources.
+     * @private
+     */
+    public add(transparency : PdfTransparency, name : PdfName) : void
+    /**
+     * `Adds object` to the resources.
+     * @private
+     */
+    public add(image : PdfImage|PdfBitmap, name : PdfName) : void
+    public add(arg1 : PdfFont|PdfTemplate|PdfTransparency|PdfBrush|PdfImage|PdfBitmap, arg2 : PdfName) : void {
+        if (arg1 instanceof PdfFont) {
+            let dictionary : PdfDictionary = null;
+            let fonts : IPdfPrimitive = this.items.getValue(this.dictionaryProperties.font);
+            if (fonts != null) {
+                let reference : PdfReferenceHolder = fonts as PdfReferenceHolder;
+                dictionary = fonts as PdfDictionary;
+                dictionary = fonts as PdfDictionary;
+            } else {
+                dictionary = new PdfDictionary();
+                this.items.setValue(this.dictionaryProperties.font, dictionary);
+            }
+            dictionary.items.setValue(arg2.value,  new PdfReferenceHolder((<IPdfWrapper>arg1).element));
+        } else if (arg1 instanceof PdfTemplate) {
+            let xobjects : PdfDictionary;
+            xobjects = this.items.getValue(this.dictionaryProperties.xObject) as PdfDictionary;
+            // Create fonts dictionary.
+            if (xobjects == null) {
+                xobjects = new PdfDictionary();
+                this.items.setValue(this.dictionaryProperties.xObject, xobjects);
+            }
+            xobjects.items.setValue(arg2.value, new PdfReferenceHolder((<IPdfWrapper>arg1).element));
+        } else if (arg1 instanceof PdfBrush) {
+            if (arg1 instanceof PdfGradientBrush || arg1 instanceof PdfTilingBrush) {
+                let savable : IPdfPrimitive = (arg1 as IPdfWrapper).element;
+                if (savable != null) {
+                    let pattern : PdfDictionary = this.items.getValue(this.dictionaryProperties.pattern) as PdfDictionary;
+                    // Create a new pattern dictionary.
+                    if (pattern == null) {
+                        pattern = new PdfDictionary();
+                        this.items.setValue(this.dictionaryProperties.pattern, pattern);
+                    }
+                    pattern.items.setValue(arg2.value, new PdfReferenceHolder(savable));
+                }
+            }
+        } else if (arg1 instanceof PdfTransparency) {
+            let savable : IPdfPrimitive = (arg1 as IPdfWrapper).element;
+            let transDic : PdfDictionary = null;
+            transDic = this.items.getValue(this.dictionaryProperties.extGState) as PdfDictionary;
+            // Create a new pattern dictionary.
+            if (transDic == null) {
+                transDic = new PdfDictionary();
+                this.items.setValue(this.dictionaryProperties.extGState, transDic);
+            }
+            transDic.items.setValue(arg2.value, new PdfReferenceHolder(savable));
+        } else {
+            /* tslint:disable */
+            let xobjects : PdfDictionary = this.Dictionary.items.getValue(this.dictionaryProperties.xObject) as PdfDictionary;
+            let parentXObjects : PdfDictionary;
+            if (typeof this.pdfDocument !== 'undefined') {
+                parentXObjects = ((this.pdfDocument.sections.element as PdfDictionary).items.getValue(this.dictionaryProperties.resources) as PdfDictionary).items.getValue(this.dictionaryProperties.xObject) as PdfDictionary;
+            }
+            let values : IPdfPrimitive[] = this.Dictionary.items.values();
+            let hasSameImageStream : boolean = false;
+            let oldReference : PdfReferenceHolder;
+            if ( typeof this.pdfDocument !== 'undefined' && (typeof parentXObjects === undefined || parentXObjects == null)) {
+                parentXObjects = new PdfDictionary();
+                ((this.pdfDocument.sections.element as PdfDictionary).items.getValue(this.dictionaryProperties.resources) as PdfDictionary).items.setValue(this.dictionaryProperties.xObject, parentXObjects);
+            } else if (typeof this.pdfDocument !== 'undefined') {
+                let values : IPdfPrimitive[] = parentXObjects.items.values();
+                for (let i : number = 0; i < values.length; i++) {
+                    if (typeof (values[i] as PdfReferenceHolder) !== 'undefined' && typeof ((values[i] as PdfReferenceHolder).element as PdfStream) !== 'undefined') {
+                        if (((values[i] as PdfReferenceHolder).element as PdfStream).data[0] === (arg1.element as PdfStream).data[0]) {
+                            oldReference = values[i] as PdfReferenceHolder;
+                            hasSameImageStream = true;
+                        }
+                    }
+                }
+            }
+            if (xobjects == null) {
+                xobjects = new PdfDictionary();
+                this.Dictionary.items.setValue(this.dictionaryProperties.xObject, xobjects);
+            }
+            if (hasSameImageStream && typeof oldReference !== 'undefined') {
+                xobjects.items.setValue(arg2.value, oldReference);
+            } else {
+                let reference : PdfReferenceHolder = new PdfReferenceHolder((arg1 as IPdfWrapper).element);
+                xobjects.items.setValue(arg2.value, reference);
+                if ( typeof this.pdfDocument !== 'undefined' ) {
+                    parentXObjects.items.setValue(arg2.value, reference);
+                }
+            }
+            /* tslint:enable */
+        }
+    }
+}
+/* tslint:disable */
+/**
+ * Used to create new guid for resources.
+ * @private
+ */
+export class Guid {
+    /**
+     * Generate `new GUID`.
+     * @private
+     */
+    public static getNewGuidString() : string {
+        return 'aaaaaaaa-aaaa-4aaa-baaa-aaaaaaaaaaaa'.replace(/[ab]/g, (c : string) => {
+            let random : number = Math.random() * 16 | 0;
+            let result : number = c === 'a' ? random : (random & 0x3 | 0x8);
+            return result.toString(16);
+          });
+    }
+}
+/* tslint:enable */

package/dist/ts/implementation/graphics/pdf-transformation-matrix.ts

@@ -0,0 +1,246 @@
+/**
+ * PdfTransformationMatrix.ts class for EJ2-PDF
+ */
+import { PointF } from './../drawing/pdf-drawing';
+import { PdfNumber } from './../primitives/pdf-number';
+/**
+ * Class for representing Root `transformation matrix`.
+ */
+export class PdfTransformationMatrix {
+    // Constants
+    /**
+     * Value for `angle converting`.
+     * @default Math.PI / 180.0
+     * @private
+     */
+    private static readonly degRadFactor : number = Math.PI / 180.0;
+    /**
+     * Value for `angle converting`.
+     * @default 180.0 / Math.PI
+     * @private
+     */
+    private readonly radDegFactor : number = 180.0 / Math.PI;
+    // Fields
+    /**
+     * `Transformation matrix`.
+     * @private
+     */
+    private transformationMatrix : Matrix;
+
+    // Properties
+    /**
+     * Gets or sets the `internal matrix object`.
+     * @private
+     */
+    public get matrix() : Matrix {
+        return this.transformationMatrix;
+    }
+    public set matrix(value : Matrix) {
+        this.transformationMatrix = value;
+    }
+    // Constructors
+    /**
+     * Initializes object of `PdfTransformationMatrix` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes object of `PdfTransformationMatrix` class.
+     * @private
+     */
+    public constructor(value : boolean)
+    public constructor(value ? : boolean) {
+        if (typeof value === 'undefined') {
+            this.transformationMatrix = new Matrix(1.00, 0.00, 0.00, 1.00, 0.00, 0.00);
+        } else {
+            this.transformationMatrix = new Matrix(1.00, 0.00, 0.00, -1.00, 0.00, 0.00);
+        }
+    }
+    // Public methods
+    /**
+     * `Translates` coordinates by specified coordinates.
+     * @private
+     */
+    public translate(offsetX : number, offsetY : number) : void {
+        this.transformationMatrix.translate(offsetX, offsetY);
+    }
+    /**
+     * `Scales` coordinates by specified coordinates.
+     * @private
+     */
+    public scale(scaleX : number, scaleY : number) : void {
+        this.transformationMatrix.elements[0] = scaleX;
+        this.transformationMatrix.elements[3] = scaleY;
+    }
+    /**
+     * `Rotates` coordinate system in counterclockwise direction.
+     * @private
+     */
+    public rotate(angle : number) : void {
+        //Convert from degree to radian 
+        angle = (angle * Math.PI) / 180;
+        //Rotation 
+        this.transformationMatrix.elements[0] = Math.cos(angle);
+        this.transformationMatrix.elements[1] = Math.sin(angle);
+        this.transformationMatrix.elements[2] = -Math.sin(angle);
+        this.transformationMatrix.elements[3] = Math.cos(angle);
+    }
+    // Overrides
+    /**
+     * Gets `PDF representation`.
+     * @private
+     */
+    public toString() : string {
+        let builder : string = '';
+        let whitespace : string = ' ';
+        for (let i : number = 0, len : number = this.transformationMatrix.elements.length; i < len; i++) {
+            let temp : number = this.matrix.elements[i];
+            builder += PdfNumber.floatToString(this.transformationMatrix.elements[i]);
+            builder += whitespace;
+        }
+        return builder;
+    }
+    // Implementation
+    /**
+     * `Multiplies` matrices (changes coordinate system.)
+     * @private
+     */
+    public multiply(matrix : PdfTransformationMatrix) : void {
+        this.transformationMatrix.multiply(matrix.matrix);
+    }
+    /**
+     * Converts `degrees to radians`.
+     * @private
+     */
+    public static degreesToRadians(degreesX : number) : number {
+        return this.degRadFactor * degreesX;
+    }
+    /**
+     * Converts `radians to degrees`.
+     * @private
+     */
+    public radiansToDegrees(radians : number) : number {
+        return this.radDegFactor * radians;
+    }
+    /**
+     * `Clones` this instance of PdfTransformationMatrix.
+     * @private
+     */
+    public clone() : PdfTransformationMatrix {
+        return this;
+    }
+}
+export class Matrix {
+    //Fields
+    /**
+     * `elements` in the matrix.
+     * @private
+     */
+    private metrixElements : number[];
+    // Constructor
+    /**
+     * Initializes a new instance of the `Matrix` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `Matrix` class with number array.
+     * @private
+     */
+    public constructor(elements : number[])
+    /**
+     * Initializes a new instance of the `Matrix` class.
+     * @private
+     */
+    public constructor(m11 : number, m12 : number, m21 : number, m22 : number, dx : number, dy : number)
+    public constructor(arg1 ?: number|number[], arg2 ?: number, arg3 ?: number, arg4 ?: number, arg5 ?: number, arg6 ?: number) {
+        if (typeof arg1 === 'undefined') {
+            this.metrixElements = [];
+        } else if (typeof arg1 === 'number') {
+            this.metrixElements = [];
+            this.metrixElements.push(arg1);
+            this.metrixElements.push(arg2);
+            this.metrixElements.push(arg3);
+            this.metrixElements.push(arg4);
+            this.metrixElements.push(arg5);
+            this.metrixElements.push(arg6);
+        } else {
+            this.metrixElements = arg1;
+        }
+    }
+    // Properties
+    /**
+     * Gets the `elements`.
+     * @private
+     */
+    public get elements() : number[] {
+        return this.metrixElements;
+    }
+    /**
+     * Gets the off set `X`.
+     * @private
+     */
+    public get offsetX() : number {
+        return this.metrixElements[4];
+    }
+    /**
+     * Gets the off set `Y`.
+     * @private
+     */
+    public get offsetY() : number {
+        return this.metrixElements[5];
+    }
+    // Implementation
+    /**
+     * `Translates` coordinates by specified coordinates.
+     * @private
+     */
+    public translate(offsetX : number, offsetY : number) : void {
+        this.metrixElements[4] = offsetX;
+        this.metrixElements[5] = offsetY;
+    }
+    /**
+     * `Translates` the specified offset X.
+     * @private
+     */
+    public transform(point : PointF) : PointF {
+        let x : number = point.x;
+        let y : number = point.y;
+        let x2 : number = x * this.elements[0] + y * this.elements[2] + this.offsetX;
+        let y2 : number = x * this.elements[1] + y * this.elements[3] + this.offsetY;
+        return new PointF(x2, y2);
+    }
+    /**
+     * `Multiplies matrices` (changes coordinate system.)
+     * @private
+     */
+    public multiply(matrix : Matrix) : void {
+        let tempMatrix : number[] = [];
+        tempMatrix.push(this.elements[0] * matrix.elements[0] + this.elements[1] * matrix.elements[2]);
+        tempMatrix[1] = (this.elements[0] * matrix.elements[1] + this.elements[1] * matrix.elements[3]);
+        tempMatrix[2] = (this.elements[2] * matrix.elements[0] + this.elements[3] * matrix.elements[2]);
+        tempMatrix[3] = (this.elements[2] * matrix.elements[1] + this.elements[3] * matrix.elements[3]);
+        tempMatrix[4] = (this.offsetX * matrix.elements[0] + this.offsetY * matrix.elements[2] + matrix.offsetX);
+        tempMatrix[5] = (this.offsetX * matrix.elements[1] + this.offsetY * matrix.elements[3] + matrix.offsetY);
+        for (let i : number = 0; i < tempMatrix.length; i++) {
+            this.elements[i] = tempMatrix[i];
+        }
+    }
+    // IDisposable Members
+    /**
+     * `Dispose` this instance of PdfTransformationMatrix class.
+     * @private
+     */
+    public dispose() : void {
+        this.metrixElements = null;
+    }
+    // ICloneable Members
+    /**
+     * `Clones` this instance of PdfTransformationMatrix class.
+     * @private
+     */
+    public clone() : Object {
+        let m : Matrix = new Matrix(this.metrixElements);
+        return m;
+    }
+}

package/dist/ts/implementation/graphics/pdf-transparency.ts

@@ -0,0 +1,93 @@
+/**
+ * PdfTransparency.ts class for EJ2-PDF
+ */
+import { IPdfWrapper } from './../../interfaces/i-pdf-wrapper';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+import { PdfDictionary } from './../primitives/pdf-dictionary';
+import { PdfBlendMode } from './../graphics/enum';
+import { PdfNumber } from './../primitives/pdf-number';
+import { PdfName } from './../primitives/pdf-name';
+import { DictionaryProperties } from './../input-output/pdf-dictionary-properties';
+/**
+ * Represents a simple `transparency`.
+ * @private
+ */
+export class PdfTransparency implements IPdfWrapper {
+    // Fields
+    /**
+     * Internal variable to store `dictionary`.
+     * @default new PdfDictionary()
+     * @private
+     */
+    private dictionary : PdfDictionary = new PdfDictionary();
+    /**
+     * Internal variable for accessing fields from `DictionryProperties` class.
+     * @default new DictionaryProperties()
+     * @private
+     */
+    private dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    // Properties
+    // /**
+    //  * Gets the `stroke` operation alpha value.
+    //  * @private
+    //  */
+    // public get stroke() : number {
+    //     let result : number = this.getNumber(this.dictionaryProperties.CA);
+    //     return result;
+    // }
+    // /**
+    //  * Gets the `fill` operation alpha value.
+    //  * @private
+    //  */
+    // public get fill() : number {
+    //     let result : number = this.getNumber(this.dictionaryProperties.ca);
+    //     return result;
+    // }
+    // /**
+    //  * Gets the `blend mode`.
+    //  * @private
+    //  */
+    // public get mode() : PdfBlendMode {
+    //     let result : string = this.getName(this.dictionaryProperties.ca);
+    //     return PdfBlendMode.Normal;
+    // }
+    // Constructors
+    /**
+     * Initializes a new instance of the `Transparency` class.
+     * @private
+     */
+    public constructor(stroke : number, fill : number, mode : PdfBlendMode) {
+        this.dictionary.items.setValue(this.dictionaryProperties.CA, new PdfNumber(stroke));
+        this.dictionary.items.setValue(this.dictionaryProperties.ca, new PdfNumber(fill));
+        this.dictionary.items.setValue(this.dictionaryProperties.BM, new PdfName(mode.toString()));
+    }
+    // // Implementation
+    // /**
+    //  * Gets the `number value`.
+    //  * @private
+    //  */
+    // private getNumber(keyName : string) : number {
+    //     let result : number = 0.0;
+    //     let numb : PdfNumber = this.dictionary.items.getValue(keyName) as PdfNumber;
+    //     result = numb.intValue;
+    //     return result;
+    // }
+    // /**
+    //  * Gets the `name value`.
+    //  * @private
+    //  */
+    // private getName(keyName : string) : string {
+    //     let result : string = null;
+    //     let name : PdfName = this.dictionary.items.getValue(keyName) as PdfName;
+    //     result = name.value;
+    //     return result;
+    // }
+    // IPdfWrapper Members
+    /**
+     * Gets the `element`.
+     * @private
+     */
+    public get element() : IPdfPrimitive {
+        return this.dictionary;
+    }
+}