@next2d/text 1.18.11 → 2.0.0

package/src/TextField/usecase/TextFieldCompositionEndUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description テキストフィールドのコンポジションエンドイベントを処理します。
+ *              Processes the composition end event of the text field.
+ *
+ * @param  {TextField} text_field
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField) => void;

package/src/TextField/usecase/TextFieldCompositionEndUseCase.js

@@ -0,0 +1,32 @@
+import { $textArea } from "../../TextUtil";
+import { execute as textFieldGetTextDataUseCase } from "../../TextField/usecase/TextFieldGetTextDataUseCase";
+/**
+ * @description テキストフィールドのコンポジションエンドイベントを処理します。
+ *              Processes the composition end event of the text field.
+ *
+ * @param  {TextField} text_field
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (text_field) => {
+    if (text_field.compositionEndIndex > -1) {
+        const textData = textFieldGetTextDataUseCase(text_field);
+        for (let idx = text_field.compositionStartIndex; idx < text_field.compositionEndIndex; ++idx) {
+            const textObject = textData.textTable[idx];
+            if (!textObject) {
+                continue;
+            }
+            textObject.textFormat.underline = false;
+        }
+        text_field.focusIndex = text_field.compositionEndIndex;
+    }
+    $textArea.blur();
+    $textArea.value = "";
+    if (text_field.focus) {
+        $textArea.focus();
+    }
+    text_field.selectIndex = -1;
+    text_field.compositionStartIndex = -1;
+    text_field.compositionEndIndex = -1;
+};

package/src/TextField/usecase/TextFieldCompositionUpdateUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description 新しい文字が入力されたときのイベント処理関数
+ *              Event processing function when a new character is entered
+ *
+ * @param  {TextField} text_field
+ * @param  {string} texts
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField, texts: string) => void;

package/src/TextField/usecase/TextFieldCompositionUpdateUseCase.js

@@ -0,0 +1,109 @@
+import { TextFormat } from "../../TextFormat";
+import { execute as textFieldGetTextDataUseCase } from "../../TextField/usecase/TextFieldGetTextDataUseCase";
+import { execute as textFieldDeleteTextUseCase } from "../../TextField/usecase/TextFieldDeleteTextUseCase";
+/**
+ * @description 新しい文字が入力されたときのイベント処理関数
+ *              Event processing function when a new character is entered
+ *
+ * @param  {TextField} text_field
+ * @param  {string} texts
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (text_field, texts) => {
+    if (text_field.compositionEndIndex > -1) {
+        const cacheIndex = text_field.compositionStartIndex;
+        text_field.focusIndex = text_field.compositionStartIndex;
+        text_field.selectIndex = text_field.compositionEndIndex - 1;
+        text_field.compositionStartIndex = -1;
+        textFieldDeleteTextUseCase(text_field);
+        // reset
+        text_field.compositionStartIndex = cacheIndex;
+        text_field.selectIndex = -1;
+    }
+    let textData = textFieldGetTextDataUseCase(text_field);
+    const textFormats = [];
+    const length = texts.length;
+    let newText = "";
+    if (2 > textData.textTable.length) {
+        newText = texts;
+        text_field.focusIndex = 1;
+        text_field.compositionStartIndex = 1;
+    }
+    else {
+        for (let idx = 1; idx < textData.textTable.length; ++idx) {
+            const textObject = textData.textTable[idx];
+            if (!textObject) {
+                continue;
+            }
+            if (text_field.compositionStartIndex === idx) {
+                for (let idx = 0; idx < length; ++idx) {
+                    textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                    newText += texts[idx];
+                }
+            }
+            switch (textObject.mode) {
+                case "break":
+                    textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                    newText += "\n";
+                    break;
+                case "text":
+                    textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                    newText += textObject.text;
+                    break;
+                default:
+                    continue;
+            }
+        }
+        // last text
+        if (text_field.compositionStartIndex === textData.textTable.length) {
+            const textObject = textData.textTable[text_field.compositionStartIndex - 1];
+            if (!textObject) {
+                return;
+            }
+            for (let idx = 0; idx < length; ++idx) {
+                textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                newText += texts[idx];
+            }
+        }
+    }
+    // update
+    if (textFormats.length) {
+        text_field.$textFormats = textFormats;
+    }
+    // fixed logic
+    text_field.text = newText;
+    // fixed logic
+    text_field.$textFormats = null;
+    textData = textFieldGetTextDataUseCase(text_field);
+    let index = text_field.compositionStartIndex + length;
+    for (let idx = text_field.compositionStartIndex; idx < index; ++idx) {
+        const textObject = textData.textTable[idx];
+        if (!textObject) {
+            break;
+        }
+        textObject.textFormat.underline = true;
+        if (textObject.mode !== "wrap") {
+            continue;
+        }
+        if (idx === text_field.compositionStartIndex) {
+            let subIndex = 1;
+            for (;;) {
+                const textObject = textData.textTable[idx - subIndex];
+                if (!textObject) {
+                    break;
+                }
+                if (textObject.mode === "text") {
+                    textObject.textFormat.underline = true;
+                    break;
+                }
+                subIndex++;
+            }
+        }
+        if (idx > text_field.compositionStartIndex) {
+            index++;
+        }
+    }
+    text_field.compositionEndIndex = text_field.focusIndex = index;
+};

package/src/TextField/usecase/TextFieldCopyUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description テキストフィールドの選択範囲のテキストを返却します。
+ *              Returns the text of the selection in the text field.
+ *
+ * @param  {TextField} text_field
+ * @return {Promise<void>}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField) => Promise<void>;

package/src/TextField/usecase/TextFieldCopyUseCase.js

@@ -0,0 +1,38 @@
+import { execute as textFieldGetTextDataUseCase } from "./TextFieldGetTextDataUseCase";
+/**
+ * @description テキストフィールドの選択範囲のテキストを返却します。
+ *              Returns the text of the selection in the text field.
+ *
+ * @param  {TextField} text_field
+ * @return {Promise<void>}
+ * @method
+ * @protected
+ */
+export const execute = async (text_field) => {
+    if (text_field.focusIndex === -1 || text_field.selectIndex === -1) {
+        return;
+    }
+    let text = "";
+    const minIndex = Math.min(text_field.focusIndex, text_field.selectIndex);
+    const maxIndex = Math.max(text_field.focusIndex, text_field.selectIndex) + 1;
+    const textData = textFieldGetTextDataUseCase(text_field);
+    for (let idx = minIndex; idx < maxIndex; ++idx) {
+        const textObject = textData.textTable[idx];
+        if (!textObject) {
+            continue;
+        }
+        switch (textObject.mode) {
+            case "text":
+                text += textObject.text;
+                break;
+            case "break":
+                text += "\n";
+                break;
+            default:
+                break;
+        }
+    }
+    await navigator
+        .clipboard
+        .writeText(text);
+};

