@syncfusion/ej2-pdf-export 25.2.3 → 26.1.35

package/dist/ts/implementation/graphics/figures/base/pdf-shape-element.d.ts

@@ -0,0 +1,40 @@
+/**
+ * PdfShapeElement.ts class for EJ2-PDF
+ * @private
+ */
+import { PdfLayoutResult, PdfLayoutParams } from './element-layouter';
+import { RectangleF, PointF } from './../../../drawing/pdf-drawing';
+import { PdfLayoutElement } from './../layout-element';
+import { PdfGraphics } from './../../pdf-graphics';
+/**
+ * Base class for the main shapes.
+ * @private
+ */
+export declare abstract class PdfShapeElement extends PdfLayoutElement {
+    /**
+     * Gets the bounds.
+     * @private
+     */
+    getBounds(): RectangleF;
+    /**
+     * `drawGraphicsHelper` the graphics.
+     * @public
+     */
+    drawGraphicsHelper(graphics: PdfGraphics, location: PointF): void;
+    /**
+     * `drawShapeHelper` the graphics.
+     * @private
+     */
+    private drawShapeHelper;
+    protected abstract drawInternal(graphics: PdfGraphics): void;
+    /**
+     * Returns a rectangle that bounds this element.
+     * @private
+     */
+    protected abstract getBoundsInternal(): RectangleF;
+    /**
+     * Layouts the element.
+     * @private
+     */
+    protected layout(param: PdfLayoutParams): PdfLayoutResult;
+}

package/dist/ts/implementation/graphics/figures/base/pdf-shape-element.ts

@@ -0,0 +1,69 @@
+/**
+ * PdfShapeElement.ts class for EJ2-PDF
+ * @private
+ */
+import { PdfLayoutResult, PdfLayoutParams } from './element-layouter';
+import { RectangleF, PointF } from './../../../drawing/pdf-drawing';
+import { PdfLayoutElement } from './../layout-element';
+import { ShapeLayouter } from './shape-layouter';
+import { PdfGraphics, PdfGraphicsState } from './../../pdf-graphics';
+/**
+ * Base class for the main shapes.
+ * @private
+ */
+export abstract class PdfShapeElement extends PdfLayoutElement {
+    // methods
+    /**
+     * Gets the bounds.
+     * @private
+     */
+    public getBounds() : RectangleF {
+        let rect : RectangleF = this.getBoundsInternal();
+        return rect;
+    }
+    /**
+     * `drawGraphicsHelper` the graphics.
+     * @public
+     */
+    public drawGraphicsHelper(graphics: PdfGraphics, location: PointF) : void {
+        if ((graphics == null)) {
+            throw new Error('ArgumentNullException :graphics');
+        }
+        this.drawShapeHelper(graphics, location.x, location.y);
+    }
+    /**
+     * `drawShapeHelper` the graphics.
+     * @private
+     */
+    private drawShapeHelper(graphics : PdfGraphics, x : number, y : number) : void {
+        let bNeedSave : boolean = (x !== 0.5 || y !== 0.5);
+        let gState : PdfGraphicsState = null;
+        // Translate co-ordinates.
+        if (bNeedSave) {
+            // Save state.
+            gState = graphics.save();
+            graphics.translateTransform((x as number), y);
+        }
+        this.drawInternal(graphics);
+        if (bNeedSave) {
+            // Restore state.
+            graphics.restore(gState);
+        }
+    }
+    // Implementation
+    protected abstract drawInternal(graphics : PdfGraphics) : void;
+    /**
+     * Returns a rectangle that bounds this element.
+     * @private
+     */
+    protected abstract getBoundsInternal() : RectangleF;
+    /**
+     * Layouts the element.
+     * @private
+     */
+    protected layout(param : PdfLayoutParams) : PdfLayoutResult {
+        let layouter : ShapeLayouter = new ShapeLayouter(this);
+        let result : PdfLayoutResult = layouter.layout(param);
+        return result;
+    }
+}

package/dist/ts/implementation/graphics/figures/base/shape-layouter.d.ts

