@syncfusion/ej2-pdf-export 21.2.10 → 22.1.34

package/dist/ts/implementation/annotations/document-link-annotation.ts

@@ -0,0 +1,118 @@
+import { PdfLinkAnnotation } from './link-annotation';
+import { RectangleF } from './../drawing/pdf-drawing';
+import { PdfDestination } from './../general/pdf-destination';
+/**
+ * `PdfDocumentLinkAnnotation` class represents an annotation object with holds link on another location within a document.
+ * ```typescript
+ * // create a new PDF document
+ * let document : PdfDocument = new PdfDocument();
+ * // create new pages
+ * let page1 : PdfPage = document.pages.add();
+ * let page2 : PdfPage = document.pages.add();
+ * // create a new rectangle
+ * let bounds : RectangleF = new RectangleF({x : 10, y : 200}, {width : 300, height : 25});
+ * //
+ * // create a new document link annotation
+ * let documentLinkAnnotation : PdfDocumentLinkAnnotation = new PdfDocumentLinkAnnotation(bounds);
+ * // set the annotation text
+ * documentLinkAnnotation.text = 'Document link annotation';
+ * // set the destination
+ * documentLinkAnnotation.destination = new PdfDestination(page2);
+ * // set the documentlink annotation location
+ * documentLinkAnnotation.destination.location = new PointF(10, 0);
+ * // add this annotation to a new page
+ * page1.annotations.add(documentLinkAnnotation);
+ * //
+ * // save the document to disk
+ * document.save('output.pdf');
+ * // destroy the document
+ * document.destroy();
+ * ```
+ */
+export class PdfDocumentLinkAnnotation extends PdfLinkAnnotation {
+    // Fields
+    /**
+     * `Destination` of the annotation.
+     * @default null
+     * @private
+     */
+    private pdfDestination : PdfDestination = null;
+    // Properties
+    /**
+     * Gets or sets the `destination` of the annotation.
+     * ```typescript
+     * // create a new PDF document
+     * let document : PdfDocument = new PdfDocument();
+     * // create new pages
+     * let page1 : PdfPage = document.pages.add();
+     * let page2 : PdfPage = document.pages.add();
+     * // create a new rectangle
+     * let bounds : RectangleF = new RectangleF({x : 10, y : 200}, {width : 300, height : 25});
+     * //
+     * // create a new document link annotation
+     * let documentLinkAnnotation : PdfDocumentLinkAnnotation = new PdfDocumentLinkAnnotation(bounds);
+     * // set the annotation text
+     * documentLinkAnnotation.text = 'Document link annotation';
+     * // set the destination
+     * documentLinkAnnotation.destination = new PdfDestination(page2);
+     * // set the documentlink annotation location
+     * documentLinkAnnotation.destination.location = new PointF(10, 0);
+     * // add this annotation to a new page
+     * page1.annotations.add(documentLinkAnnotation);
+     * //
+     * // save the document to disk
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     * @default null
+     */
+    public get destination() : PdfDestination {
+        return this.pdfDestination;
+    }
+    public set destination(value : PdfDestination) {
+        // if (this.pdfDestination !== value) {
+        this.pdfDestination = value;
+        // }
+    }
+    // Constructors
+    /**
+     * Initializes new `PdfDocumentLinkAnnotation` instance with specified bounds.
+     * @private
+     */
+    public constructor(rectangle : RectangleF)
+    /**
+     * Initializes new `PdfDocumentLinkAnnotation` instance with specified bounds and destination.
+     * @private
+     */
+    public constructor(rectangle : RectangleF, destination : PdfDestination)
+    public constructor(rectangle : RectangleF, destination ?: PdfDestination) {
+        super(rectangle);
+        if (typeof destination !== 'undefined') {
+            this.destination = destination;
+        }
+    }
+    // Implementation
+    /**
+     * `Saves` annotation object.
+     * @private
+     */
+    public save() : void {
+        super.save();
+        if (this.pdfDestination != null) {
+            this.dictionary.items.setValue(this.dictionaryProperties.dest, this.pdfDestination.element);
+        }
+    }
+    /**
+     * `Clone` the document link annotation.
+     * @private
+     */
+    public clone() : PdfDocumentLinkAnnotation {
+        let annot : PdfDocumentLinkAnnotation = new PdfDocumentLinkAnnotation(this.bounds, this.destination);
+        annot.color = this.color;
+        annot.brush = this.brush;
+        annot.destination = this.destination;
+        annot.font = this.font;
+        return annot;
+    }
+}