package/src/TextField/usecase/TextFieldDeleteTextUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description 選択中のテキストを削除します。
+ *              Deletes the selected text.
+ *
+ * @param  {TextField} text_field
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField) => void;

package/src/TextField/usecase/TextFieldDeleteTextUseCase.js

@@ -0,0 +1,108 @@
+import { TextFormat } from "../../TextFormat";
+import { execute as textFieldGetTextDataUseCase } from "../../TextField/usecase/TextFieldGetTextDataUseCase";
+/**
+ * @description 選択中のテキストを削除します。
+ *              Deletes the selected text.
+ *
+ * @param  {TextField} text_field
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (text_field) => {
+    if (text_field.compositionStartIndex > -1) {
+        return;
+    }
+    let minIndex = 0;
+    let maxIndex = 0;
+    if (text_field.selectIndex > -1) {
+        minIndex = Math.min(text_field.focusIndex, text_field.selectIndex);
+        maxIndex = Math.max(text_field.focusIndex, text_field.selectIndex) + 1;
+        text_field.focusIndex = minIndex;
+    }
+    else {
+        if (2 > text_field.focusIndex) {
+            return;
+        }
+        text_field.focusIndex--;
+    }
+    const textData = textFieldGetTextDataUseCase(text_field);
+    const textObject = textData.textTable[text_field.focusIndex];
+    if (textObject && textObject.mode === "wrap") {
+        text_field.focusIndex--;
+    }
+    const textFormats = [];
+    let newText = "";
+    for (let idx = 1; idx < textData.textTable.length; ++idx) {
+        const textObject = textData.textTable[idx];
+        if (!textObject) {
+            continue;
+        }
+        if (text_field.focusIndex === idx
+            || minIndex <= idx && maxIndex > idx) {
+            continue;
+        }
+        switch (textObject.mode) {
+            case "break":
+                textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                newText += "\n";
+                break;
+            case "text":
+                textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                newText += textObject.text;
+                break;
+            default:
+                continue;
+        }
+    }
+    if (textData.textTable.length === text_field.focusIndex) {
+        textFormats.pop();
+        newText = newText.slice(0, -1);
+    }
+    text_field.selectIndex = -1;
+    if (!newText) {
+        // reset
+        text_field.text = "";
+        text_field.focusIndex = 1;
+    }
+    else {
+        const beforeTextWidth = text_field.textWidth;
+        const beforeTextHeight = text_field.textHeight;
+        // fixed logic
+        text_field.$textFormats = textFormats;
+        // fixed logic
+        text_field.text = newText;
+        if (text_field.scrollX > 0) {
+            const textWidth = text_field.textWidth;
+            const width = text_field.width;
+            switch (true) {
+                case width > textWidth:
+                    text_field.$scrollX = 0;
+                    break;
+                case beforeTextWidth !== textWidth:
+                    text_field.$scrollX -= (beforeTextWidth - textWidth)
+                        / (textWidth / width);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (text_field.scrollY > 0) {
+            const textHeight = text_field.textHeight;
+            const height = text_field.height;
+            switch (true) {
+                case height > textHeight:
+                    text_field.$scrollY = 0;
+                    break;
+                case beforeTextHeight !== textHeight:
+                    text_field.$scrollY -= (beforeTextHeight - textHeight)
+                        / (textHeight / height);
+                    break;
+                default:
+                    break;
+            }
+        }
+        // fixed logic
+        text_field.$textFormats = null;
+    }
+};

package/src/TextField/usecase/TextFieldGetLineTextUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description 指定された行のテキストを返します。
+ *              Returns the text of a given line.
+ *
+ * @param  {TextField} text_field
+ * @param  {number} index
+ * @return {string}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField, index: number) => string;

package/src/TextField/usecase/TextFieldGetLineTextUseCase.js

@@ -0,0 +1,32 @@
+import { execute as textFieldGetTextDataUseCase } from "./TextFieldGetTextDataUseCase";
+/**
+ * @description 指定された行のテキストを返します。
+ *              Returns the text of a given line.
+ *
+ * @param  {TextField} text_field
+ * @param  {number} index
+ * @return {string}
+ * @method
+ * @protected
+ */
+export const execute = (text_field, index) => {
+    let text = "";
+    const textData = textFieldGetTextDataUseCase(text_field);
+    for (let idx = 1; idx < textData.textTable.length; idx++) {
+        const textObject = textData.textTable[idx];
+        if (!textObject) {
+            continue;
+        }
+        if (textObject.line > index) {
+            break;
+        }
+        if (textObject.line !== index) {
+            continue;
+        }
+        if (textObject.mode !== "text") {
+            continue;
+        }
+        text += textObject.text;
+    }
+    return text;
+};

