@syncfusion/ej2-pdf-export 21.2.10 → 22.1.34

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

@@ -0,0 +1,260 @@
+/**
+ * ElementLayouter.ts class for EJ2-PDF
+ */
+import { RectangleF } from './../../../drawing/pdf-drawing';
+import { PdfPage } from './../../../pages/pdf-page';
+import { PdfLayoutType, PdfLayoutBreakType } from './../enum';
+import { PdfLayoutElement } from './../layout-element';
+import { PdfSection } from './../../../pages/pdf-section';
+/**
+ * Base class for `elements lay outing`.
+ * @private
+ */
+export abstract class ElementLayouter {
+    // Fields
+    /**
+     * Layout the `element`.
+     * @private
+     */
+    private layoutElement : PdfLayoutElement;
+    // Constructor
+    /**
+     * Initializes a new instance of the `ElementLayouter` class.
+     * @private
+     */
+    public constructor(element : PdfLayoutElement) {
+        this.layoutElement = element;
+    }
+    // Properties
+    /**
+     * Gets the `element`.
+     * @private
+     */
+    public get elements() : PdfLayoutElement {
+        return this.layoutElement;
+    }
+    /**
+     * Gets the `element`.
+     * @private
+     */
+    public getElement() : PdfLayoutElement {
+        return this.layoutElement;
+    }
+    // Implementation
+    /**
+     * `Layouts` the element.
+     * @private
+     */
+    public layout(param : PdfLayoutParams) : PdfLayoutResult {
+        return this.layoutInternal(param);
+    }
+    public Layouter(param : PdfLayoutParams) : PdfLayoutResult {
+        return this.layoutInternal(param);
+    }
+    /**
+     * Returns the `next page`.
+     * @private
+     */
+    public getNextPage(currentPage : PdfPage) : PdfPage {
+        let section : PdfSection = currentPage.section;
+        let nextPage : PdfPage = section.add() as PdfPage;
+        return nextPage;
+    }
+    protected getPaginateBounds(param: PdfLayoutParams): RectangleF {
+        if ((param == null)) {
+            throw new Error('ArgumentNullException : param');
+        }
+        let result : RectangleF = param.format.usePaginateBounds ? param.format.paginateBounds
+         : new RectangleF(param.bounds.x, 0, param.bounds.width, param.bounds.height);
+        return result;
+    }
+    /**
+     * `Layouts` the element.
+     * @private
+     */
+    protected abstract layoutInternal(param : PdfLayoutParams) : PdfLayoutResult;
+   // protected abstract layoutInternal(param : PdfLayoutParams, isBoundsChanged ?: boolean) : PdfLayoutResult;
+}
+export class PdfLayoutFormat {
+    // Fields
+    /**
+     * Indicates whether `PaginateBounds` were set and should be used or not.
+     * @private
+     */
+    private boundsSet : boolean;
+    /**
+     * `Bounds` for the paginating.
+     * @private
+     */
+    private layoutPaginateBounds : RectangleF;
+    /**
+     * `Layout` type of the element.
+     * @private
+     */
+    private layoutType : PdfLayoutType;
+    /**
+     * `Break` type of the element.
+     * @private
+     */
+    private breakType : PdfLayoutBreakType;
+
+    // Properties
+    /**
+     * Gets or sets `layout` type of the element.
+     * @private
+     */
+    public get layout() : PdfLayoutType {
+        // if (typeof this.layoutType === 'undefined' || this.layoutType == null) {
+        //      this.layoutType = PdfLayoutType.Paginate;
+        // }
+        return this.layoutType;
+    }
+    public set layout(value : PdfLayoutType) {
+        this.layoutType = value;
+    }
+    /**
+     * Gets or sets `break` type of the element.
+     * @private
+     */
+    public get break() : PdfLayoutBreakType {
+        // if (typeof this.breakType === 'undefined' || this.boundsSet == null) {
+        //      this.breakType = PdfLayoutBreakType.FitPage;
+        // }
+        return this.breakType;
+    }
+    public set break(value : PdfLayoutBreakType) {
+        this.breakType = value;
+    }
+    /**
+     * Gets or sets the `bounds` on the next page.
+     * @private
+     */
+    public get paginateBounds() : RectangleF {
+        if (typeof this.layoutPaginateBounds === 'undefined' && this.layoutPaginateBounds == null) {
+            this.layoutPaginateBounds = new RectangleF(0, 0, 0, 0);
+        }
+        return this.layoutPaginateBounds;
+    }
+    public set paginateBounds(value : RectangleF) {
+        this.layoutPaginateBounds = value;
+        this.boundsSet = true;
+    }
+    /**
+     * Gets a value indicating whether [`use paginate bounds`].
+     * @private
+     */
+    public get usePaginateBounds() : boolean {
+        // if (typeof this.boundsSet === 'undefined' || this.boundsSet == null) {
+        //      this.boundsSet = false;
+        // }
+        return this.boundsSet;
+    }
+    // Constructors
+    /**
+     * Initializes a new instance of the `PdfLayoutFormat` class.
+     * @private
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `PdfLayoutFormat` class.
+     * @private
+     */
+    public constructor(baseFormat : PdfLayoutFormat)
+    public constructor(baseFormat ?: PdfLayoutFormat) {
+        if (typeof baseFormat === 'undefined') {
+            //
+        } else {
+            this.break = baseFormat.break;
+            this.layout = baseFormat.layout;
+            this.paginateBounds = baseFormat.paginateBounds;
+            this.boundsSet = baseFormat.usePaginateBounds;
+        }
+    }
+}
+export class PdfLayoutParams {
+    // Fields
+    /**
+     * The last `page` where the element was drawn.
+     * @private
+     */
+    private pdfPage : PdfPage;
+    /**
+     * The `bounds` of the element on the last page where it was drawn.
+     * @private
+     */
+    private layoutBounds : RectangleF;
+    /**
+     * Layout settings as `format`.
+     * @private
+     */
+    private layoutFormat : PdfLayoutFormat;
+    // Properties
+    /**
+     * Gets or sets the layout `page` for the element.
+     * @private
+     */
+    public get page() : PdfPage {
+        return this.pdfPage;
+    }
+    public set page(value : PdfPage) {
+        this.pdfPage = value;
+    }
+    /**
+     * Gets or sets layout `bounds` for the element.
+     * @private
+     */
+    public get bounds() : RectangleF {
+        return new RectangleF(this.layoutBounds.x, this.layoutBounds.y, this.layoutBounds.width, this.layoutBounds.height);
+    }
+    public set bounds(value : RectangleF) {
+        this.layoutBounds = value;
+    }
+    /**
+     * Gets or sets `layout settings` for the element.
+     * @private
+     */
+    public get format() : PdfLayoutFormat {
+        return this.layoutFormat;
+    }
+    public set format(value : PdfLayoutFormat) {
+        this.layoutFormat = value;
+    }
+}
+export class PdfLayoutResult {
+    // Fields    
+    /**
+     * The last `page` where the element was drawn.
+     * @private
+     */
+    private pdfPage : PdfPage;
+    /**
+     * The `bounds` of the element on the last page where it was drawn.
+     * @private
+     */
+    private layoutBounds : RectangleF;
+
+    // Properties
+    /**
+     * Gets the last `page` where the element was drawn.
+     * @private
+     */
+    public get page() : PdfPage {
+        return this.pdfPage;
+    }
+    /**
+     * Gets the `bounds` of the element on the last page where it was drawn.
+     * @private
+     */
+    public get bounds() : RectangleF {
+         return this.layoutBounds;
+    }
+    // Constructors
+    /**
+     * Initializes the new instance of `PdfLayoutResult` class.
+     * @private
+     */
+    public constructor(page : PdfPage, bounds : RectangleF) {
+        this.pdfPage = page;
+        this.layoutBounds = bounds;
+    }
+}

