@syncfusion/ej2-pdf-export 20.2.45 → 20.3.56

package/dist/ts/implementation/graphics/brushes/pdf-color-blend.ts

@@ -0,0 +1,295 @@
+/**
+ * PdfColorBlend.ts class for EJ2-PDF
+ */
+import { PdfColorSpace } from './../enum';
+import { PdfColor } from './../pdf-color';
+import { PdfBrush } from './pdf-brush';
+import { PdfFunction } from './../../general/functions/pdf-function';
+import { PdfSampledFunction} from './../../general/functions/pdf-sampled-function';
+import { PdfBlend } from './pdf-blend';
+/**
+ * `PdfColorBlend` Represents the arrays of colors and positions used for
+ *  interpolating color blending in a multicolor gradient.
+ * @private
+ */
+export class PdfColorBlend extends PdfBlend {
+    //Fields
+    /**
+     * Array of colors.
+     * @private
+     */
+    private mcolors: PdfColor[];
+    /**
+     * Local variable to store the brush.
+     */
+    private mbrush: PdfBrush;
+    //Constructor
+    /**
+     * Initializes a new instance of the `PdfColorBlend` class.
+     * @public
+     */
+    public constructor()
+    /**
+     * Initializes a new instance of the `PdfColorBlend` class.
+     * @public
+     */
+    public constructor(count: number)
+    public constructor(count?: number) {
+        super();
+        if (typeof count === 'number') {
+            super(count);
+        }
+    }
+    //Properties
+    /**
+     * Gets or sets the array of colors.
+     * @public
+     */
+    public get colors(): PdfColor[] {
+        return this.mcolors;
+    }
+    public set colors(value: PdfColor[])  {
+        if ((value == null)) {
+            throw new Error('ArgumentNullException : Colors');
+        }
+        this.mcolors = value;
+    }
+    //Implementation
+    /**
+     * Gets the function.
+     * @param colorSpace The color space.
+     * @public
+     */
+    public getFunction(colorSpace: PdfColorSpace): PdfFunction {
+        let domain: number[] = [ 0, 1];
+        let colourComponents: number = this.getColorComponentsCount(colorSpace);
+        let maxComponentValue: number = this.getMaxComponentValue(colorSpace);
+        let range: number[] = this.setRange(colourComponents, maxComponentValue);
+        let func: PdfSampledFunction = null;
+        if ((this.mbrush == null && typeof this.mbrush === 'undefined')) {
+            let sizes: number[] = [1];
+            let samplesCount: number;
+            let step: number = 1;
+            if (this.positions.length === 2) {
+                samplesCount = 2;
+            } else {
+                let positions: number[] = this.positions;
+                let intervals: number[] = this.getIntervals(positions);
+                let gcd: number = this.gcd(intervals);
+                step = gcd;
+                samplesCount = ((<number>((1 / gcd))) + 1);
+            }
+            sizes[0] = samplesCount;
+            let samples: number[] = this.getSamplesValues(colorSpace, samplesCount, maxComponentValue, step);
+            func = new PdfSampledFunction(domain, range, sizes, samples);
+            return func;
+        }
+        return func;
+    }
+    /**
+     * 'cloneColorBlend' Clones this instance.
+     * @public
+     */
+    public cloneColorBlend(): PdfColorBlend {
+        let cBlend: PdfColorBlend = this;
+        if ((this.mcolors != null && typeof this.mcolors !== 'undefined')) {
+            cBlend.colors = (<PdfColor[]>(this.mcolors));
+        }
+        if ((this.positions != null && typeof this.positions !== 'undefined')) {
+            cBlend.positions = (<number[]>(this.positions));
+        }
+        return cBlend;
+    }
+    /**
+     * Sets the range.
+     * @param colourComponents The colour components.
+     * @param maxValue The max value.
+     */
+    private setRange(colourComponents: number, maxValue: number): number[] {
+        let range: number[] = [(colourComponents * 2)];
+        for (let i: number = 0; (i < colourComponents); ++i) {
+            range[(i * 2)] = 0;
+            range[((i * 2) + 1)] = 1;
+        }
+        return range;
+    }
+    /**
+     * Calculates the color components count according to colour space.
+     * @param colorSpace The color space.
+     */
+    private getColorComponentsCount(colorSpace: PdfColorSpace): number {
+        let count: number = 0;
+        switch (colorSpace) {
+            case PdfColorSpace.Rgb:
+                count = 3;
+                break;
+            case PdfColorSpace.Cmyk:
+                count = 4;
+                break;
+            case PdfColorSpace.GrayScale:
+                count = 1;
+                break;
+            default:
+                throw new Error('ArgumentException - Unsupported color space: ' + colorSpace + ' colorSpace');
+        }
+        return count;
+    }
+    /**
+     * Gets samples values for specified colour space.
+     * @param colorSpace The color space.
+     * @param sampleCount The sample count.
+     * @param maxComponentValue The max component value.
+     * @param step The step.
+     */
+    private getSamplesValues(colorSpace: PdfColorSpace, sampleCount: number, maxComponentValue: number, step: number): number[] {
+        let values: number[];
+        switch (colorSpace) {
+            case PdfColorSpace.GrayScale:
+                values = this.getGrayscaleSamples(sampleCount, maxComponentValue, step);
+                break;
+            case PdfColorSpace.Cmyk:
+                values = this.getCmykSamples(sampleCount, maxComponentValue, step);
+                break;
+            case PdfColorSpace.Rgb:
+                values = this.getRgbSamples(sampleCount, maxComponentValue, step);
+                break;
+            default:
+                throw new Error('ArgumentException - Unsupported color space: ' + colorSpace + ' colorSpace');
+        }
+        return values;
+    }
+    /**
+     * Gets the grayscale samples.
+     * @param sampleCount The sample count.
+     * @param maxComponentValue The max component value.
+     * @param step The step.
+     */
+    private getGrayscaleSamples(sampleCount: number, maxComponentValue: number, step: number): number[] {
+        let values: number[] = [(sampleCount * 2)];
+        for (let i: number = 0; (i < sampleCount); ++i) {
+            let color: PdfColor = this.getNextColor(i, step, PdfColorSpace.GrayScale);
+            let index: number = (i * 2);
+        }
+        return values;
+    }
+    /**
+     * Gets the RGB samples.
+     * @param sampleCount The sample count.
+     * @param maxComponentValue The max component value.
+     * @param step The step.
+     */
+    private getRgbSamples(sampleCount: number, maxComponentValue: number, step: number): number[] {
+        let values: number[] = [(sampleCount * 3)];
+        for (let i: number = 0; (i < sampleCount); ++i) {
+            let color: PdfColor = this.getNextColor(i, step, PdfColorSpace.Rgb);
+            let index: number = (i * 3);
+            values[index] = color.r;
+            values[(index + 1)] = color.g;
+            values[(index + 2)] = color.b;
+        }
+        return values;
+    }
+    /**
+     * Gets the CMYK samples.
+     * @param sampleCount The sample count.
+     * @param maxComponentValue The max component value.
+     * @param step The step.
+     */
+    private getCmykSamples(sampleCount: number, maxComponentValue: number, step: number): number[] {
+        let values: number[] = [(sampleCount * 4)];
+        for (let i: number = 0; (i < sampleCount); i++) {
+            let color: PdfColor = this.getNextColor(i, step, PdfColorSpace.Cmyk);
+            let index: number = (i * 4);
+            values[index] = (<number>((color.c * maxComponentValue)));
+            values[(index + 1)] = (<number>((color.m * maxComponentValue)));
+            values[(index + 2)] = (<number>((color.y * maxComponentValue)));
+            values[(index + 3)] = (<number>((color.k * maxComponentValue)));
+        }
+        return values;
+    }
+    /**
+     * Calculates the color that should be at the specified index.
+     * @param index The index.
+     * @param step The step.
+     * @param colorSpace The color space.
+     */
+    private getNextColor(index: number, step: number, colorSpace: PdfColorSpace): PdfColor {
+        let position: number = (step * index);
+        let indexHi: number;
+        let indexLow: number;
+        let result : { indexLow : number, indexHi : number} = this.getIndices(position, indexLow, indexHi);
+        indexLow = result.indexLow;
+        indexHi = result.indexHi;
+        let color: PdfColor;
+        if (indexLow === indexHi) {
+            color = this.mcolors[indexLow];
+        } else {
+            let positionLow: number = this.positions[indexLow];
+            let positionHi: number = this.positions[indexHi];
+            let colorLow: PdfColor = this.mcolors[indexLow];
+            let colorHi: PdfColor = this.mcolors[indexHi];
+            let t: number = ((position - positionLow) / (positionHi - positionLow));
+            color = this.interpolate(t, colorLow, colorHi, colorSpace);
+        }
+        return color;
+    }
+    /**
+     * Gets the indices.
+     * @param position The position.
+     * @param indexLow The index low.
+     * @param indexHi The index hi.
+     */
+    private getIndices(position: number, indexLow: number, indexHi: number) : { indexLow : number, indexHi : number} {
+        let positions: number[] = this.positions;
+        indexLow = 0;
+        indexHi = 0;
+        for (let i: number = 0; (i < this.mcolors.length); ++i) {
+            let currPos: number = positions[i];
+            if ((currPos === position)) {
+                indexHi = i;
+                indexLow = i;
+                break;
+            } else if ((currPos > position)) {
+                indexHi = i;
+                break;
+            }
+            indexLow = i;
+            indexHi = i;
+        }
+        return { indexLow : indexLow, indexHi : indexHi };
+    }
+    /**
+     * Calculates the max component value.
+     * @param colorSpace The color space.
+     */
+    private getMaxComponentValue(colorSpace: PdfColorSpace) : number {
+        let result: number = 0;
+        switch (colorSpace) {
+            case PdfColorSpace.Cmyk:
+            case PdfColorSpace.Rgb:
+                result = 255;
+                break;
+            case PdfColorSpace.GrayScale:
+                result = 65535;
+                break;
+            default:
+                throw new Error('ArgumentException - Unsupported color space: ' + colorSpace + 'colorSpace');
+        }
+        return result;
+    }
+    /**
+     * Gets an intervals array from the positions array.
+     * @param positions The positions array.
+     */
+    private getIntervals(positions: number[]): number[] {
+        let count: number = positions.length;
+        let intervals: number[] = [(count - 1)];
+        let prev: number = positions[0];
+        for (let i: number = 1; (i < count); ++i) {
+            let v: number = positions[i];
+            intervals[(i - 1)] = (v - prev);
+            prev = v;
+        }
+        return intervals;
+    }
+}

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