package/src/TextField/usecase/TextFieldGetTextDataUseCase.d.ts

@@ -0,0 +1,15 @@
+import type { TextData } from "../../TextData";
+import type { TextField } from "../../TextField";
+/**
+ * @description テキスト情報を元に描画用のデータを生成して返します。
+ *              生成済みのデータがある場合は、そのデータを返します。
+ *              Generates and returns data for drawing based on text information.
+ *              If data has already been generated, that data is returned.
+ *
+ * @param  {TextField} text_field
+ * @param  {number} sub_font_size
+ * @return {TextData}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField, sub_font_size?: number) => TextData;

package/src/TextField/usecase/TextFieldGetTextDataUseCase.js

@@ -0,0 +1,26 @@
+import { execute as textParserParseHtmlTextUseCase } from "../../TextParser/usecase/TextParserParseHtmlTextUseCase";
+/**
+ * @description テキスト情報を元に描画用のデータを生成して返します。
+ *              生成済みのデータがある場合は、そのデータを返します。
+ *              Generates and returns data for drawing based on text information.
+ *              If data has already been generated, that data is returned.
+ *
+ * @param  {TextField} text_field
+ * @param  {number} sub_font_size
+ * @return {TextData}
+ * @method
+ * @protected
+ */
+export const execute = (text_field, sub_font_size = 0) => {
+    if (text_field.$textData) {
+        return text_field.$textData;
+    }
+    text_field.$textData = textParserParseHtmlTextUseCase(text_field.htmlText, text_field.defaultTextFormat, {
+        "width": text_field.width,
+        "multiline": text_field.multiline,
+        "wordWrap": text_field.wordWrap,
+        "subFontSize": sub_font_size,
+        "textFormats": text_field.$textFormats
+    });
+    return text_field.$textData;
+};

