@syncfusion/ej2-pdf-export 29.1.41 → 30.1.37

package/dist/ts/implementation/graphics/brushes/pdf-radial-gradient-brush.ts

@@ -0,0 +1,290 @@
+/**
+ * PdfRadialGradientBrush.ts class for EJ2-PDF
+ */
+import { PdfColorSpace } from './../enum';
+import { PdfColor } from './../pdf-color';
+import { PdfBrush } from './pdf-brush';
+import { PointF, RectangleF } from './../../drawing/pdf-drawing';
+import { PdfDictionary} from '../../primitives/pdf-dictionary';
+import { DictionaryProperties } from './../../input-output/pdf-dictionary-properties';
+import { PdfBoolean } from '../../primitives/pdf-boolean';
+import { PdfArray } from './../../primitives/pdf-array';
+import { PdfNumber } from './../../primitives/pdf-number';
+import { PdfColorBlend  } from './pdf-color-blend';
+import { PdfBlend } from './pdf-blend';
+import { PdfGradientBrush } from './pdf-gradient-brush';
+import { PdfExtend , ShadingType} from './enum';
+/**
+ * `PdfRadialGradientBrush` Represent radial gradient brush.
+ * @private
+ */
+export class PdfRadialGradientBrush extends PdfGradientBrush {
+    //Fields
+    /**
+     * Local varaible to store the point start.
+     * @private
+     */
+    private mPointStart: PointF;
+    /**
+     * Local varaible to store the radius start.
+     * @private
+     */
+    private mRadiusStart: number;
+    /**
+     * Local varaible to store the point End.
+     * @private
+     */
+    private mPointEnd: PointF;
+    /**
+     * Local varaible to store the radius End.
+     * @private
+     */
+    private mRadiusEnd: number;
+    /**
+     * Local varaible to store the colours.
+     * @private
+     */
+    private mColour: PdfColor[];
+    /**
+     * Local varaible to store the colour blend.
+     * @private
+     */
+    private mColourBlends: PdfColorBlend;
+    /**
+     * Local varaible to store the blend.
+     * @private
+     */
+    private mBlend: PdfBlend;
+    /**
+     * Local varaible to store the boundaries.
+     * @private
+     */
+    private mBoundaries: RectangleF;
+    /**
+     * Local varaible to store the dictionary properties.
+     */
+    private mDictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    //Constructor
+    /**
+     * Initializes a new instance of the `PdfRadialGradientBrush` class.
+     * @public
+     */
+    /* tslint:disable-next-line:max-line-length */
+    public constructor(centerStart: PointF, radiusStart: number, centerEnd: PointF, radiusEnd: number, colorStart: PdfColor, colorEnd: PdfColor) {
+        super(new PdfDictionary());
+        this.initialize(colorStart, colorEnd);
+        if (radiusStart < 0) {
+            throw new Error('ArgumentOutOfRangeException : radiusStart - The radius cannot be less then zero.');
+        }
+        if (radiusEnd < 0) {
+            throw new Error('ArgumentOutOfRangeException : radiusEnd - The radius cannpt be less then zero.');
+        }
+        this.mPointEnd = centerEnd;
+        this.mPointStart = centerStart;
+        this.mRadiusStart = radiusStart;
+        this.mRadiusEnd = radiusEnd;
+        this.setPoints(this.mPointStart, this.mPointEnd, this.mRadiusStart, this.mRadiusEnd);
+    }
+    /**
+     * Initializes a new instance of the `PdfRadialGradientBrush` class.
+     * @param color1 The color1.
+     * @param color2 The color2.
+     */
+    private initialize(color1: PdfColor, color2: PdfColor) : void {
+        this.mColour = [ color1, color2];
+        this.mColourBlends = new PdfColorBlend(2);
+        this.mColourBlends.positions = [ 0, 1];
+        this.mColourBlends.colors = this.mColour;
+        this.initShading();
+    }
+    //Properties
+    /**
+     * Gets or sets a PdfBlend that specifies positions and factors that define a custom falloff for the gradient.
+     * @public
+     */
+    public get blend(): PdfBlend {
+        return this.mBlend;
+    }
+    public set blend(value: PdfBlend)  {
+        if ((value == null)) {
+            throw new Error('ArgumentNullException : Blend');
+        }
+        if ((this.mColour == null && typeof this.mColour === 'undefined')) {
+            throw new Error('NotSupportedException : There is no starting and ending colours specified.');
+        }
+        this.mBlend = value;
+        this.mColourBlends = this.mBlend.generateColorBlend(this.mColour, this.colorSpace);
+        this.resetFunction();
+    }
+    /**
+     * Gets or sets a ColorBlend that defines a multicolor radial gradient.
+     * @public
+     */
+    public get interpolationColors(): PdfColorBlend {
+        return this.mColourBlends;
+    }
+    public set interpolationColors(value: PdfColorBlend)  {
+        if (value == null) {
+            throw new Error('ArgumentNullException : InterpolationColors');
+        }
+        this.mBlend = null;
+        this.mColour = null;
+        this.mColourBlends = value;
+        this.resetFunction();
+    }
+    /**
+     * Gets or sets the starting and ending colors of the radial gradient.
+     * @public
+     */
+    public get linearColors(): PdfColor[] {
+        return this.mColour;
+    }
+    public set linearColors(value: PdfColor[]) {
+        if ((value == null)) {
+            throw new Error('ArgumentNullException : radial LinearColors');
+        }
+        if ((value.length < 2)) {
+            throw new Error('ArgumentException : The array is too small LinearColors');
+        }
+        if ((this.mColour == null && typeof this.mColour === 'undefined')) {
+            this.mColour = [value[0], value[1]];
+        } else {
+            this.mColour[0] = value[0];
+            this.mColour[1] = value[1];
+        }
+        if ((this.mBlend == null && typeof this.mBlend === 'undefined')) {
+            //  Set correct colour blend.
+            this.mColourBlends = new PdfColorBlend(2);
+            this.mColourBlends.colors = this.mColour;
+            this.mColourBlends.positions = [0, 1];
+        } else {
+            this.mColourBlends = this.mBlend.generateColorBlend(this.mColour, this.colorSpace);
+        }
+        this.resetFunction();
+    }
+    /**
+     * Gets or sets the rectangle.
+     * @public
+     */
+    public get rectangle(): RectangleF {
+        return this.mBoundaries;
+    }
+    public set rectangle(value: RectangleF)  {
+        this.mBoundaries = value;
+        this.bBox = PdfArray.fromRectangle(value);
+    }
+    /**
+     * Gets or sets the value indicating whether the gradient
+     *  should extend starting and ending points.
+     * @public
+     */
+    public get extend(): PdfExtend {
+        let result1 : PdfExtend = PdfExtend.None;
+        let extend1 : PdfArray = (<PdfArray>(this.shading.items.getValue(this.mDictionaryProperties.extend)));
+        if (extend1 !== null && typeof extend1 !== 'undefined') {
+            let extStart : PdfBoolean = (<PdfBoolean>(extend1.items(0)));
+            let extEnd : PdfBoolean = (<PdfBoolean>(extend1.items(1)));
+            if (extStart.value) {
+                result1 = (result1 | PdfExtend.Start);
+            }
+            if (extEnd.value) {
+                result1 = (result1 | PdfExtend.End);
+            }
+        }
+        return result1;
+    }
+    public set extend(value: PdfExtend)  {
+        let extend : PdfArray = (<PdfArray>(this.shading.items.getValue(this.mDictionaryProperties.extend)));
+        let extStart : PdfBoolean;
+        let extEnd1 : PdfBoolean;
+        if (extend == null && typeof extend === 'undefined') {
+            extStart = new PdfBoolean(false);
+            extEnd1 = new PdfBoolean(false);
+            extend = new PdfArray();
+            extend.add(extStart);
+            extend.add(extEnd1);
+            this.shading.items.setValue(this.mDictionaryProperties.extend, extend);
+        } else {
+            extStart = (<PdfBoolean>(extend.items(0)));
+            extEnd1 = (<PdfBoolean>(extend.items(1)));
+        }
+    }
+    //Implementation
+    /**
+     * Sets the points.
+     * @param pointStart The point start.
+     * @param pointEnd The point end.
+     * @param radiusStart The radius start.
+     * @param radiusEnd The radius end.
+     */
+    private setPoints(pointStart: PointF, pointEnd: PointF, radiusStart: number, radiusEnd: number) : void {
+        let points: PdfArray = new PdfArray();
+        points.add(new PdfNumber(pointStart.x));
+        points.add(new PdfNumber(this.updateY(pointStart.y)));
+        points.add(new PdfNumber(radiusStart));
+        points.add(new PdfNumber(pointEnd.x));
+        points.add(new PdfNumber(this.updateY(pointEnd.y)));
+        if ((radiusStart !== radiusEnd)) {
+            points.add(new PdfNumber(radiusEnd));
+        } else {
+            points.add(new PdfNumber(0));
+        }
+        this.shading.items.setValue(this.mDictionaryProperties.coords, points);
+    }
+    /**
+     * Update y co-ordinate.
+     * @param y Y co-ordinate.
+     */
+    private updateY(y: number): number {
+        if (y !== 0) {
+            return -y;
+        } else {
+            return y;
+        }
+    }
+    /**
+     * Initializess the shading dictionary.
+     * @private
+     */
+    private initShading(): void {
+        this.colorSpace = PdfColorSpace.Rgb;
+        this.function = this.mColourBlends.getFunction(this.colorSpace);
+        this.shading.items.setValue(this.mDictionaryProperties.shadingType, new PdfNumber((<number>(ShadingType.Radial))));
+    }
+    //Overrides
+    /**
+     * Creates a new copy of a brush.
+     * @public
+     */
+    public clone(): PdfBrush {
+        let rBrush: PdfRadialGradientBrush = this;
+        rBrush.resetPatternDictionary(new PdfDictionary(this.patternDictionary));
+        rBrush.shading = new PdfDictionary();
+        rBrush.initShading();
+        rBrush.setPoints(this.mPointStart, this.mPointEnd, this.mRadiusStart, this.mRadiusEnd);
+        if ( rBrush instanceof PdfRadialGradientBrush) {
+            if ((this.matrix !== null && typeof this.matrix !== 'undefined')) {
+                rBrush.matrix = this.matrix.clone();
+            }
+        }
+        if ((this.mColour !== null && typeof this.mColour !== 'undefined')) {
+            rBrush.mColour = (<PdfColor[]>(this.mColour));
+        }
+        if ((this.blend !== null && typeof this.blend !== 'undefined')) {
+            rBrush.blend = this.blend.clonePdfBlend();
+        } else if ((this.interpolationColors !== null && typeof this.interpolationColors !== 'undefined')) {
+            rBrush.interpolationColors = this.interpolationColors.cloneColorBlend();
+        }
+        rBrush.extend = this.extend;
+        this.cloneBackgroundValue(rBrush);
+        this.cloneAntiAliasingValue(rBrush);
+        return rBrush;
+    }
+    /**
+     * Resets the function.
+     * @public
+     */
+    public resetFunction() : void {
+        this.function = this.mColourBlends.getFunction(this.colorSpace);
+    }
+}

