@syncfusion/ej2-pdf-export 25.1.38 → 26.1.35

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

@@ -0,0 +1,132 @@
+/**
+ * PdfLayoutElement.ts class for EJ2-PDF
+ */
+import { PdfPage } from './../../pages/pdf-page';
+import { RectangleF, PointF } from './../../drawing/pdf-drawing';
+import { PdfLayoutParams, PdfLayoutFormat, PdfLayoutResult } from './base/element-layouter';
+import { PdfBorders} from './../../structured-elements/grid/styles/pdf-borders';
+import { PdfGridBeginPageLayoutEventArgs, PdfGridEndPageLayoutEventArgs }  from './../../structured-elements/grid/layout/grid-layouter';
+import { BeginPageLayoutEventArgs, EndPageLayoutEventArgs } from './../../structured-elements/grid/layout/grid-layouter';
+/**
+ * `PdfLayoutElement` class represents the base class for all elements that can be layout on the pages.
+ * @private
+ */
+export abstract class PdfLayoutElement {
+    /* tslint:disable */
+    /**
+     * Indicating whether [`embed fonts`]
+     * @private
+     */
+    private bEmbedFonts : boolean;
+    // Events 
+    public endPageLayout : Function;
+    public beginPageLayout : Function;
+
+    // Property
+    /**
+     * Gets a value indicating whether the `start page layout event` should be raised.
+     * @private
+     */   
+    public get raiseBeginPageLayout() : boolean {
+        return (typeof this.beginPageLayout !== 'undefined');
+    }
+    /**
+     * Gets a value indicating whether the `ending page layout event` should be raised.
+     * @private
+     */
+    public get raiseEndPageLayout() : boolean {
+        return (typeof this.endPageLayout !== 'undefined');
+    }
+    //Event Handlers
+    public onBeginPageLayout(args : PdfGridBeginPageLayoutEventArgs | BeginPageLayoutEventArgs): void {
+        if (this.beginPageLayout) {
+            this.beginPageLayout(this, args);
+        }
+    }
+    public onEndPageLayout(args : PdfGridEndPageLayoutEventArgs | EndPageLayoutEventArgs): void {
+        if (this.endPageLayout) {
+            this.endPageLayout(this, args);
+        }
+    }
+    /**
+     * `Draws` the element on the page with the specified page and "PointF" class
+     * @private
+     */
+    public drawHelper(page : PdfPage, location : PointF) : PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page and pair of coordinates
+     * @private
+     */
+    public drawHelper(page : PdfPage, x : number, y : number) : PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page and "RectangleF" class
+     * @private
+     */
+    public drawHelper(page : PdfPage, layoutRectangle : RectangleF) : PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page, "PointF" class and layout format
+     * @private
+     */
+    public drawHelper(page : PdfPage, location : PointF, format : PdfLayoutFormat) : PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page, pair of coordinates and layout format
+     * @private
+     */
+    public drawHelper(page : PdfPage, x : number, y : number, format : PdfLayoutFormat) : PdfLayoutResult
+    /**
+     * `Draws` the element on the page.
+     * @private
+     */
+    public drawHelper(page : PdfPage, layoutRectangle : RectangleF, embedFonts : boolean) : PdfLayoutResult
+    /**
+     * `Draws` the element on the page with the specified page, "RectangleF" class and layout format
+     * @private
+     */
+    public drawHelper(page : PdfPage, layoutRectangle : RectangleF, format : PdfLayoutFormat) : PdfLayoutResult
+    public drawHelper(arg2 : PdfPage, arg3 : RectangleF | PointF | number, arg4 ?: PdfLayoutFormat | number | boolean, arg5 ?: PdfLayoutFormat) : PdfLayoutResult {
+        if (arg3 instanceof PointF && typeof (arg3 as RectangleF).width === 'undefined' && typeof arg4 === 'undefined') {
+            return this.drawHelper(arg2, arg3.x, arg3.y);
+        } else if (typeof arg3 === 'number' && typeof arg4 === 'number' && typeof arg5 === 'undefined') {
+            return this.drawHelper(arg2, arg3, arg4, null);
+        } else if (arg3 instanceof RectangleF && typeof (arg3 as RectangleF).width !== 'undefined' && typeof arg4 === 'undefined') {
+            return this.drawHelper(arg2, arg3, null);
+        } else if (arg3 instanceof PointF && typeof (arg3 as RectangleF).width === 'undefined' && arg4 instanceof PdfLayoutFormat) {
+            return this.drawHelper(arg2, arg3.x, arg3.y, arg4);
+        } else if (typeof arg3 === 'number' && typeof arg4 === 'number' && (arg5 instanceof PdfLayoutFormat || arg5 == null)) {
+            let width : number = (arg2.graphics.clientSize.width - arg3);
+            let layoutRectangle : RectangleF = new RectangleF(arg3, arg4, width, 0);
+            return this.drawHelper(arg2, layoutRectangle, arg5);
+        } else if (arg3 instanceof RectangleF && typeof (arg3 as RectangleF).width !== 'undefined' && typeof arg4 === 'boolean') {
+            this.bEmbedFonts = arg4;
+            return this.drawHelper(arg2, arg3, null);
+        } else {
+            let param : PdfLayoutParams = new PdfLayoutParams();
+            let temparg3 : RectangleF = arg3 as RectangleF;
+            let temparg4 : PdfLayoutFormat = arg4 as PdfLayoutFormat;
+            param.page = arg2;
+            param.bounds = temparg3;
+            if (param != null ) {
+                let x : number = param.bounds.x;
+                let y : number = param.bounds.y;
+                if (param.bounds.x === 0) {
+                    x = PdfBorders.default.right.width / 2;
+                }
+                if (param.bounds.y === 0) {
+                    y = PdfBorders.default.top.width / 2;
+                }
+                let newBound : RectangleF = new RectangleF(x, y, param.bounds.width, param.bounds.height);
+                param.bounds = newBound;
+            }
+            param.format = (temparg4 != null) ? temparg4 : new PdfLayoutFormat();
+            let result : PdfLayoutResult = this.layout(param);
+            return result;
+        }
+    }
+   
+    /**
+     * `Layouts` the specified param.
+     * @private
+     */
+    protected abstract layout(param : PdfLayoutParams) : PdfLayoutResult;
+    /* tslint:enable */
+}