package/src/TextField/usecase/TextFieldHtmlTextToRawTextUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description HTMLテキストをプレーンテキストに変換します。
+ *              Convert HTML text to plain text.
+ *
+ * @param  {TextField} text_field
+ * @return {string}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField) => string;

package/src/TextField/usecase/TextFieldHtmlTextToRawTextUseCase.js

@@ -0,0 +1,31 @@
+import { execute as textFieldGetTextDataUseCase } from "./TextFieldGetTextDataUseCase";
+/**
+ * @description HTMLテキストをプレーンテキストに変換します。
+ *              Convert HTML text to plain text.
+ *
+ * @param  {TextField} text_field
+ * @return {string}
+ * @method
+ * @protected
+ */
+export const execute = (text_field) => {
+    let text = "";
+    const textData = textFieldGetTextDataUseCase(text_field);
+    for (let idx = 1; idx < textData.textTable.length; ++idx) {
+        const textObject = textData.textTable[idx];
+        if (!textObject) {
+            continue;
+        }
+        switch (textObject.mode) {
+            case "text":
+                text += textObject.text;
+                break;
+            case "break":
+                text += "\r";
+                break;
+            default:
+                continue;
+        }
+    }
+    return text;
+};

package/src/TextField/usecase/TextFieldInsertTextUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description TextField にテキストを挿入します。
+ *              Inserts text into the TextField.
+ *
+ * @param  {TextField} text_field
+ * @param  {string} texts
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField, texts: string) => void;

package/src/TextField/usecase/TextFieldInsertTextUseCase.js

