@syncfusion/ej2-pdf 1.0.23 → 23.1.38

package/src/pdf/core/fonts/pdf-string-format.d.ts

@@ -0,0 +1,236 @@
+import { PdfTextAlignment, PdfTextDirection, PdfSubSuperScript, _PdfWordWrapType } from './../enumerator';
+/**
+ * Represents the text layout information.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Gets the first page
+ * let page: PdfPage = document.getPage(0) as PdfPage;
+ * // Create a new PDF standard font
+ * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+ * // Create a new PDF string format
+ * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right, PdfVerticalAlignment.bottom);
+ * // Draw the text
+ * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+export declare class PdfStringFormat {
+    alignment: PdfTextAlignment;
+    lineLimit: boolean;
+    lineAlignment: PdfVerticalAlignment;
+    characterSpacing: number;
+    wordSpacing: number;
+    lineSpacing: number;
+    clipPath: boolean;
+    horizontalScalingFactor: number;
+    firstLineIndent: number;
+    measureTrailingSpaces: boolean;
+    noClip: boolean;
+    _internalParagraphIndent: number;
+    textDirection: PdfTextDirection;
+    rightToLeft: boolean;
+    _pdfSubSuperScript: PdfSubSuperScript;
+    _wordWrapType: _PdfWordWrapType;
+    /**
+     * Initializes a new instance of the `PdfStringFormat` class.
+     *
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Gets the first page
+     * let page: PdfPage = document.getPage(0) as PdfPage;
+     * // Create a new PDF standard font
+     * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+     * // Create a new PDF string format
+     * let format: PdfStringFormat = new PdfStringFormat();
+     * // Draw the text
+     * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    constructor();
+    /**
+     * Initializes a new instance of the `PdfStringFormat` class.
+     *
+     * @param {PdfTextAlignment} alignment PdfTextAlignment.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Gets the first page
+     * let page: PdfPage = document.getPage(0) as PdfPage;
+     * // Create a new PDF standard font
+     * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+     * // Create a new PDF string format
+     * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+     * // Draw the text
+     * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    constructor(alignment: PdfTextAlignment);
+    /**
+     * Initializes a new instance of the `PdfStringFormat` class.
+     *
+     * @param {PdfTextAlignment} alignment PdfTextAlignment.
+     * @param {PdfVerticalAlignment} lineAlignment PdfVerticalAlignment.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Gets the first page
+     * let page: PdfPage = document.getPage(0) as PdfPage;
+     * // Create a new PDF standard font
+     * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+     * // Create a new PDF string format
+     * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right, PdfVerticalAlignment.bottom);
+     * // Draw the text
+     * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    constructor(alignment: PdfTextAlignment, lineAlignment: PdfVerticalAlignment);
+    /**
+     * Gets the paragraph indent from string format.
+     *
+     * @returns {number} Returns the paragraph indent.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Gets the first page
+     * let page: PdfPage = document.getPage(0) as PdfPage;
+     * // Create a new PDF standard font
+     * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+     * // Create a new PDF string format
+     * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+     * // Get the default paragraph indent
+     * let paragraph: number = format.paragraphIndent;
+     * // Draw the text
+     * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    /**
+    * Sets the paragraph indent to string format.
+    *
+    * @param {number} value paragraph indent.
+    * ```typescript
+    * // Load an existing PDF document
+    * let document: PdfDocument = new PdfDocument(data, password);
+    * // Gets the first page
+    * let page: PdfPage = document.getPage(0) as PdfPage;
+    * // Create a new PDF standard font
+    * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+    * // Create a new PDF string format
+    * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+    * // Set a new paragraph indent
+    * format.paragraphIndent = 20;
+    * // Draw the text
+    * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+    * // Save the document
+    * document.save('output.pdf');
+    * // Destroy the document
+    * document.destroy();
+    * ```
+    */
+    paragraphIndent: number;
+    /**
+     * Gets the subscript or superscript mode from string format.
+     *
+     * @returns {PdfSubSuperScript} Returns the subscript or superscript mode.
+     * ```typescript
+     * // Load an existing PDF document
+     * let document: PdfDocument = new PdfDocument(data, password);
+     * // Gets the first page
+     * let page: PdfPage = document.getPage(0) as PdfPage;
+     * // Create a new PDF standard font
+     * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+     * // Create a new PDF string format
+     * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+     * // Set a new paragraph indent
+     * format.paragraphIndent = 20;
+     * // Get the subscript or superscript mode
+     * let script: PdfSubSuperScript = format.subSuperScript;
+     * // Draw the text
+     * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+     * // Save the document
+     * document.save('output.pdf');
+     * // Destroy the document
+     * document.destroy();
+     * ```
+     */
+    /**
+    * Sets the subscript or superscript mode to string format.
+    *
+    * @param {PdfSubSuperScript} value subscript or superscript mode.
+    * ```typescript
+    * // Load an existing PDF document
+    * let document: PdfDocument = new PdfDocument(data, password);
+    * // Gets the first page
+    * let page: PdfPage = document.getPage(0) as PdfPage;
+    * // Create a new PDF standard font
+    * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+    * // Create a new PDF string format
+    * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+    * // Set a new paragraph indent
+    * format.paragraphIndent = 20;
+    * // Set the subscript or superscript mode
+    * format.subSuperScript = PdfSubSuperScript.subScript;
+    * // Draw the text
+    * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+    * // Save the document
+    * document.save('output.pdf');
+    * // Destroy the document
+    * document.destroy();
+    * ```
+    */
+    subSuperScript: PdfSubSuperScript;
+    _wordWrap: _PdfWordWrapType;
+}
+/**
+ * Public enum to define vertical alignment.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Gets the first page
+ * let page: PdfPage = document.getPage(0) as PdfPage;
+ * // Create a new PDF standard font
+ * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10, PdfFontStyle.regular);
+ * // Create a new PDF string format
+ * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right, PdfVerticalAlignment.top);
+ * // Draw the text
+ * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+export declare enum PdfVerticalAlignment {
+    /**
+     * Specifies the type of `top`.
+     */
+    top = 0,
+    /**
+     * Specifies the type of `middle`.
+     */
+    middle = 1,
+    /**
+     * Specifies the type of `bottom`.
+     */
+    bottom = 2
+}

