@syncfusion/ej2-pdf-export 19.4.52 → 20.2.36

package/dist/ts/implementation/graphics/unit-convertor.ts

@@ -0,0 +1,96 @@
+/**
+ * PdfUnitConverter.ts class for EJ2-PDF
+ */
+import { PdfGraphicsUnit } from './../graphics/enum';
+/**
+ * Used to perform `convertion between pixels and points`.
+ * @private
+ */
+export class PdfUnitConverter {
+    //Fields
+    /**
+     * Indicates default `horizontal resolution`.
+     * @default 96
+     * @private
+     */
+    public static readonly horizontalResolution : number = 96;
+    /**
+     * Indicates default `vertical resolution`.
+     * @default 96
+     * @private
+     */
+    public static readonly verticalResolution: number = 96;
+    /**
+     * `Width, in millimeters`, of the physical screen.
+     * @private
+     */
+    public static readonly horizontalSize: number;
+    /**
+     * `Height, in millimeters`, of the physical screen.
+     * @private
+     */
+    public static readonly verticalSize: number;
+    /**
+     * `Width, in pixels`, of the screen.
+     * @private
+     */
+    public static readonly pxHorizontalResolution: number;
+    /**
+     * `Height, in pixels`, of the screen.
+     * @private
+     */
+    public static readonly pxVerticalResolution: number;
+    /**
+     * `Matrix` for conversations between different numeric systems.
+     * @private
+     */
+    private proportions : number[];
+    //constructors
+    /**
+     * Initializes a new instance of the `UnitConvertor` class with DPI value.
+     * @private
+     */
+    public constructor( dpi : number) {
+        this.updateProportionsHelper(dpi);
+    }
+    /**
+     * `Converts` the value, from one graphics unit to another graphics unit.
+     * @private
+     */
+    public convertUnits(value : number, from : PdfGraphicsUnit, to : PdfGraphicsUnit) : number {
+        return this.convertFromPixels(this.convertToPixels(value, from), to);
+    }
+    /**
+     * Converts the value `to pixel` from specified graphics unit.
+     * @private
+     */
+    public convertToPixels(value : number, from : PdfGraphicsUnit) : number {
+        let index : number = (from as number);
+        let result : number = (value * this.proportions[index]) as number;
+        return result;
+    }
+    /**
+     * Converts value, to specified graphics unit `from Pixel`.
+     * @private
+     */
+    public convertFromPixels(value : number, to : PdfGraphicsUnit) : number {
+        let index : number = to as number;
+        let result : number = (value / this.proportions[index]) as number;
+        return result;
+    }
+    /**
+     * `Update proportions` matrix according to Graphics settings.
+     * @private
+     */
+    private updateProportionsHelper(pixelPerInch : number) : void {
+        this.proportions = [
+            pixelPerInch / 2.54,  // Centimeter
+            pixelPerInch / 6.0,      // Pica
+            1,                     // Pixel
+            pixelPerInch / 72.0,     // Point
+            pixelPerInch,          // Inch
+            pixelPerInch / 300.0,    // Document
+            pixelPerInch / 25.4  // Millimeter
+        ];
+    }
+}

package/dist/ts/implementation/input-output/big-endian-writer.ts