@@ -0,0 +1,131 @@
+/**
+ * ShapeLayouter.ts class for EJ2-PDF
+ * @private
+ */
+import { ElementLayouter, PdfLayoutResult, PdfLayoutParams } from './element-layouter';
+import { RectangleF } from './../../../drawing/pdf-drawing';
+import { PdfPage } from './../../../pages/pdf-page';
+import { PdfShapeElement } from './pdf-shape-element';
+/**
+ * ShapeLayouter class.
+ * @private
+ */
+export declare class ShapeLayouter extends ElementLayouter {
+    /**
+     * Initializes the object to store `older form elements` of previous page.
+     * @default 0
+     * @private
+     */
+    olderPdfForm: number;
+    /**
+     * Initializes the offset `index`.
+     * * @default 0
+     * @private
+     */
+    private static index;
+    /**
+     * Initializes the `difference in page height`.
+     * * @default 0
+     * @private
+     */
+    private static splitDiff;
+    /**
+     * Determines the `end of Vertical offset` values.
+     * * @default false
+     * @private
+     */
+    private static last;
+    /**
+     * Determines the document link annotation `border width`.
+     * * @default 0
+     * @private
+     */
+    private static readonly borderWidth;
+    /**
+     * Checks weather `is pdf grid` or not.
+     * @private
+     */
+    isPdfGrid: boolean;
+    /**
+     * The `bounds` of the shape element.
+     * * @default new RectangleF()
+     * @private
+     */
+    shapeBounds: RectangleF;
+    /**
+     * The `bottom cell padding`.
+     * @private
+     */
+    bottomCellPadding: number;
+    /**
+     * Total Page size of the web page.
+     * * @default 0
+     * @private
+     */
+    private totalPageSize;
+    /**
+     * Initializes a new instance of the `ShapeLayouter` class.
+     * @private
+     */
+    constructor(element: PdfShapeElement);
+    /**
+     * Gets shape element.
+     * @private
+     */
+    readonly element: PdfShapeElement;
+    /**
+     * Layouts the element.
+     * @private
+     */
+    protected layoutInternal(param: PdfLayoutParams): PdfLayoutResult;
+    /**
+     * Raises BeforePageLayout event.
+     * @private
+     */
+    private raiseBeforePageLayout;
+    /**
+     * Raises PageLayout event if needed.
+     * @private
+     */
+    private raiseEndPageLayout;
+    /**
+     * Creates layout result.
+     * @private
+     */
+    private getLayoutResult;
+    /**
+     * Calculates the next active shape bounds.
+     * @private
+     */
+    private getNextShapeBounds;
+    /**
+     * Layouts the element on the current page.
+     * @private
+     */
+    private layoutOnPage;
+    /**
+     * Returns Rectangle for element drawing on the page.
+     * @private
+     */
+    private getDrawBounds;
+    /**
+     * Draws the shape.
+     * @private
+     */
+    private drawShape;
+    /**
+     * Corrects current bounds on the page.
+     * @protected
+     */
+    protected checkCorrectCurrentBounds(currentPage: PdfPage, curBounds: RectangleF, param: PdfLayoutParams): RectangleF;
+    /**
+     * Calculates bounds where the shape was layout on the page.
+     * @private
+     */
+    private getPageResultBounds;
+    /**
+     * Checks whether shape rectangle fits to the lay outing bounds.
+     * @private
+     */
+    private fitsToBounds;
+}

package/dist/ts/implementation/graphics/figures/base/shape-layouter.ts