package/dist/ts/implementation/graphics/brushes/pdf-solid-brush.d.ts

@@ -0,0 +1,77 @@
+import { PdfColor } from './../pdf-color';
+import { PdfStreamWriter } from './../../input-output/pdf-stream-writer';
+import { GetResourceEventHandler } from './../pdf-graphics';
+import { PdfColorSpace } from './../enum';
+import { PdfBrush } from './pdf-brush';
+/**
+ * Represents a brush that fills any object with a solid color.
+ * ```typescript
+ * // create a new PDF document
+ * let document : PdfDocument = new PdfDocument();
+ * // add a pages to the document
+ * let page1 : PdfPage = document.pages.add();
+ * // set font
+ * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+ * // set brush
+ * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+ * // draw the text
+ * page1.graphics.drawString('Hello World', font, blackBrush, new PointF(10, 10));
+ * // save the document
+ * document.save('output.pdf');
+ * // destroy the document
+ * document.destroy();
+ * ```
+ */
+export declare class PdfSolidBrush extends PdfBrush {
+    /**
+     * The `colour` of the brush.
+     * @private
+     */
+    pdfColor: PdfColor;
+    /**
+     * Indicates if the brush is `immutable`.
+     * @private
+     */
+    private bImmutable;
+    /**
+     * The `color space` of the brush.
+     * @private
+     */
+    private colorSpace;
+    /**
+     * Initializes a new instance of the `PdfSolidBrush` class.
+     * ```typescript
+     * // create a new PDF document
+     * let document : PdfDocument = new PdfDocument();
+     * // add a pages to the document
+     * let page1 : PdfPage = document.pages.add();
+     * // set font
+     * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+     * // set brush
+     * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+     * // draw the text
+     * page1.graphics.drawString('Hello World', font, blackBrush, new PointF(10, 10));
+     * // save the document
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     * @param color color of the brush
+     */
+    constructor(color: PdfColor);
+    /**
+     * Gets or sets the `color` of the brush.
+     * @private
+     */
+    color: PdfColor;
+    /**
+     * `Monitors` the changes of the brush and modify PDF state respectively.
+     * @private
+     */
+    monitorChanges(brush: PdfBrush, streamWriter: PdfStreamWriter, getResources: GetResourceEventHandler, saveChanges: boolean, currentColorSpace: PdfColorSpace): boolean;
+    /**
+     * `Resets` the changes, which were made by the brush.
+     * @private
+     */
+    resetChanges(streamWriter: PdfStreamWriter): void;
+}