package/src/pdf/core/fonts/pdf-string-format.js

@@ -0,0 +1,213 @@
+import { PdfSubSuperScript, _PdfWordWrapType } from './../enumerator';
+/**
+ * Represents the text layout information.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Gets the first page
+ * let page: PdfPage = document.getPage(0) as PdfPage;
+ * // Create a new PDF standard font
+ * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+ * // Create a new PDF string format
+ * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right, PdfVerticalAlignment.bottom);
+ * // Draw the text
+ * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+var PdfStringFormat = /** @class */ (function () {
+    function PdfStringFormat(arg1, arg2) {
+        this.horizontalScalingFactor = 100.0;
+        this.rightToLeft = false;
+        this._wordWrapType = _PdfWordWrapType.word;
+        this.lineLimit = true;
+        if (typeof arg1 !== 'undefined') {
+            this.alignment = arg1;
+        }
+        if (typeof arg2 !== 'undefined') {
+            this.lineAlignment = arg2;
+        }
+        else {
+            this.lineAlignment = PdfVerticalAlignment.top;
+        }
+        this.characterSpacing = 0;
+        this.wordSpacing = 0;
+        this.lineSpacing = 0;
+        this.clipPath = false;
+        this.firstLineIndent = 0;
+        this._internalParagraphIndent = 0;
+        this.measureTrailingSpaces = false;
+        this.noClip = false;
+    }
+    Object.defineProperty(PdfStringFormat.prototype, "paragraphIndent", {
+        /**
+         * Gets the paragraph indent from string format.
+         *
+         * @returns {number} Returns the paragraph indent.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the first page
+         * let page: PdfPage = document.getPage(0) as PdfPage;
+         * // Create a new PDF standard font
+         * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+         * // Create a new PDF string format
+         * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+         * // Get the default paragraph indent
+         * let paragraph: number = format.paragraphIndent;
+         * // Draw the text
+         * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            return this._internalParagraphIndent;
+        },
+        /**
+         * Sets the paragraph indent to string format.
+         *
+         * @param {number} value paragraph indent.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the first page
+         * let page: PdfPage = document.getPage(0) as PdfPage;
+         * // Create a new PDF standard font
+         * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+         * // Create a new PDF string format
+         * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+         * // Set a new paragraph indent
+         * format.paragraphIndent = 20;
+         * // Draw the text
+         * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            this._internalParagraphIndent = value;
+            this.firstLineIndent = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfStringFormat.prototype, "subSuperScript", {
+        /**
+         * Gets the subscript or superscript mode from string format.
+         *
+         * @returns {PdfSubSuperScript} Returns the subscript or superscript mode.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the first page
+         * let page: PdfPage = document.getPage(0) as PdfPage;
+         * // Create a new PDF standard font
+         * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+         * // Create a new PDF string format
+         * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+         * // Set a new paragraph indent
+         * format.paragraphIndent = 20;
+         * // Get the subscript or superscript mode
+         * let script: PdfSubSuperScript = format.subSuperScript;
+         * // Draw the text
+         * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        get: function () {
+            if (typeof this._pdfSubSuperScript === 'undefined' || this._pdfSubSuperScript === null) {
+                return PdfSubSuperScript.none;
+            }
+            else {
+                return this._pdfSubSuperScript;
+            }
+        },
+        /**
+         * Sets the subscript or superscript mode to string format.
+         *
+         * @param {PdfSubSuperScript} value subscript or superscript mode.
+         * ```typescript
+         * // Load an existing PDF document
+         * let document: PdfDocument = new PdfDocument(data, password);
+         * // Gets the first page
+         * let page: PdfPage = document.getPage(0) as PdfPage;
+         * // Create a new PDF standard font
+         * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10);
+         * // Create a new PDF string format
+         * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right);
+         * // Set a new paragraph indent
+         * format.paragraphIndent = 20;
+         * // Set the subscript or superscript mode
+         * format.subSuperScript = PdfSubSuperScript.subScript;
+         * // Draw the text
+         * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+         * // Save the document
+         * document.save('output.pdf');
+         * // Destroy the document
+         * document.destroy();
+         * ```
+         */
+        set: function (value) {
+            this._pdfSubSuperScript = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PdfStringFormat.prototype, "_wordWrap", {
+        get: function () {
+            return this._wordWrapType;
+        },
+        set: function (value) {
+            this._wordWrapType = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return PdfStringFormat;
+}());
+export { PdfStringFormat };
+/**
+ * Public enum to define vertical alignment.
+ * ```typescript
+ * // Load an existing PDF document
+ * let document: PdfDocument = new PdfDocument(data, password);
+ * // Gets the first page
+ * let page: PdfPage = document.getPage(0) as PdfPage;
+ * // Create a new PDF standard font
+ * let font: PdfStandardFont = new PdfStandardFont(PdfFontFamily.Helvetica, 10, PdfFontStyle.regular);
+ * // Create a new PDF string format
+ * let format: PdfStringFormat = new PdfStringFormat(PdfTextAlignment.right, PdfVerticalAlignment.top);
+ * // Draw the text
+ * page.graphics.drawString('Helvetica', font, [0, 180, page.size[0], 40], undefined, new PdfBrush([0, 0, 255]), format);
+ * // Save the document
+ * document.save('output.pdf');
+ * // Destroy the document
+ * document.destroy();
+ * ```
+ */
+export var PdfVerticalAlignment;
+(function (PdfVerticalAlignment) {
+    /**
+     * Specifies the type of `top`.
+     */
+    PdfVerticalAlignment[PdfVerticalAlignment["top"] = 0] = "top";
+    /**
+     * Specifies the type of `middle`.
+     */
+    PdfVerticalAlignment[PdfVerticalAlignment["middle"] = 1] = "middle";
+    /**
+     * Specifies the type of `bottom`.
+     */
+    PdfVerticalAlignment[PdfVerticalAlignment["bottom"] = 2] = "bottom";
+})(PdfVerticalAlignment || (PdfVerticalAlignment = {}));

package/src/pdf/core/fonts/string-layouter.d.ts

@@ -0,0 +1,68 @@
+import { PdfStringFormat } from './pdf-string-format';
+import { PdfFont } from './pdf-standard-font';
+import { _PdfWordWrapType } from './../enumerator';
+export declare class _PdfStringLayouter {
+    _font: PdfFont;
+    _format: PdfStringFormat;
+    _size: number[];
+    _rectangle: number[];
+    _pageHeight: number;
+    _reader: _StringTokenizer;
+    _layout(text: string, font: PdfFont, format: PdfStringFormat, size: number[]): _PdfStringLayoutResult;
+    _initialize(text: string, font: PdfFont, format: PdfStringFormat, size: number[]): void;
+    _clear(): void;
+    _doLayout(): _PdfStringLayoutResult;
+    _getLineIndent(firstLine: boolean): number;
+    _getLineHeight(): number;
+    _getLineWidth(line: string): number;
+    _layoutLine(line: string, lineIndent: number): _PdfStringLayoutResult;
+    _addToLineResult(lineResult: _PdfStringLayoutResult, lines: _LineInfo[], line: string, lineWidth: number, breakType: _LineType): void;
+    _copyToResult(result: _PdfStringLayoutResult, lineResult: _PdfStringLayoutResult, lines: _LineInfo[], flag: number): {
+        success: boolean;
+        flag: number;
+    };
+    _finalizeResult(result: _PdfStringLayoutResult, lines: _LineInfo[]): void;
+    _trimLine(info: _LineInfo, firstLine: boolean): _LineInfo;
+    _getWrapType(): _PdfWordWrapType;
+}
+export declare class _PdfStringLayoutResult {
+    _layoutLines: _LineInfo[];
+    _remainder: string;
+    _size: number[];
+    _lineHeight: number;
+    readonly _actualSize: number[];
+    readonly _lines: _LineInfo[];
+    readonly _empty: boolean;
+    readonly _lineCount: number;
+}
+export declare class _LineInfo {
+    _text: string;
+    _width: number;
+    _lineType: _LineType;
+}
+export declare enum _LineType {
+    none = 0,
+    newLineBreak = 1,
+    layoutBreak = 2,
+    firstParagraphLine = 4,
+    lastParagraphLine = 8
+}
+export declare class _StringTokenizer {
+    _text: string;
+    _position: number;
+    static readonly _whiteSpace: string;
+    static readonly _tab: string;
+    static readonly _spaces: string[];
+    constructor(textValue: string);
+    readonly _length: number;
+    readonly _end: boolean;
+    _readLine(): string;
+    _peekLine(): string;
+    _readWord(): string;
+    _peekWord(): string;
+    _read(): string;
+    _read(count: number): string;
+    _peek(): string;
+    _close(): void;
+    _readToEnd(): string;
+}