@@ -0,0 +1,276 @@
+/**
+ * ShapeLayouter.ts class for EJ2-PDF
+ * @private
+ */
+import { ElementLayouter, PdfLayoutResult, PdfLayoutParams } from './element-layouter';
+import { RectangleF, SizeF, PointF } from './../../../drawing/pdf-drawing';
+import { PdfPage } from './../../../pages/pdf-page';
+import { PdfShapeElement } from './pdf-shape-element';
+import { PdfLayoutBreakType, PdfLayoutType } from './../../figures/enum';
+import { BeginPageLayoutEventArgs, EndPageLayoutEventArgs } from './../../../structured-elements/grid/layout/grid-layouter';
+import { PdfGraphics, PdfGraphicsState } from './../../pdf-graphics';
+/**
+ * ShapeLayouter class.
+ * @private
+ */
+export class ShapeLayouter extends ElementLayouter {
+    // Fields
+    /**
+     * Initializes the object to store `older form elements` of previous page.
+     * @default 0
+     * @private
+     */
+    public olderPdfForm : number = 0;
+    /**
+     * Initializes the offset `index`.
+     * * @default 0
+     * @private
+     */
+    private static index : number = 0;
+    /**
+     * Initializes the `difference in page height`.
+     * * @default 0
+     * @private
+     */
+    private static splitDiff : number = 0;
+    /**
+     * Determines the `end of Vertical offset` values.
+     * * @default false
+     * @private
+     */
+    private static last : boolean = false;
+    /**
+     * Determines the document link annotation `border width`.
+     * * @default 0
+     * @private
+     */
+    private static readonly borderWidth : number = 0;
+    /**
+     * Checks weather `is pdf grid` or not.
+     * @private
+     */
+    public isPdfGrid : boolean;
+    /**
+     * The `bounds` of the shape element.
+     * * @default new RectangleF()
+     * @private
+     */
+    public shapeBounds : RectangleF = new RectangleF();
+    /**
+     * The `bottom cell padding`.
+     * @private
+     */
+    public bottomCellPadding : number;
+    /**
+     * Total Page size of the web page.
+     * * @default 0
+     * @private
+     */
+    private totalPageSize : number = 0;
+
+    // Constructors
+    /**
+     * Initializes a new instance of the `ShapeLayouter` class.
+     * @private
+     */
+    public constructor(element : PdfShapeElement) {
+        super(element);
+    }
+    // Properties
+    /**
+     * Gets shape element.
+     * @private
+     */
+    public get element() : PdfShapeElement {
+        return (this.elements as PdfShapeElement);
+    }
+    // Implementation
+    /**
+     * Layouts the element.
+     * @private
+     */
+    protected layoutInternal(param : PdfLayoutParams) : PdfLayoutResult {
+        let currentPage : PdfPage = param.page;
+        let currentBounds : RectangleF = param.bounds;
+        let shapeLayoutBounds : RectangleF = this.element.getBounds();
+        shapeLayoutBounds.x = 0;
+        shapeLayoutBounds.y = 0;
+        /* tslint:disable */
+        let isEmpty : boolean = (this.shapeBounds.x === this.shapeBounds.y && this.shapeBounds.y === this.shapeBounds.width && this.shapeBounds.width === this.shapeBounds.height && this.shapeBounds.height === 0) ? true : false;
+        /* tslint:enable */
+        if ((this.isPdfGrid) && (!(isEmpty))) {
+            shapeLayoutBounds = this.shapeBounds;
+        }
+        let result : PdfLayoutResult = null;
+        let pageResult : ShapeLayoutResult = new ShapeLayoutResult();
+        pageResult.page = currentPage;
+        /*tslint:disable:no-constant-condition */
+        while (true) {
+            // Raise event.
+            let result1 : { currentBounds: RectangleF, cancel : boolean } = this.raiseBeforePageLayout(currentPage, currentBounds);
+            currentBounds = result1.currentBounds;
+            let endArgs : EndPageLayoutEventArgs = null;
+            if (!result1.cancel) {
+                pageResult = this.layoutOnPage(currentPage, currentBounds, shapeLayoutBounds, param);
+                // Raise event.
+                endArgs = this.raiseEndPageLayout(pageResult);
+                result1.cancel = (endArgs === null) ? false : endArgs.cancel;
+            }
+            if (!pageResult.end && !result1.cancel) {
+                currentBounds = this.getPaginateBounds(param);
+                shapeLayoutBounds = this.getNextShapeBounds(shapeLayoutBounds, pageResult);
+                currentPage = (endArgs === null || endArgs.nextPage === null) ?
+                    this.getNextPage(currentPage) : endArgs.nextPage;
+                if (this.isPdfGrid) {
+                    result = this.getLayoutResult(pageResult);
+                    break;
+                }
+            } else {
+                result = this.getLayoutResult(pageResult);
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Raises BeforePageLayout event.
+     * @private
+     */
+    private raiseBeforePageLayout(currentPage: PdfPage, currentBounds: RectangleF): { currentBounds : RectangleF, cancel : boolean } {
+        let cancel: boolean = false;
+        if (this.element.raiseBeginPageLayout) {
+            let args: BeginPageLayoutEventArgs = new BeginPageLayoutEventArgs(currentBounds, currentPage);
+            this.element.onBeginPageLayout(args);
+            cancel = args.cancel;
+            currentBounds = args.bounds;
+        }
+        return { currentBounds : currentBounds, cancel : cancel};
+    }
+    /**
+     * Raises PageLayout event if needed.
+     * @private
+     */
+    private raiseEndPageLayout(pageResult: ShapeLayoutResult): EndPageLayoutEventArgs {
+        let args: EndPageLayoutEventArgs = null;
+        if (this.element.raiseEndPageLayout) {
+            let res: PdfLayoutResult = this.getLayoutResult(pageResult);
+            args = new EndPageLayoutEventArgs(res);
+            this.element.onEndPageLayout(args);
+        }
+        return args;
+    }
+    /**
+     * Creates layout result.
+     * @private
+     */
+    private getLayoutResult(pageResult: ShapeLayoutResult): PdfLayoutResult {
+        let result: PdfLayoutResult = new PdfLayoutResult(pageResult.page, pageResult.bounds);
+        return result;
+    }
+    /**
+     * Calculates the next active shape bounds.
+     * @private
+     */
+    private getNextShapeBounds(shapeLayoutBounds: RectangleF, pageResult: ShapeLayoutResult): RectangleF {
+        let layoutedBounds: RectangleF = pageResult.bounds;
+        shapeLayoutBounds.y = (shapeLayoutBounds.y + layoutedBounds.height);
+        shapeLayoutBounds.height = (shapeLayoutBounds.height - layoutedBounds.height);
+        return shapeLayoutBounds;
+    }
+    /**
+     * Layouts the element on the current page.
+     * @private
+     */
+    private layoutOnPage(currentPage: PdfPage, curBounds: RectangleF, sBounds: RectangleF, param: PdfLayoutParams): ShapeLayoutResult {
+        let result: ShapeLayoutResult = new ShapeLayoutResult();
+        curBounds = this.checkCorrectCurrentBounds(currentPage, curBounds, param);
+        let fitToPage: boolean = this.fitsToBounds(curBounds, sBounds);
+        let canDraw: boolean = !((param.format.break === PdfLayoutBreakType.FitElement)
+                    && (!fitToPage && (currentPage === param.page)));
+        let shapeFinished: boolean = false;
+        if (canDraw) {
+            let drawRectangle: RectangleF = this.getDrawBounds(curBounds, sBounds);
+            this.drawShape(currentPage.graphics, curBounds, drawRectangle);
+            result.bounds = this.getPageResultBounds(curBounds, sBounds);
+            shapeFinished = ((<number>(curBounds.height)) >= (<number>(sBounds.height)));
+        }
+        result.end = (shapeFinished || (param.format.layout === PdfLayoutType.OnePage));
+        result.page = currentPage;
+        return result;
+    }
+    /**
+     * Returns Rectangle for element drawing on the page.
+     * @private
+     */
+    private getDrawBounds(currentBounds: RectangleF, shapeLayoutBounds: RectangleF): RectangleF {
+        let result: RectangleF = currentBounds;
+        result.y = (result.y - shapeLayoutBounds.y);
+        result.height = (result.height + shapeLayoutBounds.y);
+        return result;
+    }
+    /**
+     * Draws the shape.
+     * @private
+     */
+    private drawShape(g: PdfGraphics, currentBounds: RectangleF, drawRectangle: RectangleF): void {
+        let gState: PdfGraphicsState = g.save();
+        try {
+            g.setClip(currentBounds);
+            this.element.drawGraphicsHelper(g, new PointF(drawRectangle.x, drawRectangle.y));
+        }
+        finally {
+            g.restore(gState);
+        }
+    }
+    /**
+     * Corrects current bounds on the page.
+     * @protected
+     */
+    protected checkCorrectCurrentBounds(currentPage: PdfPage, curBounds: RectangleF, param: PdfLayoutParams): RectangleF {
+        let pageSize: SizeF = currentPage.graphics.clientSize;
+        curBounds.width = (curBounds.width > 0) ? curBounds.width : (pageSize.width - curBounds.x);
+        curBounds.height = (curBounds.height > 0) ? curBounds.height : (pageSize.height - curBounds.y);
+        if (this.isPdfGrid) {
+            curBounds.height = (curBounds.height - this.bottomCellPadding);
+        }
+        return curBounds;
+    }
+    /**
+     * Calculates bounds where the shape was layout on the page.
+     * @private
+     */
+    private getPageResultBounds(currentBounds: RectangleF, shapeLayoutBounds: RectangleF): RectangleF {
+        let result: RectangleF = currentBounds;
+        result.height = Math.min(result.height, shapeLayoutBounds.height);
+        return result;
+    }
+    /**
+     * Checks whether shape rectangle fits to the lay outing bounds.
+     * @private
+     */
+    private fitsToBounds(currentBounds: RectangleF, shapeLayoutBounds: RectangleF): boolean {
+        let fits: boolean = (shapeLayoutBounds.height <= currentBounds.height);
+        return fits;
+    }
+}
+/**
+ * Contains lay outing result settings.
+ * @private
+ */
+class ShapeLayoutResult {
+    /**
+     * The last page where the element was drawn.
+     * @private
+     */
+    public page : PdfPage;
+    /**
+     * The bounds of the element on the last page where it was drawn.
+     * @private
+     */
+    public bounds : RectangleF;
+    /**
+     * Indicates whether the lay outing has been finished.
+     * @private
+     */
+    public end : boolean;
+}

package/dist/ts/implementation/graphics/figures/base/text-layouter.d.ts

@@ -0,0 +1,107 @@
+/**
+ * TextLayouter.ts class for EJ2-PDF
+ */
+import { ElementLayouter, PdfLayoutParams, PdfLayoutResult } from './element-layouter';
+import { PdfTextElement } from './../text-element';
+import { PdfPage } from './../../../pages/pdf-page';
+import { RectangleF } from './../../../drawing/pdf-drawing';
+/**
+ * Class that `layouts the text`.
+ * @private
+ */
+export declare class TextLayouter extends ElementLayouter {
+    /**
+     * String `format`.
+     * @private
+     */
+    private format;
+    /**
+     * Gets the layout `element`.
+     * @private
+     */
+    readonly element: PdfTextElement;
+    /**
+     * Initializes a new instance of the `TextLayouter` class.
+     * @private
+     */
+    constructor(element: PdfTextElement);
+    /**
+     * `Layouts` the element.
+     * @private
+     */
+    protected layoutInternal(param: PdfLayoutParams): PdfLayoutResult;
+    /**
+     * Raises `PageLayout` event if needed.
+     * @private
+     */
+    private getLayoutResult;
+    /**
+     * `Layouts` the text on the page.
+     * @private
+     */
+    private layoutOnPage;
+    /**
+     * `Corrects current bounds` on the page.
+     * @private
+     */
+    private checkCorrectBounds;
+    /**
+     * Returns a `rectangle` where the text was printed on the page.
+     * @private
+     */
+    private getTextPageBounds;
+}
+export declare class TextPageLayoutResult {
+    /**
+     * The last `page` where the text was drawn.
+     * @private
+     */
+    page: PdfPage;
+    /**
+     * The `bounds` of the element on the last page where it was drawn.
+     * @private
+     */
+    bounds: RectangleF;
+    /**
+     * Indicates whether the lay outing has been finished [`end`].
+     * @private
+     */
+    end: boolean;
+    /**
+     * The `text` that was not printed.
+     * @private
+     */
+    remainder: string;
+    /**
+     * Gets or sets a `bounds` of the last text line that was printed.
+     * @private
+     */
+    lastLineBounds: RectangleF;
+}
+export declare class PdfTextLayoutResult extends PdfLayoutResult {
+    /**
+     * The `text` that was not printed.
+     * @private
+     */
+    private remainderText;
+    /**
+     * The `bounds` of the last line that was printed.
+     * @private
+     */
+    private lastLineTextBounds;
+    /**
+     * Gets a value that contains the `text` that was not printed.
+     * @private
+     */
+    readonly remainder: string;
+    /**
+     * Gets a value that indicates the `bounds` of the last line that was printed on the page.
+     * @private
+     */
+    readonly lastLineBounds: RectangleF;
+    /**
+     * Initializes the new instance of `PdfTextLayoutResult` class.
+     * @private
+     */
+    constructor(page: PdfPage, bounds: RectangleF, remainder: string, lastLineBounds: RectangleF);
+}