package/dist/ts/implementation/graphics/brushes/pdf-solid-brush.ts

@@ -0,0 +1,107 @@
+import { PdfColor } from './../pdf-color';
+import { PdfStreamWriter } from './../../input-output/pdf-stream-writer';
+import { GetResourceEventHandler } from './../pdf-graphics';
+import { PdfColorSpace } from './../enum';
+import { PdfBrush } from './pdf-brush';
+/**
+ * Represents a brush that fills any object with a solid color.
+ * ```typescript
+ * // create a new PDF document
+ * let document : PdfDocument = new PdfDocument();
+ * // add a pages to the document
+ * let page1 : PdfPage = document.pages.add();
+ * // set font
+ * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+ * // set brush
+ * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+ * // draw the text
+ * page1.graphics.drawString('Hello World', font, blackBrush, new PointF(10, 10));
+ * // save the document
+ * document.save('output.pdf');
+ * // destroy the document
+ * document.destroy();
+ * ```
+ */
+export class PdfSolidBrush extends PdfBrush {
+    //Fields
+    /**
+     * The `colour` of the brush.
+     * @private
+     */
+    public pdfColor : PdfColor;
+    /**
+     * Indicates if the brush is `immutable`.
+     * @private
+     */
+    private bImmutable : boolean;
+    /**
+     * The `color space` of the brush.
+     * @private
+     */
+    private colorSpace : PdfColorSpace;
+    //Constructors
+    /**
+     * Initializes a new instance of the `PdfSolidBrush` class.
+     * ```typescript
+     * // create a new PDF document
+     * let document : PdfDocument = new PdfDocument();
+     * // add a pages to the document
+     * let page1 : PdfPage = document.pages.add();
+     * // set font
+     * let font : PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 20);
+     * // set brush
+     * let blackBrush : PdfSolidBrush = new PdfSolidBrush(new PdfColor(0, 0, 0));
+     * // draw the text
+     * page1.graphics.drawString('Hello World', font, blackBrush, new PointF(10, 10));
+     * // save the document
+     * document.save('output.pdf');
+     * // destroy the document
+     * document.destroy();
+     * ```
+     * @param color color of the brush
+     */
+    public constructor(color : PdfColor) {
+        super();
+        this.pdfColor = color;
+    }
+    //Properties
+    /**
+     * Gets or sets the `color` of the brush.
+     * @private
+     */
+    public get color() : PdfColor {
+        return this.pdfColor;
+    }
+    public set color(value : PdfColor) {
+        this.pdfColor = value;
+    }
+    //Implementation
+    /**
+     * `Monitors` the changes of the brush and modify PDF state respectively.
+     * @private
+     */
+    public monitorChanges(brush : PdfBrush, streamWriter : PdfStreamWriter, getResources : GetResourceEventHandler,
+                          saveChanges : boolean, currentColorSpace : PdfColorSpace) : boolean {
+        if (streamWriter == null) {
+            throw new Error('ArgumentNullException:streamWriter');
+        }
+        let diff : boolean = false;
+        if (brush == null) {
+            diff = true;
+            streamWriter.setColorAndSpace(this.pdfColor, currentColorSpace, false);
+            return diff;
+        } else {
+            let sBrush : PdfSolidBrush = brush as PdfSolidBrush;
+            diff = true;
+            streamWriter.setColorAndSpace(this.pdfColor, currentColorSpace, false);
+            return diff;
+        }
+    }
+    /**
+     * `Resets` the changes, which were made by the brush.
+     * @private
+     */
+    public resetChanges(streamWriter : PdfStreamWriter) : void {
+        streamWriter.setColorAndSpace(new PdfColor(0, 0, 0), PdfColorSpace.Rgb, false);
+    }
+}