@@ -0,0 +1,121 @@
+/**
+ * Writes data in BigEndian order.
+ */
+export class BigEndianWriter {
+    //Constants
+    /**
+     * Size of Int32 type.
+     */
+    public readonly int32Size : number = 4;
+    /**
+     * Size of Int16 type.
+     */
+    public readonly int16Size : number = 2;
+    /**
+     * Size of long type.
+     */
+    public readonly int64Size : number = 8;
+    //Fields    
+    /**
+     * Internal buffer.
+     */
+    private buffer : number[];
+    /**
+     * Internal buffer capacity.
+     */
+    private bufferLength : number;
+    /**
+     * Current position.
+     */
+    private internalPosition : number;
+    //Properties
+    /**
+     * Gets data written to the writer.
+     */
+    public get data() : number[] {
+        if (this.buffer.length < this.bufferLength) {
+            let length : number = this.bufferLength - this.buffer.length;
+            for (let i : number = 0; i < length; i++) {
+                this.buffer.push(0);
+            }
+        }
+        return this.buffer;
+    }
+    /// <summary>
+    /// Gets position of the internal buffer.
+    /// </summary>
+    public get position() : number {
+        if (this.internalPosition === undefined || this.internalPosition === null) {
+            this.internalPosition = 0;
+        }
+        return this.internalPosition;
+    }
+    //Constructors
+    /**
+     * Creates a new writer.
+     */
+    public constructor(capacity : number) {
+        this.bufferLength = capacity;
+        this.buffer = [];
+    }
+    /**
+     * Writes short value.
+     */
+    public writeShort(value : number) : void {
+        let bytes : number[] = [((value & 0x0000ff00) >> 8), value & 0x000000ff];
+        this.flush(bytes);
+    }
+    /**
+     * Writes int value.
+     */
+    public writeInt(value : number) : void {
+        let i1 : number = (value & 0xff000000) >> 24;
+        i1 = i1 < 0 ? 256 + i1 : i1;
+        let i2 : number = (value & 0x00ff0000) >> 16;
+        i2 = i2 < 0 ? 256 + i2 : i2;
+        let i3 : number = (value & 0x0000ff00) >> 8;
+        i3 = i3 < 0 ? 256 + i3 : i3;
+        let i4 : number = value & 0x000000ff;
+        i4 = i4 < 0 ? 256 + i4 : i4;
+        let bytes : number[] = [(value & 0xff000000) >> 24, (value & 0x00ff0000) >> 16, (value & 0x0000ff00) >> 8, value & 0x000000ff ];
+        this.flush(bytes);
+    }
+    /**
+     * Writes u int value.
+     */
+    public writeUInt(value : number) : void {
+        let buff : number[] = [(value & 0xff000000) >> 24, (value & 0x00ff0000) >> 16, (value & 0x0000ff00) >> 8, value & 0x000000ff ];
+        this.flush(buff);
+    }
+    /**
+     * Writes string value.
+     */
+    public writeString(value : string) : void {
+        if (value == null) {
+            throw new Error('Argument Null Exception : value');
+        }
+        let bytes : number[] = [];
+        for (let i : number = 0; i < value.length; i++) {
+            bytes.push(value.charCodeAt(i));
+        }
+        this.flush(bytes);
+    }
+    /**
+     * Writes byte[] value.
+     */
+    public writeBytes(value : number[]) : void {
+        this.flush(value);
+    }
+    // //Implementation
+    private flush(buff : number[]) : void {
+        if (buff === null) {
+            throw new Error('Argument Null Exception : buff');
+        }
+        let position : number = this.position;
+        for (let i : number = 0; i < buff.length; i++) {
+            this.buffer[position] = buff[i];
+            position++;
+        }
+        this.internalPosition += buff.length;
+    }
+}

package/dist/ts/implementation/input-output/cross-table.ts

@@ -0,0 +1,21 @@
+/**
+ * public Enum for `ObjectType`.
+ * @private
+ */
+export enum ObjectType {
+    /**
+     * Specifies the type of `Free`.
+     * @private
+     */
+    Free = 0,
+    /**
+     * Specifies the type of `Normal`.
+     * @private
+     */
+    Normal = 1,
+    /**
+     * Specifies the type of `Packed`.
+     * @private
+     */
+    Packed = 2
+}

package/dist/ts/implementation/input-output/enum.ts

@@ -0,0 +1,16 @@
+/**
+ * public Enum for `CompositeFontType`.
+ * @private
+ */
+export enum ObjectStatus {
+    /**
+     * Specifies the type of `None`.
+     * @private
+     */
+    None,
+    /**
+     * Specifies the type of `Registered`.
+     * @private
+     */
+    Registered
+}