package/dist/ts/implementation/graphics/figures/path.d.ts

@@ -0,0 +1,319 @@
+/**
+ * Path.ts class for EJ2-PDF
+ */
+import { PdfBrush } from './../brushes/pdf-brush';
+import { PdfPen } from './../pdf-pen';
+import { PdfLayoutResult, PdfLayoutFormat } from './../figures/base/element-layouter';
+import { PdfGraphics } from './../pdf-graphics';
+import { RectangleF, PointF } from './../../drawing/pdf-drawing';
+import { PdfPage } from './../../pages/pdf-page';
+import { PdfFillElement } from './../figures/base/fill-element';
+import { PdfFillMode } from './../enum';
+/**
+ * `PdfPath` class Implements graphics path, which is a sequence of primitive graphics elements.
+ * @private
+ */
+export declare class PdfPath extends PdfFillElement {
+    /**
+     * Local variable to store the points.
+     * @private
+     */
+    private mpoints;
+    /**
+     * Local variable to store the path Types.
+     * @private
+     */
+    private mpathTypes;
+    /**
+     * Local variable to store the Start Figure.
+     * @private
+     */
+    private mStartFigure;
+    /**
+     * Local variable to store the fill Mode.
+     * @private
+     */
+    private mfillMode;
+    /**
+     * Local variable to store the Beziers.
+     * @private
+     */
+    private isBeziers3;
+    /**
+     * Local variable to store the xps.
+     * @private
+     */
+    private isXps;
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor();
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(pen: PdfPen);
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(brush: PdfBrush);
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(points: PointF[], pathTypes: number[]);
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(brush: PdfBrush, fillMode: PdfFillMode);
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(pen: PdfPen, points: PointF[], pathTypes: number[]);
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(pen: PdfPen, brush: PdfBrush, fillMode: PdfFillMode);
+    /**
+     * Initializes a new instance of the `PdfPath` class.
+     * @public
+     */
+    constructor(brush: PdfBrush, fillMode: PdfFillMode, points: PointF[], pathTypes: number[]);
+    /**
+     * Gets or sets the fill mode.
+     * @public
+     */
+    fillMode: PdfFillMode;
+    /**
+     * Gets the path points.
+     * @public
+     */
+    readonly pathPoints: PointF[];
+    /**
+     * Gets the path point types.
+     * @public
+     */
+    readonly pathTypes: number[];
+    /**
+     * Gets the point count.
+     * @public
+     */
+    readonly pointCount: number;
+    /**
+     * Gets the last points.
+     * @public
+     */
+    readonly lastPoint: PointF;
+    /**
+     * Gets the points list.
+     * @private
+     */
+    private readonly points;
+    /**
+     * Gets the types.
+     * @private
+     */
+    private readonly types;
+    /**
+     * `draw` the element on the page with the specified page and 'PointF' class
+     * @param page Current page where the element should be drawn.
+     * @param location Start location on the page.
+     */
+    draw(page: PdfPage, location: PointF): PdfLayoutResult;
+    /**
+     * `draw` the element on the page with the specified page and pair of coordinates
+     * @private
+     */
+    draw(page: PdfPage, x: number, y: number): PdfLayoutResult;
+    /**
+     * `draw` the element on the page with the specified page and 'RectangleF' class
+     * @private
+     */
+    draw(page: PdfPage, layoutRectangle: RectangleF): PdfLayoutResult;
+    /**
+     * `draw` the element on the page with the specified page, 'PointF' class and layout format
+     * @private
+     */
+    draw(page: PdfPage, location: PointF, format: PdfLayoutFormat): PdfLayoutResult;
+    /**
+     * `draw` the element on the page with the specified page, pair of coordinates and layout format
+     * @private
+     */
+    draw(page: PdfPage, x: number, y: number, format: PdfLayoutFormat): PdfLayoutResult;
+    /**
+     * `draw` the element on the page.
+     * @private
+     */
+    draw(page: PdfPage, layoutRect: RectangleF, format: PdfLayoutFormat): PdfLayoutResult;
+    /**
+     * `add a arc` specified by a rectangle, a coordinate start angle and sweepangle.
+     * @param rectangle The boundaries of the arc.
+     * @param startAngle The start angle of the arc.
+     * @param sweepAngle The angle between startAngle and the end of the arc.
+     */
+    addArc(rectangle: RectangleF, startAngle: number, sweepAngle: number): void;
+    /**
+     * `add a arc` specified by a x , y coordinate points, a width, a height and coordinate start angle and sweepangle.
+     * @param x The x-coordinate of the upper-left corner of the rectangular region.
+     * @param y The y-coordinate of the upper-left corner of the rectangular region
+     * @param width The width of the rectangular region.
+     * @param height The height of the rectangular region.
+     * @param startAngle The start angle of the arc.
+     * @param sweepAngle The angle between startAngle and the end of the arc.
+     */
+    addArc(x: number, y: number, width: number, height: number, startAngle: number, sweepAngle: number): void;
+    /**
+     * `add a bezier curve` specified by region points.
+     * @param startPoint The start point - represents the starting point of the curve.
+     * @param firstControlPoint The first control point - represents the second control point of the curve.
+     * @param secondControlPoint The second control point - represents the second control point of the curve.
+     * @param endPoint The end point - represents the end point of the curve.
+     */
+    addBezier(startPoint: PointF, firstControlPoint: PointF, secondControlPoint: PointF, endPoint: PointF): void;
+    /**
+     * `add a bezier curve` specified by region points.
+     * @param startPointX The start point X.
+     * @param startPointY The start point Y.
+     * @param firstControlPointX The first control point X.
+     * @param firstControlPointY The first control point Y.
+     * @param secondControlPointX The second control point X.
+     * @param secondControlPointY The second control point Y.
+     * @param endPointX The end point X.
+     * @param endPointY The end point Y.
+     */
+    addBezier(startPointX: number, startPointY: number, firstControlPointX: number, firstControlPointY: number, secondControlPointX: number, secondControlPointY: number, endPointX: number, endPointY: number): void;
+    /**
+     * `add a ellipse` specified by a rectangle.
+     * @param rectangle The boundaries of the ellipse.
+     */
+    addEllipse(rectangle: RectangleF): void;
+    /**
+     * `add a ellipse` specified by a rectangle bounds .
+     * @param x The x-coordinate of the upper-left corner of the rectangular region.
+     * @param y The y-coordinate of the upper-left corner of the rectangular region.
+     * @param width The width of the rectangular region.
+     * @param height The height of the rectangular region.
+     */
+    addEllipse(x: number, y: number, width: number, height: number): void;
+    /**
+     * `add a line` specified by points .
+     * @param point1 The start point of the line.
+     * @param point2 The end point of the line.
+     */
+    addLine(point1: PointF, point2: PointF): void;
+    /**
+     * `add a line` specified by a rectangle bounds.
+     * @param x1 The x-coordinate of the starting point of the line.
+     * @param y1 The y-coordinate of the starting point of the line.
+     * @param x2 The x-coordinate of the end point of the line.
+     * @param y2 The y-coordinate of the end point of the line.
+     */
+    addLine(x1: number, y1: number, x2: number, y2: number): void;
+    /**
+     * `add a path` specified by a path, appends the path specified to this one.
+     * @param path The path, which should be appended.
+     */
+    addPath(path: PdfPath): void;
+    /**
+     * `add a path` specified by a path points and path types.
+     * @param pathPoints The array of points that represents the points to define the path
+     * @param pathTypes The path types specifies the types of the corresponding points in the path.
+     */
+    addPath(pathPoints: PointF[], pathTypes: number[]): void;
+    /**
+     * `add a pie` specified by a rectangle, a coordinate start angle and sweepangle.
+     * @param rectangle The bounding rectangle of the pie.
+     * @param startAngle The start angle of the pie.
+     * @param sweepAngle The sweep angle of the pie.
+     */
+    addPie(rectangle: RectangleF, startAngle: number, sweepAngle: number): void;
+    /**
+     * `add a pie` specified by x , y coordinate points, a width, a height and start angle and sweepangle.
+     * @param x The x-coordinate of the upper-left corner of the bounding rectangle.
+     * @param y The y-coordinate of the upper-left corner of the bounding rectangle.
+     * @param width The width of the bounding rectangle.
+     * @param height The height of the bounding rectangle
+     * @param startAngle The start angle of the pie.
+     * @param sweepAngle The sweep angle of the pie.
+     */
+    addPie(x: number, y: number, width: number, height: number, startAngle: number, sweepAngle: number): void;
+    /**
+     * `add a polygon` specified by points.
+     * @param points The points of the polygon
+     */
+    addPolygon(points: PointF[]): void;
+    /**
+     * `add a rectangle` specified by a rectangle.
+     * @param rectangle The rectangle.
+     */
+    addRectangle(rectangle: RectangleF): void;
+    /**
+     * `add a rectangle` specified by a rectangle.
+     * @param x The x-coordinate of the upper-left corner of the rectangular region.
+     * @param y The y-coordinate of the upper-left corner of the rectangular region
+     * @param width The width of the rectangular region.
+     * @param height The height of the rectangular region.
+     */
+    addRectangle(x: number, y: number, width: number, height: number): void;
+    /**
+     * Starts a new figure.
+     * @public
+     */
+    startFigure(): void;
+    /**
+     * Closed all non-closed figures.
+     * @public
+     */
+    closeAllFigures(): void;
+    /**
+     * Gets the last point.
+     * @public
+     */
+    getLastPoint(): PointF;
+    /**
+     * Gets the bezier points for arc constructing.
+     * @public
+     */
+    getBezierArcPoints(x1: number, y1: number, x2: number, y2: number, s1: number, e1: number): number[];
+    /**
+     * `getBoundsInternal` Returns a rectangle that bounds this element.
+     * @public
+     */
+    getBoundsInternal(): RectangleF;
+    /**
+     * `drawInternal` Draws an element on the Graphics.
+     * @param graphics Graphics context where the element should be printed.
+     * @public
+     */
+    drawInternal(graphics: PdfGraphics): void;
+    /**
+     * `add a points` Adds the points along with their type to the path.
+     * @param points The points.
+     * @param pointType Type of the points.
+     * @private
+     */
+    private addPoints;
+    /**
+     * `add a point` Adds the point and its type
+     * @param points The points.
+     * @param pointType Type of the points.
+     * @private
+     */
+    private addPoint;
+    /**
+     * Closes the figure.
+     * @public
+     */
+    closeFigure(): void;
+    /**
+     * Closes the figure.
+     * @param index The index of the last figure point.
+     * @public
+     */
+    closeFigure(index: number): void;
+}