@@ -0,0 +1,79 @@
+import { TextFormat } from "../../TextFormat";
+import { $textArea } from "../../TextUtil";
+import { execute as textFieldDeleteTextUseCase } from "../../TextField/usecase/TextFieldDeleteTextUseCase";
+import { execute as textFieldGetTextDataUseCase } from "../../TextField/usecase/TextFieldGetTextDataUseCase";
+/**
+ * @description TextField にテキストを挿入します。
+ *              Inserts text into the TextField.
+ *
+ * @param  {TextField} text_field
+ * @param  {string} texts
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (text_field, texts) => {
+    if (text_field.focusIndex === -1
+        || text_field.compositionStartIndex > -1) {
+        return;
+    }
+    if (text_field.selectIndex > -1) {
+        textFieldDeleteTextUseCase(text_field);
+    }
+    const textData = textFieldGetTextDataUseCase(text_field);
+    if (2 > textData.textTable.length) {
+        text_field.focusIndex = 2;
+        text_field.appendText(texts);
+        return;
+    }
+    const textFormats = [];
+    let newText = "";
+    for (let idx = 1; idx < textData.textTable.length; ++idx) {
+        const textObject = textData.textTable[idx];
+        if (!textObject) {
+            continue;
+        }
+        if (text_field.focusIndex === idx) {
+            for (let idx = 0; idx < texts.length; ++idx) {
+                textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                newText += texts[idx];
+            }
+        }
+        switch (textObject.mode) {
+            case "break":
+                textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                newText += "\n";
+                break;
+            case "text":
+                textFormats.push(new TextFormat(...Object.values(textObject.textFormat)));
+                newText += textObject.text;
+                break;
+            default:
+                continue;
+        }
+    }
+    if (textData.textTable.length === text_field.focusIndex) {
+        let textFormat;
+        if (textData.textTable.length) {
+            const textObject = textData.textTable[textData.textTable.length - 1];
+            textFormat = new TextFormat(...Object.values(textObject.textFormat));
+        }
+        else {
+            textFormat = text_field.defaultTextFormat;
+            text_field.focusIndex++;
+        }
+        for (let idx = 0; idx < texts.length; ++idx) {
+            textFormats.push(new TextFormat(...Object.values(textFormat.toObject())));
+            newText += texts[idx];
+        }
+    }
+    // fixed logic
+    text_field.$textFormats = textFormats;
+    // fixed logic
+    text_field.text = newText;
+    // fixed logic
+    text_field.$textFormats = null;
+    text_field.focusIndex += texts.length;
+    text_field.selectIndex = -1;
+    $textArea.value = "";
+};

package/src/TextField/usecase/TextFieldKeyDownEventUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description テキストフィールドのキーボードダウンイベントを実行する
+ *              Execute the keyboard down event of the text field
+ *
+ * @param  {TextField} text_field
+ * @param  {KeyboardEvent} event
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField, event: KeyboardEvent) => void;

package/src/TextField/usecase/TextFieldKeyDownEventUseCase.js

@@ -0,0 +1,60 @@
+import { execute as textFieldArrowDownUseCase } from "../../TextField/usecase/TextFieldArrowDownUseCase";
+import { execute as textFieldArrowUpUseCase } from "../../TextField/usecase/TextFieldArrowUpUseCase";
+import { execute as textFieldArrowLeftUseCase } from "../../TextField/usecase/TextFieldArrowLeftUseCase";
+import { execute as textFieldArrowRightUseCase } from "../../TextField/usecase/TextFieldArrowRightUseCase";
+/**
+ * @description テキストフィールドのキーボードダウンイベントを実行する
+ *              Execute the keyboard down event of the text field
+ *
+ * @param  {TextField} text_field
+ * @param  {KeyboardEvent} event
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (text_field, event) => {
+    if (text_field.focusIndex === -1) {
+        return;
+    }
+    switch (event.key) {
+        case "Backspace":
+        case "Delete":
+            text_field.deleteText();
+            break;
+        case "Enter":
+            text_field.insertText("\n");
+            break;
+        case "ArrowLeft":
+            textFieldArrowLeftUseCase(text_field, event.shiftKey);
+            break;
+        case "ArrowRight":
+            textFieldArrowRightUseCase(text_field, event.shiftKey);
+            break;
+        case "ArrowUp":
+            textFieldArrowUpUseCase(text_field, event.shiftKey);
+            break;
+        case "ArrowDown":
+            textFieldArrowDownUseCase(text_field, event.shiftKey);
+            break;
+        case "a":
+            if (event.metaKey || event.ctrlKey) {
+                event.preventDefault();
+                text_field.selectAll();
+            }
+            break;
+        case "c":
+            if (event.metaKey || event.ctrlKey) {
+                event.preventDefault();
+                text_field.copy();
+            }
+            break;
+        case "v":
+            if (event.metaKey || event.ctrlKey) {
+                event.preventDefault();
+                text_field.paste();
+            }
+            break;
+        default:
+            break;
+    }
+};

package/src/TextField/usecase/TextFieldReloadUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { TextField } from "../../TextField";
+/**
+ * @description テキストフィールドの描画生成情報を再計算します
+ *              Recalculates the drawing generation information of the text field
+ *
+ * @param  {TextField} text_field
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (text_field: TextField) => void;