package/dist/ts/implementation/annotations/link-annotation.ts

@@ -0,0 +1,32 @@
+import { PdfAnnotation } from './annotation';
+import { RectangleF } from './../drawing/pdf-drawing';
+import { PdfName } from './../primitives/pdf-name';
+/**
+ * `PdfLinkAnnotation` class represents the ink annotation class.
+ * @private
+ */
+export abstract class PdfLinkAnnotation extends PdfAnnotation {
+    // Constructors
+    /**
+     * Initializes new instance of `PdfLineAnnotation` class with specified points.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes new instance of `PdfLineAnnotation` class with set of points and annotation text.
+     * @private
+     */
+    public constructor(rectangle : RectangleF)
+    public constructor(rectangle ?: RectangleF) {
+        super(rectangle);
+    }
+    // Implementation
+    /**
+     * `Initializes` annotation object.
+     * @private
+     */
+    protected initialize() : void {
+        super.initialize();
+        this.dictionary.items.setValue(this.dictionaryProperties.subtype, new PdfName(this.dictionaryProperties.link));
+    }
+}

package/dist/ts/implementation/annotations/pdf-text-web-link.ts

@@ -0,0 +1,265 @@
+import { PdfPage } from './../pages/pdf-page';
+import { PdfGraphics } from './../graphics/pdf-graphics';
+import { PointF, RectangleF, SizeF } from './../drawing/pdf-drawing';
+import { PdfTextElement } from './../graphics/figures/text-element';
+import { PdfUriAnnotation } from './uri-annotation';
+import { PdfStringLayouter, PdfStringLayoutResult } from './../graphics/fonts/string-layouter';
+import { PdfFontStyle } from './../graphics/fonts/enum';
+import { PdfLayoutResult } from './../graphics/figures/base/element-layouter';
+import { PdfTextAlignment } from './../graphics/enum';
+import { PdfArray } from './../primitives/pdf-array';
+import { PdfNumber } from './../primitives/pdf-number';
+/**
+ * `PdfTextWebLink` class represents the class for text web link annotation.
+ * ```typescript
+ * // create a new PDF document.
+ * let document : PdfDocument = new PdfDocument();
+ * // add a page to the document.
+ * let page1 : PdfPage = document.pages.add();
+ * // create the font
+ * let font : PdfFont = new PdfStandardFont(PdfFontFamily.Helvetica, 12);
+ * //
+ * // create the Text Web Link
+ * let textLink : PdfTextWebLink = new PdfTextWebLink();
+ * // set the hyperlink
+ * textLink.url = 'http://www.google.com';
+ * // set the link text
+ * textLink.text = 'Google';
+ * // set the font
+ * textLink.font = font;
+ * // draw the hyperlink in PDF page
+ * textLink.draw(page1, new PointF(10, 40));
+ * //
+ * // save the document.
+ * document.save('output.pdf');
+ * // destroy the document
+ * document.destroy();
+ * ```
+ */
+export class PdfTextWebLink extends PdfTextElement {
+    // Fields
+    /**
+     * Internal variable to store `Url`.
+     * @default ''
+     * @private
+     */
+    private uniformResourceLocator : string = '';
+    /**
+     * Internal variable to store `Uri Annotation` object. 
+     * @default null
+     * @private
+     */
+    private uriAnnotation : PdfUriAnnotation = null;
+    /**
+     * Checks whether the drawTextWebLink method with `PointF` overload is called or not.
+     * If it set as true, then the start position of each lines excluding firest line is changed as (0, Y).
+     * @private
+     * @hidden
+     */
+    private recalculateBounds : boolean = false;
+    private defaultBorder : PdfArray = new PdfArray();
+    // Properties
+    /**
+     * Gets or sets the `Uri address`.
+     * ```typescript
+     * // create a new PDF document.
+     * let document : PdfDocument = new PdfDocument();
+     * // add a page to the document.
+     * let page1 : PdfPage = document.pages.add();
+     * // create the font
+     * let font : PdfFont = new PdfStandardFont(PdfFontFamily.Helvetica, 12);
+     * // create the Text Web Link
+     * let textLink : PdfTextWebLink = new PdfTextWebLink();
+     * //
+     * // set the hyperlink
+     * textLink.url = 'http://www.google.com';
+     * //
+     * // set the link text
+     * textLink.text = 'Google';
+     * // set the font
+     * textLink.font = font;
+     * // draw the hyperlink in PDF page
+     * textLink.draw(page1, new PointF(10, 40));
+     * // save the document.
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     */
+    public get url() : string {
+        return this.uniformResourceLocator;
+    }
+    public set url(value : string) {
+        if (value.length === 0) {
+            throw new Error('ArgumentException : Url - string can not be empty');
+        }
+        this.uniformResourceLocator = value;
+    }
+
+    // Constructors
+    /**
+     * Initializes a new instance of the `PdfTextWebLink` class.
+     * @private
+     */
+    public constructor() {
+        super();
+        for (let i : number = 0; i < 3; i++) {
+            this.defaultBorder.add(new PdfNumber(0));
+        }
+    }
+
+    // Implementation
+    /* tslint:disable */
+    /**
+     * `Draws` a Text Web Link on the Page with the specified location.
+     * @private
+     */
+    public draw(page : PdfPage, location : PointF) : PdfLayoutResult
+    /**
+     * `Draws` a Text Web Link on the Page with the specified bounds.
+     * @private
+     */
+    public draw(page : PdfPage, bounds : RectangleF) : PdfLayoutResult
+    /**
+     * `Draw` a Text Web Link on the Graphics with the specified location.
+     * @private
+     */
+    public draw(graphics : PdfGraphics, location : PointF) : PdfLayoutResult
+    /**
+     * `Draw` a Text Web Link on the Graphics with the specified bounds.
+     * @private
+     */
+    public draw(graphics : PdfGraphics, bounds : RectangleF) : PdfLayoutResult
+    public draw(arg1 : PdfGraphics|PdfPage, arg2 : PointF|RectangleF) : PdfLayoutResult {
+        if (arg1 instanceof PdfPage) {
+            let layout : PdfStringLayouter = new PdfStringLayouter();
+            let previousFontStyle : PdfFontStyle = this.font.style;
+            if (arg2 instanceof PointF) {
+                this.recalculateBounds = true;
+                this.font.style = PdfFontStyle.Underline;
+                let layoutResult : PdfStringLayoutResult = layout.layout(this.value, this.font, this.stringFormat, new SizeF((arg1.graphics.clientSize.width - arg2.x), 0), true, arg1.graphics.clientSize);
+                if (layoutResult.lines.length === 1) {
+                    let textSize : SizeF = this.font.measureString(this.value);
+                    let rect : RectangleF = new RectangleF(arg2, textSize);
+                    rect = this.calculateBounds(rect, textSize.width, arg1.graphics.clientSize.width, arg2.x);
+                    this.uriAnnotation = new PdfUriAnnotation(rect, this.url);
+                    this.uriAnnotation.dictionary.items.setValue('Border', this.defaultBorder);
+                    arg1.annotations.add(this.uriAnnotation);
+                    let result : PdfLayoutResult =  this.drawText(arg1, arg2);
+                    this.font.style = previousFontStyle;
+                    return result;
+                } else {
+                    let result : PdfLayoutResult =  this.drawMultipleLineWithPoint(layoutResult, arg1, arg2);
+                    this.font.style = previousFontStyle;
+                    return result;
+                }
+            } else {
+                let layoutResult : PdfStringLayoutResult = layout.layout(this.value, this.font, this.stringFormat, new SizeF((arg2 as RectangleF).width, 0), false, new SizeF(0, 0));
+                this.font.style = PdfFontStyle.Underline;
+                if (layoutResult.lines.length === 1) {
+                    let textSize : SizeF = this.font.measureString(this.value);
+                    let rect : RectangleF = new RectangleF(new PointF((arg2 as RectangleF).x, (arg2 as RectangleF).y), textSize);
+                    rect = this.calculateBounds(rect, textSize.width, (arg2 as RectangleF).width, (arg2 as RectangleF).x);
+                    this.uriAnnotation = new PdfUriAnnotation(rect, this.url);
+                    this.uriAnnotation.dictionary.items.setValue('Border', this.defaultBorder);
+                    arg1.annotations.add(this.uriAnnotation);
+                    let returnValue : PdfLayoutResult = this.drawText(arg1, arg2 as RectangleF);
+                    this.font.style = previousFontStyle;
+                    return returnValue;
+                } else {
+                    let returnValue : PdfLayoutResult = this.drawMultipleLineWithBounds(layoutResult, arg1, arg2 as RectangleF);
+                    this.font.style = previousFontStyle;
+                    return returnValue;
+                }
+            }
+        } else {
+            let page : PdfPage = new PdfPage();
+            page = arg1.page as PdfPage;
+            return this.draw(page, arg2);
+        }
+    }
+    /* tslint:enable */
+    //Private methods
+    /**
+     * Helper method `Draw` a Multiple Line Text Web Link on the Graphics with the specified location.
+     * @private
+     */
+    private drawMultipleLineWithPoint(result : PdfStringLayoutResult, page : PdfPage, location : PointF) : PdfLayoutResult {
+        let layoutResult : PdfLayoutResult;
+        for (let i : number = 0; i < result.layoutLines.length; i++) {
+            let size : SizeF = this.font.measureString(result.lines[i].text);
+            let bounds : RectangleF = new RectangleF(location, size);
+            if (i !== 0) {
+                bounds.x = 0;
+            }
+            this.text = result.lines[i].text;
+            if (bounds.y + size.height > page.graphics.clientSize.height) {
+                if (i !== 0) {
+                    page = page.graphics.getNextPage();
+                    bounds = new RectangleF(0, 0, page.graphics.clientSize.width, size.height);
+                    location.y = 0;
+                } else {
+                    break;
+                }
+            }
+            bounds = this.calculateBounds(bounds, size.width, page.graphics.clientSize.width, bounds.x);
+            this.uriAnnotation = new PdfUriAnnotation(bounds, this.url);
+            this.uriAnnotation.dictionary.items.setValue('Border', this.defaultBorder);
+            page.annotations.add(this.uriAnnotation);
+            if (i !== 0) {
+                layoutResult = this.drawText(page, new PointF(0, bounds.y));
+            } else {
+                layoutResult = this.drawText(page, bounds.x, bounds.y);
+            }
+            location.y += size.height;
+        }
+        return layoutResult;
+    }
+    /**
+     * Helper method `Draw` a Multiple Line Text Web Link on the Graphics with the specified bounds.
+     * @private
+     */
+    private drawMultipleLineWithBounds(result : PdfStringLayoutResult, page : PdfPage, bounds : RectangleF) : PdfLayoutResult {
+        let layoutResult : PdfLayoutResult;
+        for (let i : number = 0; i < result.layoutLines.length; i++) {
+            let size : SizeF = this.font.measureString(result.lines[i].text);
+            let internalBounds : RectangleF = new RectangleF(new PointF(bounds.x, bounds.y), size);
+            internalBounds = this.calculateBounds(internalBounds, size.width, bounds.width, bounds.x);
+            this.text = result.lines[i].text;
+            if (bounds.y + size.height > page.graphics.clientSize.height) {
+                if (i !== 0) {
+                    page = page.graphics.getNextPage();
+                    bounds = new RectangleF(bounds.x, 0, bounds.width, size.height);
+                    internalBounds.y = 0;
+                } else {
+                    break;
+                }
+            }
+            this.uriAnnotation = new PdfUriAnnotation(internalBounds, this.url);
+            this.uriAnnotation.dictionary.items.setValue('Border', this.defaultBorder);
+            page.annotations.add(this.uriAnnotation);
+            layoutResult = this.drawText(page, bounds);
+            bounds.y += size.height;
+        }
+        return layoutResult;
+    }
+    /* tslint:disable */
+    private calculateBounds(currentBounds : RectangleF, lineWidth : number, maximumWidth : number, startPosition : number) : RectangleF {
+        let shift : number = 0;
+        if (this.stringFormat != null && typeof this.stringFormat !== 'undefined' && this.stringFormat.alignment === PdfTextAlignment.Center) {
+            currentBounds.x = startPosition + (maximumWidth - lineWidth) / 2;
+            currentBounds.width = lineWidth;
+        } else if (this.stringFormat != null && typeof this.stringFormat !== 'undefined' && this.stringFormat.alignment === PdfTextAlignment.Right) {
+            currentBounds.x = startPosition + (maximumWidth - lineWidth);
+            currentBounds.width = lineWidth;
+        } else if (this.stringFormat != null && typeof this.stringFormat !== 'undefined' && this.stringFormat.alignment === PdfTextAlignment.Justify) {
+            currentBounds.x = startPosition;
+            currentBounds.width = maximumWidth;
+        } else {
+            currentBounds.width = startPosition;
+            currentBounds.width = lineWidth;
+        }
+        return currentBounds;
+    }
+    /* tslint:enable */
+}