package/dist/ts/implementation/graphics/brushes/pdf-tiling-brush.d.ts

@@ -0,0 +1,161 @@
+/**
+ * PdfTilingBrush.ts class for EJ2-PDF
+ */
+import { PdfStreamWriter } from './../../input-output/pdf-stream-writer';
+import { GetResourceEventHandler } from './../pdf-graphics';
+import { PdfColorSpace } from './../enum';
+import { PdfBrush } from './pdf-brush';
+import { PointF, SizeF, Rectangle } from './../../drawing/pdf-drawing';
+import { IPdfWrapper } from '../../../interfaces/i-pdf-wrapper';
+import { PdfGraphics } from './../pdf-graphics';
+import { PdfResources } from './../pdf-resources';
+import { PdfPage } from './../../pages/pdf-page';
+import { IPdfPrimitive } from './../../../interfaces/i-pdf-primitives';
+/**
+ * `PdfTilingBrush` Implements a colored tiling brush.
+ */
+export declare class PdfTilingBrush extends PdfBrush implements IPdfWrapper {
+    /**
+     * Local variable to store rectanble box.
+     * @private
+     */
+    private mBox;
+    /**
+     * Local variable to store graphics.
+     * @private
+     */
+    private mGraphics;
+    /**
+     * Local variable to store brush Stream.
+     * @private
+     */
+    private brushStream;
+    /**
+     * Local variable to store brush Stream.
+     * @private
+     */
+    private tempBrushStream;
+    /**
+     * Local variable to store resources.
+     * @private
+     */
+    private mResources;
+    /**
+     * Local variable to store Stroking.
+     * @private
+     */
+    private mStroking;
+    /**
+     * Local variable to store the page.
+     * @private
+     */
+    private mPage;
+    /**
+     * Local variable to store the tile start location.
+     * @private
+     */
+    private mLocation;
+    /**
+     * Local variable to store the Matrix.
+     * @private
+     */
+    private mTransformationMatrix;
+    /**
+     * Local variable to store the dictionary properties.
+     * @private
+     */
+    private mDictionaryProperties;
+    /**
+     * Initializes a new instance of the `PdfTilingBrush` class.
+     * @public
+     */
+    constructor(rectangle: Rectangle);
+    /**
+     * Initializes a new instance of the `PdfTilingBrush` class.
+     * @public
+     */
+    constructor(size: SizeF);
+    /**
+     * Initializes a new instance of the `PdfTilingBrush` class.
+     * @public
+     */
+    constructor(size: SizeF, page: PdfPage);
+    /**
+     * Initializes a new instance of the `PdfTilingBrush` class.
+     * @public
+     */
+    constructor(rectangle: Rectangle, page: PdfPage);
+    /**
+     * Initializes a new instance of the `PdfTilingBrush` class.
+     * @private
+     * @param rectangle The size of the smallest brush cell.
+     * @param page The Current Page Object.
+     * @param location The Tile start location.
+     * @param matrix The matrix.
+     */
+    private initialize;
+    /**
+     * Location representing the start position of the tiles.
+     * @public
+     */
+    location: PointF;
+    /**
+     * Sets the obligatory fields.
+     * @private
+     */
+    private setObligatoryFields;
+    /**
+     * Sets the BBox coordinates.
+     * @private
+     */
+    private setBox;
+    /**
+     * Gets the boundary box of the smallest brush cell.
+     * @public
+     */
+    readonly rectangle: Rectangle;
+    /**
+     * Gets the size of the smallest brush cell.
+     * @public
+     */
+    readonly size: SizeF;
+    /**
+     * Gets Graphics context of the brush.
+     */
+    readonly graphics: PdfGraphics;
+    /**
+     * Gets the resources and modifies the template dictionary.
+     * @public
+     */
+    getResources(): PdfResources;
+    /**
+     * Gets or sets a value indicating whether this PdfTilingBrush
+     * is used for stroking operations.
+     */
+    stroking: boolean;
+    /**
+     * Creates a new copy of a brush.
+     * @public
+     */
+    clone(): PdfBrush;
+    /**
+     * Monitors the changes of the brush and modify PDF state respectfully.
+     * @param brush The brush
+     * @param streamWriter The stream writer
+     * @param getResources The get resources delegate.
+     * @param saveChanges if set to true the changes should be saved anyway.
+     * @param currentColorSpace The current color space.
+     */
+    monitorChanges(brush: PdfBrush, streamWriter: PdfStreamWriter, getResources: GetResourceEventHandler, saveChanges: boolean, currentColorSpace: PdfColorSpace): boolean;
+    /**
+     * Resets the changes, which were made by the brush.
+     * In other words resets the state to the initial one.
+     * @param streamWriter The stream writer.
+     */
+    resetChanges(streamWriter: PdfStreamWriter): void;
+    /**
+     * Gets the `element`.
+     * @public
+     */
+    readonly element: IPdfPrimitive;
+}