package/dist/ts/implementation/graphics/figures/base/fill-element.ts

@@ -0,0 +1,72 @@
+/**
+ * PdfFillElement.ts class for EJ2-PDF
+ */
+import { PdfDrawElement } from './draw-element';
+import { PdfPen } from './../../pdf-pen';
+import { PdfBrush } from './../../brushes/pdf-brush';
+import {PdfColor} from './../../pdf-color';
+/**
+ * Represents a base class for all page graphics elements.
+ */
+export abstract class PdfFillElement extends PdfDrawElement {
+    // Fields
+    /**
+     * Internal variable to store pen.
+     * @private
+     */
+    private mbrush : PdfBrush = null;
+    // Constructor
+    /**
+     * Initializes a new instance of the `PdfFillElement` class.
+     * @protected
+     */
+    protected constructor()
+    /**
+     * Initializes a new instance of the `PdfFillElement` class.
+     * @protected
+     */
+    protected constructor(pen: PdfPen)
+    /**
+     * Initializes a new instance of the `PdfFillElement` class.
+     * @protected
+     */
+    protected constructor(brush: PdfBrush)
+    /**
+     * Initializes a new instance of the `PdfFillElement` class.
+     * @protected
+     */
+    protected constructor(pen: PdfPen, brush: PdfBrush)
+    /**
+     * Initializes a new instance of the `PdfFillElement` class.
+     * @protected
+     */
+    protected constructor(arg1 ?: PdfPen|PdfBrush, arg2 ?: PdfBrush) {
+        super();
+        if (typeof arg1 === 'undefined') {
+            //
+        } else if (arg1 instanceof PdfPen) {
+            super(arg1);
+        } else {
+            this.mbrush = arg2;
+        }
+    }
+    // Properties
+    /**
+     * Gets or sets a brush of the element.
+     * @public
+     */
+    public get brush(): PdfBrush {
+        return this.mbrush;
+    }
+    public set brush(value: PdfBrush) {
+        this.mbrush = value;
+    }
+    // Implementation
+    /**
+     * Gets the pen. If both pen and brush are not explicitly defined, default pen will be used.
+     * @protected
+     */
+    protected obtainPen(): PdfPen {
+        return ((this.mbrush == null) && (this.pen == null)) ? new PdfPen(new PdfColor(0, 0, 0)) : this.pen;
+    }
+}

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

@@ -0,0 +1,34 @@
+/**
+ * PdfGraphicsElement.ts class for EJ2-PDF
+ */
+import { PdfGraphics, PdfGraphicsState } from './../../pdf-graphics';
+/**
+ * Represents a base class for all page graphics elements.
+ */
+export abstract class PdfGraphicsElement {
+    // Constructors
+    protected constructor() {
+        //
+    }
+    /**
+     * `Draws` the page number field.
+     * @public
+     */
+    public drawHelper(graphics : PdfGraphics, x : number, y : number) : void {
+            let bNeedSave : boolean = (x !== 0 || y !== 0);
+            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;
+}

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;
+    }
+}