package/dist/ts/implementation/annotations/uri-annotation.ts

@@ -0,0 +1,86 @@
+/**
+ * PdfUriAnnotation.ts class for EJ2-PDF
+ */
+import { PdfAction } from './../actions/action';
+import { RectangleF } from './../drawing/pdf-drawing';
+import { PdfActionLinkAnnotation } from './action-link-annotation';
+import { PdfName } from './../primitives/pdf-name';
+import { PdfUriAction } from './../actions/uri-action';
+import { IPdfPrimitive } from './../../interfaces/i-pdf-primitives';
+/**
+ * `PdfUriAnnotation` class represents the Uri annotation.
+ * @private
+ */
+export class PdfUriAnnotation extends PdfActionLinkAnnotation {
+    // Fields
+    /**
+     * Internal variable to store `acton` for the annotation.
+     * @private
+     */
+    private pdfUriAction : PdfUriAction;
+    /**
+     * Get `action` of the annotation.
+     * @private
+     */
+    public get uriAction() : PdfUriAction {
+        if (typeof this.pdfUriAction === 'undefined') {
+            this.pdfUriAction = new PdfUriAction();
+        }
+        return this.pdfUriAction;
+    }
+
+    // Properties
+    /**
+     * Gets or sets the `Uri` address.
+     * @private
+     */
+    public get uri() : string {
+        return this.uriAction.uri;
+    }
+    public set uri(value : string) {
+        if (this.uriAction.uri !== value) {
+            this.uriAction.uri = value;
+        }
+    }
+    /**
+     * Gets or sets the `action`.
+     * @private
+     */
+    public get action() : PdfAction {
+        return this.getSetAction() as PdfAction;
+    }
+    public set action(value : PdfAction) {
+        this.getSetAction(value);
+        this.uriAction.next = value;
+    }
+
+    // Constructors
+    /**
+     * Initializes a new instance of the `PdfUriAnnotation` class with specified bounds.
+     * @private
+     */
+    public constructor(rectangle : RectangleF)
+    /**
+     * Initializes a new instance of the `PdfUriAnnotation` class with specified bounds and URI.
+     * @private
+     */
+    public constructor(rectangle : RectangleF, uri : string)
+    public constructor(rectangle : RectangleF, uri ?: string) {
+        super(rectangle);
+        if (typeof uri !== 'undefined') {
+            this.uri = uri;
+        }
+    }
+
+    // Implementation
+    /**
+     * `Initializes` annotation object.
+     * @private
+     */
+    protected initialize() : void {
+        super.initialize();
+        this.dictionary.items.setValue(this.dictionaryProperties.subtype, new PdfName(this.dictionaryProperties.link));
+        let tempPrimitive : IPdfPrimitive = this.uriAction.element;
+        this.dictionary.items.setValue(this.dictionaryProperties.a, this.uriAction.element);
+    }
+}