@@ -0,0 +1,311 @@
+/**
+ * PdfGradientBrush.ts class for EJ2-PDF
+ */
+import { PdfStreamWriter } from './../../input-output/pdf-stream-writer';
+import { GetResourceEventHandler } from './../pdf-graphics';
+import { PdfColorSpace } from './../enum';
+import { PdfColor } from './../pdf-color';
+import { PdfBrush } from './pdf-brush';
+import { IPdfWrapper } from '../../../interfaces/i-pdf-wrapper';
+import { PdfDictionary} from '../../primitives/pdf-dictionary';
+import { PdfTransformationMatrix } from './../pdf-transformation-matrix';
+import { DictionaryProperties } from './../../input-output/pdf-dictionary-properties';
+import { PdfBoolean } from './../../primitives/pdf-boolean';
+import { PdfArray } from './../../primitives/pdf-array';
+import { PdfName } from '../../primitives/pdf-name';
+import { PdfNumber} from '../../primitives/pdf-number';
+import { PdfReferenceHolder } from '../../primitives/pdf-reference';
+import { IPdfPrimitive } from './../../../interfaces/i-pdf-primitives';
+import { PdfFunction } from './../../general/functions/pdf-function';
+import { PdfResources } from './../pdf-resources';
+/**
+ * `PdfGradientBrush` class provides objects used to fill the interiors of graphical shapes such as rectangles,
+ * ellipses, pies, polygons, and paths.
+ * @private
+ */
+export abstract class PdfGradientBrush extends PdfBrush implements IPdfWrapper {
+    // Fields
+    /**
+     * Local variable to store the background color.
+     * @private
+     */
+    private mbackground : PdfColor = new PdfColor(255, 255, 255);
+    /**
+     * Local variable to store the stroking color.
+     * @private
+     */
+    private mbStroking : boolean = false;
+    /**
+     * Local variable to store the dictionary.
+     * @private
+     */
+    private mpatternDictionary : PdfDictionary;
+    /**
+     * Local variable to store the shading.
+     * @private
+     */
+    private mshading : PdfDictionary;
+    /**
+     * Local variable to store the Transformation Matrix.
+     * @private
+     */
+    private mmatrix: PdfTransformationMatrix;
+    /**
+     * Local variable to store the colorSpace.
+     * @private
+     */
+    private mcolorSpace: PdfColorSpace;
+    /**
+     * Local variable to store the function.
+     * @private
+     */
+    private mfunction: PdfFunction = null;
+    /**
+     * Local variable to store the DictionaryProperties.
+     * @private
+     */
+    private dictionaryProperties : DictionaryProperties = new DictionaryProperties();
+    //Constructor
+    /**
+     * Initializes a new instance of the `PdfGradientBrush` class.
+     * @public
+     */
+    /* tslint:disable-next-line:max-line-length */
+    public constructor(shading: PdfDictionary) {
+        super();
+        this.mpatternDictionary = new PdfDictionary();
+        this.mpatternDictionary.items.setValue(this.dictionaryProperties.type, new PdfName(this.dictionaryProperties.pattern));
+        this.mpatternDictionary.items.setValue(this.dictionaryProperties.patternType, new PdfNumber(2));
+        this.shading = shading;
+        this.colorSpace = PdfColorSpace.Rgb;
+    }
+    //Properties
+    /**
+     * Gets or sets the background color of the brush.
+     * @public
+     */
+    public get background(): PdfColor {
+        return this.mbackground;
+    }
+    public set background(value: PdfColor) {
+        this.mbackground = value;
+        let sh: PdfDictionary = this.shading;
+        if (value.isEmpty) {
+            sh.remove(this.dictionaryProperties.background);
+        } else {
+            sh.items.setValue(this.dictionaryProperties.background, value.toArray(this.colorSpace));
+        }
+    }
+    /**
+     * Gets or sets a value indicating whether use anti aliasing algorithm.
+     * @public
+     */
+    public get antiAlias(): boolean {
+        let sh: PdfDictionary = this.shading;
+        let aa: PdfBoolean = (<PdfBoolean>(sh.items.getValue(this.dictionaryProperties.antiAlias)));
+        return aa.value;
+    }
+    public set antiAlias(value: boolean)  {
+        let sh: PdfDictionary = this.shading;
+        let aa: PdfBoolean = (<PdfBoolean>(sh.items.getValue(this.dictionaryProperties.antiAlias)));
+        if ((aa == null && typeof aa === 'undefined')) {
+            aa = new PdfBoolean(value);
+            sh.items.setValue(this.dictionaryProperties.antiAlias, aa);
+        } else {
+            aa.value = value;
+        }
+    }
+    /**
+     * Gets or sets the function of the brush.
+     * @protected
+     */
+    protected get function(): PdfFunction {
+        return this.mfunction;
+    }
+    protected set function(value: PdfFunction)  {
+        this.mfunction = value;
+        if (value != null && typeof value !== 'undefined') {
+            this.shading.items.setValue(this.dictionaryProperties.function, new PdfReferenceHolder(this.mfunction));
+        } else {
+            this.shading.remove(this.dictionaryProperties.function);
+        }
+    }
+    /**
+     * Gets or sets the boundary box of the brush.
+     * @protected
+     */
+    protected get bBox(): PdfArray {
+        let sh: PdfDictionary = this.shading;
+        let box: PdfArray = (<PdfArray>(sh.items.getValue(this.dictionaryProperties.bBox)));
+        return box;
+    }
+    protected set bBox(value: PdfArray)  {
+        let sh: PdfDictionary = this.shading;
+        if (value == null && typeof value === 'undefined') {
+            sh.remove(this.dictionaryProperties.bBox);
+        } else {
+            sh.items.setValue(this.dictionaryProperties.bBox, value);
+        }
+    }
+    /**
+     * Gets or sets the color space of the brush.
+     * @public
+     */
+    public get colorSpace(): PdfColorSpace {
+        return this.mcolorSpace;
+    }
+    public set colorSpace(value: PdfColorSpace)  {
+        let colorSpace: IPdfPrimitive = this.shading.items.getValue(this.dictionaryProperties.colorSpace);
+        if ((value !== this.mcolorSpace) || (colorSpace == null)) {
+            this.mcolorSpace = value;
+            let csValue: string = this.colorSpaceToDeviceName(value);
+            this.shading.items.setValue(this.dictionaryProperties.colorSpace, new PdfName(csValue));
+        }
+    }
+    /**
+     * Gets or sets a value indicating whether this PdfGradientBrush is stroking.
+     * @public
+     */
+    public get stroking(): boolean {
+        return this.mbStroking;
+    }
+    public set stroking(value: boolean)  {
+        this.mbStroking = value;
+    }
+    /**
+     * Gets the pattern dictionary.
+     * @protected
+     */
+    protected get patternDictionary(): PdfDictionary {
+        if (this.mpatternDictionary == null) {
+            this.mpatternDictionary = new PdfDictionary();
+        }
+        return this.mpatternDictionary;
+    }
+    /**
+     * Gets or sets the shading dictionary.
+     * @protected
+     */
+    protected get shading(): PdfDictionary {
+        return this.mshading;
+    }
+    protected set shading(value: PdfDictionary)  {
+        if (value == null) {
+            throw new Error('ArgumentNullException : Shading');
+        }
+        if (value !== this.mshading) {
+            this.mshading = value;
+            this.patternDictionary.items.setValue(this.dictionaryProperties.shading, new PdfReferenceHolder(this.mshading));
+        }
+    }
+    /**
+     * Gets or sets the transformation matrix.
+     * @public
+     */
+    public get matrix(): PdfTransformationMatrix {
+        return this.mmatrix;
+    }
+    public set matrix(value: PdfTransformationMatrix)  {
+        if (value == null) {
+            throw new Error('ArgumentNullException : Matrix');
+        }
+        if (value !== this.mmatrix) {
+            this.mmatrix = value.clone();
+            let m: PdfArray = new PdfArray(this.mmatrix.matrix.elements);
+            this.mpatternDictionary.items.setValue(this.dictionaryProperties.matrix, m);
+        }
+    }
+    //Overrides
+    /**
+     * 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.
+     */
+    /* tslint:disable-next-line:max-line-length */
+    public monitorChanges(brush: PdfBrush, streamWriter: PdfStreamWriter, getResources: GetResourceEventHandler, saveChanges: boolean, currentColorSpace: PdfColorSpace): boolean {
+        let diff: boolean = false;
+        if (brush instanceof PdfGradientBrush) {
+            if ((this.colorSpace !== currentColorSpace)) {
+                this.colorSpace = currentColorSpace;
+                this.resetFunction();
+            }
+            //  Set the /Pattern colour space.
+            streamWriter.setColorSpace('Pattern', this.mbStroking);
+            //  Set the pattern for non-stroking operations.
+            let resources : PdfResources = getResources.getResources();
+            let name: PdfName = resources.getName(this);
+            streamWriter.setColourWithPattern(null, name, this.mbStroking);
+            diff = true;
+        }
+        return diff;
+    }
+    /**
+     * Resets the changes, which were made by the brush.
+     * In other words resets the state to the initial one.
+     * @param streamWriter The stream writer.
+     */
+    public resetChanges(streamWriter: PdfStreamWriter): void {
+        //  Unable reset.
+    }
+    //Implementation
+    /**
+     * Converts colorspace enum to a PDF name.
+     * @param colorSpace The color space enum value.
+     */
+    private colorSpaceToDeviceName(colorSpace: PdfColorSpace): string {
+        let result: string;
+        switch (colorSpace) {
+            case PdfColorSpace.Rgb:
+                result = 'DeviceRGB';
+                break;
+        }
+        return result;
+    }
+    /**
+     * Resets the pattern dictionary.
+     * @param dictionary A new pattern dictionary.
+     */
+    protected resetPatternDictionary(dictionary: PdfDictionary) : void {
+        this.mpatternDictionary = dictionary;
+    }
+    /**
+     * Resets the function.
+     */
+    public abstract resetFunction() : void;
+    /**
+     * Clones the anti aliasing value.
+     * @param brush The brush.
+     */
+    protected cloneAntiAliasingValue(brush: PdfGradientBrush) : void {
+        if ((brush == null)) {
+            throw new Error('ArgumentNullException : brush');
+        }
+        let sh: PdfDictionary = this.shading;
+        let aa: PdfBoolean = (<PdfBoolean>(sh.items.getValue(this.dictionaryProperties.antiAlias)));
+        if ((aa != null)) {
+            brush.shading.items.setValue(this.dictionaryProperties.antiAlias, new PdfBoolean(aa.value));
+        }
+    }
+    /**
+     * Clones the background value.
+     * @param brush The brush.
+     */
+    protected cloneBackgroundValue(brush: PdfGradientBrush) : void {
+        let background: PdfColor = this.background;
+        if (!background.isEmpty) {
+            brush.background = background;
+        }
+    }
+    /* tslint:enable */
+    // IPdfWrapper Members
+    /**
+     * Gets the `element`.
+     * @private
+     */
+    public get element() : IPdfPrimitive {
+        return this.patternDictionary;
+    }
+}