package/dist/ts/implementation/collections/dictionary.ts

@@ -0,0 +1,150 @@
+/**
+ * Dictionary.ts class for EJ2-PDF
+ * @private
+ * @hidden
+ */
+import {defaultToString} from './utils';
+// Used internally by dictionary
+/**
+ * @private
+ * @hidden
+ */
+export interface IDictionaryPair<K, V> {
+    key: K;
+    value: V;
+}
+/**
+ * @private
+ * @hidden
+ */
+export class Dictionary<K, V>{
+    /**
+     * @private
+     * @hidden
+     */
+    protected table: { [key: string]: IDictionaryPair<K, V> };
+    //: [key: K] will not work since indices can only by strings in javascript and typescript enforces this.
+    /**
+     * @private
+     * @hidden
+     */
+    protected nElements: number;
+    /**
+     * @private
+     * @hidden
+     */
+    protected toStr: (key: K) => string;
+    /**
+     * @private
+     * @hidden
+     */
+    public constructor(toStringFunction?: (key: K) => string) {
+        this.table = {};
+        this.nElements = 0;
+        this.toStr = toStringFunction || defaultToString;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public getValue(key: K): V {
+        const pair: IDictionaryPair<K, V> = this.table['$' + this.toStr(key)];
+        if (typeof pair === 'undefined') {
+            return undefined;
+        }
+        return pair.value;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public setValue(key: K, value: V): V {
+        // if (typeof key === 'undefined' || typeof value === 'undefined') {
+        //     return undefined;
+        // }
+        let ret: V;
+        const k : string = '$' + this.toStr(key);
+        const previousElement: IDictionaryPair<K, V> = this.table[k];
+        // if (typeof previousElement === 'undefined') {
+        this.nElements++;
+        ret = undefined;
+        // }
+        this.table[k] = {
+            key: key,
+            value: value
+        };
+        return ret;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public remove(key: K): V {
+        const k : string = '$' + this.toStr(key);
+        const previousElement: IDictionaryPair<K, V> = this.table[k];
+        // if (typeof previousElement !== 'undefined') {
+        delete this.table[k];
+        this.nElements--;
+        return previousElement.value;
+        // }
+        // return undefined;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public keys(): K[] {
+        const keysArray: K[] = [];
+        let namesOfKeys : string[] = Object.keys(this.table);
+        for (let index1 : number = 0; index1 < namesOfKeys.length; index1++) {
+            // if (Object.prototype.hasOwnProperty.call(this.table, namesOfKeys[index1])) {
+            const pair1: IDictionaryPair<K, V> = this.table[namesOfKeys[index1]];
+            keysArray.push(pair1.key);
+            // }
+        }
+        return keysArray;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public values(): V[] {
+        const valuesArray: V[] = [];
+        let namesOfValues : string[] = Object.keys(this.table);
+        for (let index2 : number = 0; index2 < namesOfValues.length; index2++) {
+            // if (Object.prototype.hasOwnProperty.call(this.table, namesOfValues[index2])) {
+            const pair2: IDictionaryPair<K, V> = this.table[namesOfValues[index2]];
+            valuesArray.push(pair2.value);
+            // }
+        }
+        return valuesArray;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public containsKey(key: K): boolean {
+        let retutnValue : boolean = true;
+        if (typeof this.getValue(key) === 'undefined') {
+            retutnValue = true;
+        } else {
+            retutnValue = false;
+        }
+        return !retutnValue;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public clear() : void {
+        this.table = {};
+        this.nElements = 0;
+    }
+    /**
+     * @private
+     * @hidden
+     */
+    public size(): number {
+        return this.nElements;
+    }
+} // End of dictionary