capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/TextLayoutHelper.kt

@@ -0,0 +1,105 @@
+package io.github.abc15018045126.sora.text
+
+import android.annotation.SuppressLint
+import android.os.Build
+import android.text.DynamicLayout
+import android.text.Editable
+import android.text.Layout
+import android.text.Selection
+import android.text.TextDirectionHeuristics
+import android.text.TextPaint
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Helper class for indirectly calling Paint#getTextRunCursor(), which is
+ * responsible for cursor controlling.
+ *
+ * @author abc15018045126
+ */
+class TextLayoutHelper private constructor() {
+
+    private val text: Editable = Editable.Factory.getInstance().newEditable("")
+    private val layout: DynamicLayout
+
+    init {
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
+            @Suppress("DEPRECATION")
+            layout = DynamicLayout(
+                text, TextPaint(), Int.MAX_VALUE / 2,
+                Layout.Alignment.ALIGN_NORMAL, 0f, 0f, true
+            )
+            try {
+                @SuppressLint("DiscouragedPrivateApi", "SoonBlockedPrivateApi")
+                val field = Layout::class.java.getDeclaredField("mTextDir")
+                field.isAccessible = true
+                field.set(layout, TextDirectionHeuristics.FIRSTSTRONG_LTR)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        } else {
+            layout = DynamicLayout.Builder.obtain(text, TextPaint(), Int.MAX_VALUE / 2)
+                .setIncludePad(true)
+                .setLineSpacing(0f, 0f)
+                .setTextDirection(TextDirectionHeuristics.FIRSTSTRONG_LTR)
+                .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+                .build()
+        }
+    }
+
+    /**
+     * Get cursor position after moving left
+     */
+    fun getCurPosLeft(offset: Int, s: CharSequence): Int {
+        val left = max(0, offset - CHAR_FACTOR)
+        var index = offset - left
+        text.append(s, left, min(s.length, offset + CHAR_FACTOR + 1))
+        index = min(index, text.length)
+        Selection.setSelection(text, index)
+        try {
+            Selection.moveLeft(text, layout)
+            index = Selection.getSelectionStart(text)
+        } finally {
+            text.clear()
+            Selection.removeSelection(text)
+        }
+        return left + index
+    }
+
+    /**
+     * Get cursor position after moving right
+     */
+    fun getCurPosRight(offset: Int, s: CharSequence): Int {
+        val left = max(0, offset - CHAR_FACTOR)
+        var index = offset - left
+        text.append(s, left, min(s.length, offset + CHAR_FACTOR + 1))
+        index = min(index, text.length)
+        Selection.setSelection(text, index)
+        try {
+            Selection.moveRight(text, layout)
+            index = Selection.getSelectionStart(text)
+        } finally {
+            text.clear()
+            Selection.removeSelection(text)
+        }
+        return left + index
+    }
+
+    companion object {
+        private val sLocal = ThreadLocal<TextLayoutHelper>()
+        private const val CHAR_FACTOR = 64
+
+        /**
+         * Get TextLayoutHelper for current thread
+         */
+        @JvmStatic
+        fun get(): TextLayoutHelper {
+            var v = sLocal.get()
+            if (v == null) {
+                v = TextLayoutHelper()
+                sLocal.set(v)
+            }
+            return v!!
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/TextRange.kt

@@ -0,0 +1,48 @@
+package io.github.abc15018045126.sora.text
+
+/**
+ * A range made up of two {@link CharPosition} objects.
+ *
+ * @author abc15018045126
+ */
+class TextRange(
+    @JvmField var start: CharPosition,
+    @JvmField var end: CharPosition
+) {
+
+    fun getStart(): CharPosition {
+        return start
+    }
+
+    fun setStart(start: CharPosition) {
+        this.start = start
+    }
+
+    fun getEnd(): CharPosition {
+        return end
+    }
+
+    fun setEnd(end: CharPosition) {
+        this.end = end
+    }
+
+    val startIndex: Int
+        get() = start.index
+
+    val endIndex: Int
+        get() = end.index
+
+    /**
+     * Check if the given position is inside the range
+     */
+    fun isPositionInside(pos: CharPosition): Boolean {
+        return pos.index >= start.index && pos.index < end.index
+    }
+
+    override fun toString(): String {
+        return "TextRange{" +
+                "start=" + start +
+                ", end=" + end +
+                '}'
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/TextReference.kt

@@ -0,0 +1,91 @@
+package io.github.abc15018045126.sora.text
+
+import java.util.Objects
+
+/**
+ * Reference of a {@link CharSequence} object, which allows
+ * to access the original sequence in read-only mode, and attach a
+ * {@link Validator} to validate access to check whether reject the
+ * read access.
+ * This can be useful when reading text in multiple threads, with the ability
+ * to interrupt that thread when the actual text changes.
+ *
+ * @author abc15018045126
+ */
+open class TextReference(
+    ref: CharSequence,
+    private val start: Int,
+    private val end: Int
+) : CharSequence {
+
+    private val ref: CharSequence = Objects.requireNonNull(ref)
+    private var validator: Validator? = null
+
+    constructor(ref: CharSequence) : this(ref, 0, ref.length)
+
+    init {
+        if (start > end) {
+            throw IllegalArgumentException("start > end")
+        }
+        if (start < 0) {
+            throw StringIndexOutOfBoundsException(start)
+        }
+        if (end > ref.length) {
+            throw StringIndexOutOfBoundsException(end)
+        }
+    }
+
+    /**
+     * Get original text of the reference
+     */
+    open val reference: CharSequence
+        get() = ref
+
+    override val length: Int
+        get() {
+            validateAccess()
+            return end - start
+        }
+
+    override fun get(index: Int): Char {
+        if (index < 0 || index >= length) {
+            throw StringIndexOutOfBoundsException(index)
+        }
+        validateAccess()
+        return ref[start + index]
+    }
+
+    override fun toString(): String {
+        return ref.subSequence(start, end).toString()
+    }
+
+    override fun subSequence(startIndex: Int, endIndex: Int): CharSequence {
+        if (startIndex < 0 || startIndex >= length) {
+            throw StringIndexOutOfBoundsException(startIndex)
+        }
+        if (endIndex < 0 || endIndex > length) {
+             throw StringIndexOutOfBoundsException(endIndex)
+        }
+        
+        validateAccess()
+        return TextReference(ref, this.start + startIndex, this.start + endIndex).setValidator(validator)
+    }
+
+    open fun setValidator(validator: Validator?): TextReference {
+        this.validator = validator
+        return this
+    }
+
+    fun validateAccess() {
+        validator?.validate()
+    }
+
+    fun interface Validator {
+        fun validate()
+    }
+
+    class ValidateFailedException : RuntimeException {
+        constructor()
+        constructor(message: String?) : super(message)
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/TextUtils.kt

@@ -0,0 +1,181 @@
+package io.github.abc15018045126.sora.text
+
+import io.github.abc15018045126.sora.util.IntPair
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Utility class for texts
+ */
+object TextUtils {
+
+    /**
+     * Counts the number of whitespaces at the start of the given {@link CharSequence}.
+     *
+     * @param text     The text to count the spaces in.
+     * @return A long packed with the number of spaces and tabs at the start of the line.
+     * Use {@link IntPair#getFirst(long)} to get the number of spaces and {@link IntPair#getSecond(long)}
+     * for the number of tabs.
+     */
+    @JvmStatic
+    fun countLeadingSpacesAndTabs(text: CharSequence): Long {
+        var p = 0
+        var spaces = 0
+        var tabs = 0
+        while (p < text.length) {
+            val c = text[p]
+            if (!isWhitespace(c)) {
+                break
+            }
+            if (c == '\t') {
+                tabs += 1
+            } else {
+                spaces += 1
+            }
+            ++p
+        }
+
+        return IntPair.pack(spaces, tabs)
+    }
+
+    /**
+     * Compute leading space count
+     *
+     * @param tabWidth Tab is considered in {@code tabWidth} spaces
+     */
+    @JvmStatic
+    fun countLeadingSpaceCount(text: CharSequence, tabWidth: Int): Int {
+        val result = countLeadingSpacesAndTabs(text)
+        return IntPair.getFirst(result) + tabWidth * IntPair.getSecond(result)
+    }
+
+    /**
+     * Create indent space
+     *
+     * @return Generated space string
+     */
+    @JvmStatic
+    fun createIndent(indentSize: Int, tabWidth: Int, useTab: Boolean): String {
+        val size = max(0, indentSize)
+        val tab: Int
+        val space: Int
+        if (useTab) {
+            tab = size / tabWidth
+            space = size % tabWidth
+        } else {
+            tab = 0
+            space = size
+        }
+        val s = StringBuilder()
+        for (i in 0 until tab) {
+            s.append('\t')
+        }
+        for (i in 0 until space) {
+            s.append(' ')
+        }
+        return s.toString()
+    }
+
+    @JvmStatic
+    fun indexOf(text: CharSequence, pattern: CharSequence, ignoreCase: Boolean, fromIndex: Int): Int {
+        val max = text.length - pattern.length
+        val len = pattern.length
+        label@ for (i in fromIndex..max) {
+            // Compare
+            for (j in 0 until len) {
+                val s = text[i + j]
+                val p = pattern[j]
+                if (!(s == p || ignoreCase && s.lowercaseChar() == p.lowercaseChar())) {
+                    continue@label
+                }
+            }
+            return i
+        }
+        return -1
+    }
+
+    @JvmStatic
+    fun lastIndexOf(text: CharSequence, pattern: CharSequence, ignoreCase: Boolean, fromIndex: Int): Int {
+        val len = pattern.length
+        val startIndex = min(fromIndex, text.length - len)
+        label@ for (i in startIndex downTo 0) {
+            // Compare
+            for (j in 0 until len) {
+                val s = text[i + j]
+                val p = pattern[j]
+                if (!(s == p || ignoreCase && s.lowercaseChar() == p.lowercaseChar())) {
+                    continue@label
+                }
+            }
+            return i
+        }
+        return -1
+    }
+
+    @JvmStatic
+    fun startsWith(text: CharSequence, pattern: CharSequence, ignoreCase: Boolean): Boolean {
+        if (text.length < pattern.length) {
+            return false
+        }
+        val len = pattern.length
+        for (i in 0 until len) {
+            val s = text[i]
+            val p = pattern[i]
+            if (!(s == p || ignoreCase && s.lowercaseChar() == p.lowercaseChar())) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun isWhitespace(ch: Char): Boolean {
+        return ch == '\t' || ch == ' '
+    }
+
+    @JvmStatic
+    fun padStart(src: String, padChar: Char, length: Int): String {
+        if (src.length >= length) {
+            return src
+        }
+        val sb = StringBuilder(length)
+        for (i in 0 until length - src.length) {
+            sb.append(padChar)
+        }
+        sb.append(src)
+        return sb.toString()
+    }
+
+    /**
+     * Find where leading spaces end and trailing spaces start
+     *
+     * @param line The line to search
+     */
+    @JvmStatic
+    fun findLeadingAndTrailingWhitespacePos(line: ContentLine): Long {
+        return findLeadingAndTrailingWhitespacePos(line, 0, line.length)
+    }
+
+    /**
+     * Find where leading spaces end and trailing spaces start
+     *
+     * @param line  The line to search
+     * @param start Range start (inclusive)
+     * @param end   Range end (exclusive)
+     */
+    @JvmStatic
+    fun findLeadingAndTrailingWhitespacePos(line: ContentLine, start: Int, end: Int): Long {
+        val buffer = line.backingCharArray
+        var leading = start
+        var trailing = end
+        while (leading < end && isWhitespace(buffer[leading])) {
+            leading++
+        }
+        // Skip for space-filled line
+        if (leading != end) {
+            while (trailing > 0 && isWhitespace(buffer[trailing - 1])) {
+                trailing--
+            }
+        }
+        return IntPair.pack(leading, trailing)
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/text/TextUtilsP.kt

@@ -0,0 +1,232 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.github.abc15018045126.sora.text
+
+import android.icu.lang.UCharacter
+import android.icu.lang.UProperty
+import android.os.Build
+import androidx.annotation.RequiresApi
+
+/**
+ * Taken from {@link android.text.method.BaseKeyListener}
+ */
+object TextUtilsP {
+
+    private const val LINE_FEED: Int = 0x0A
+    private const val CARRIAGE_RETURN: Int = 0x0D
+
+    // Returns true if the given code point is a variation selector.
+    @RequiresApi(api = Build.VERSION_CODES.N)
+    private fun isVariationSelector(codepoint: Int): Boolean {
+        return UCharacter.hasBinaryProperty(codepoint, UProperty.VARIATION_SELECTOR)
+    }
+
+    // Returns the start offset to be deleted by a backspace key from the given offset.
+    @JvmStatic
+    @RequiresApi(api = Build.VERSION_CODES.P)
+    fun getOffsetForBackspaceKey(text: CharSequence, offset: Int): Int {
+        if (offset <= 1) {
+            return 0
+        }
+
+        // Initial state
+        val STATE_START = 0
+
+        // The offset is immediately before line feed.
+        val STATE_LF = 1
+
+        // The offset is immediately before a KEYCAP.
+        val STATE_BEFORE_KEYCAP = 2
+        // The offset is immediately before a variation selector and a KEYCAP.
+        val STATE_BEFORE_VS_AND_KEYCAP = 3
+
+        // The offset is immediately before an emoji modifier.
+        val STATE_BEFORE_EMOJI_MODIFIER = 4
+        // The offset is immediately before a variation selector and an emoji modifier.
+        val STATE_BEFORE_VS_AND_EMOJI_MODIFIER = 5
+
+        // The offset is immediately before a variation selector.
+        val STATE_BEFORE_VS = 6
+
+        // The offset is immediately before an emoji.
+        val STATE_BEFORE_EMOJI = 7
+        // The offset is immediately before a ZWJ that were seen before a ZWJ emoji.
+        val STATE_BEFORE_ZWJ = 8
+        // The offset is immediately before a variation selector and a ZWJ that were seen before a
+        // ZWJ emoji.
+        val STATE_BEFORE_VS_AND_ZWJ = 9
+
+        // The number of following RIS code points is odd.
+        val STATE_ODD_NUMBERED_RIS = 10
+        // The number of following RIS code points is even.
+        val STATE_EVEN_NUMBERED_RIS = 11
+
+        // The offset is in emoji tag sequence.
+        val STATE_IN_TAG_SEQUENCE = 12
+
+        // The state machine has been stopped.
+        val STATE_FINISHED = 13
+
+        var deleteCharCount = 0  // Char count to be deleted by backspace.
+        var lastSeenVSCharCount = 0  // Char count of previous variation selector.
+
+        var state = STATE_START
+
+        var tmpOffset = offset
+        do {
+            val codePoint = Character.codePointBefore(text, tmpOffset)
+            tmpOffset -= Character.charCount(codePoint)
+
+            when (state) {
+                STATE_START -> {
+                    deleteCharCount = Character.charCount(codePoint)
+                    if (codePoint == LINE_FEED) {
+                        state = STATE_LF
+                    } else if (isVariationSelector(codePoint)) {
+                        state = STATE_BEFORE_VS
+                    } else if (AndroidEmoji.isRegionalIndicatorSymbol(codePoint)) {
+                        state = STATE_ODD_NUMBERED_RIS
+                    } else if (AndroidEmoji.isEmojiModifier(codePoint)) {
+                        state = STATE_BEFORE_EMOJI_MODIFIER
+                    } else if (codePoint == AndroidEmoji.COMBINING_ENCLOSING_KEYCAP) {
+                        state = STATE_BEFORE_KEYCAP
+                    } else if (AndroidEmoji.isEmoji(codePoint)) {
+                        state = STATE_BEFORE_EMOJI
+                    } else if (codePoint == AndroidEmoji.CANCEL_TAG) {
+                        state = STATE_IN_TAG_SEQUENCE
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_LF -> {
+                    if (codePoint == CARRIAGE_RETURN) {
+                        ++deleteCharCount
+                    }
+                    state = STATE_FINISHED
+                }
+                STATE_ODD_NUMBERED_RIS -> {
+                    if (AndroidEmoji.isRegionalIndicatorSymbol(codePoint)) {
+                        deleteCharCount += 2 /* Char count of RIS */
+                        state = STATE_EVEN_NUMBERED_RIS
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_EVEN_NUMBERED_RIS -> {
+                    if (AndroidEmoji.isRegionalIndicatorSymbol(codePoint)) {
+                        deleteCharCount -= 2 /* Char count of RIS */
+                        state = STATE_ODD_NUMBERED_RIS
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_BEFORE_KEYCAP -> {
+                    if (isVariationSelector(codePoint)) {
+                        lastSeenVSCharCount = Character.charCount(codePoint)
+                        state = STATE_BEFORE_VS_AND_KEYCAP
+                    } else {
+                        if (AndroidEmoji.isKeycapBase(codePoint)) {
+                            deleteCharCount += Character.charCount(codePoint)
+                        }
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_BEFORE_VS_AND_KEYCAP -> {
+                    if (AndroidEmoji.isKeycapBase(codePoint)) {
+                        deleteCharCount += lastSeenVSCharCount + Character.charCount(codePoint)
+                    }
+                    state = STATE_FINISHED
+                }
+                STATE_BEFORE_EMOJI_MODIFIER -> {
+                    if (isVariationSelector(codePoint)) {
+                        lastSeenVSCharCount = Character.charCount(codePoint)
+                        state = STATE_BEFORE_VS_AND_EMOJI_MODIFIER
+                    } else if (AndroidEmoji.isEmojiModifierBase(codePoint)) {
+                        deleteCharCount += Character.charCount(codePoint)
+                        state = STATE_BEFORE_EMOJI
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_BEFORE_VS_AND_EMOJI_MODIFIER -> {
+                    if (AndroidEmoji.isEmojiModifierBase(codePoint)) {
+                        deleteCharCount += lastSeenVSCharCount + Character.charCount(codePoint)
+                    }
+                    state = STATE_FINISHED
+                }
+                STATE_BEFORE_VS -> {
+                    if (AndroidEmoji.isEmoji(codePoint)) {
+                        deleteCharCount += Character.charCount(codePoint)
+                        state = STATE_BEFORE_EMOJI
+                    } else {
+                        if (!isVariationSelector(codePoint) &&
+                            UCharacter.getCombiningClass(codePoint) == 0
+                        ) {
+                            deleteCharCount += Character.charCount(codePoint)
+                        }
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_BEFORE_EMOJI -> {
+                    if (codePoint == AndroidEmoji.ZERO_WIDTH_JOINER) {
+                        state = STATE_BEFORE_ZWJ
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_BEFORE_ZWJ -> {
+                    if (AndroidEmoji.isEmoji(codePoint)) {
+                        deleteCharCount += Character.charCount(codePoint) + 1  // +1 for ZWJ.
+                        state = if (AndroidEmoji.isEmojiModifier(codePoint))
+                            STATE_BEFORE_EMOJI_MODIFIER else STATE_BEFORE_EMOJI
+                    } else if (isVariationSelector(codePoint)) {
+                        lastSeenVSCharCount = Character.charCount(codePoint)
+                        state = STATE_BEFORE_VS_AND_ZWJ
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_BEFORE_VS_AND_ZWJ -> {
+                    if (AndroidEmoji.isEmoji(codePoint)) {
+                        // +1 for ZWJ.
+                        deleteCharCount += lastSeenVSCharCount + 1 + Character.charCount(codePoint)
+                        lastSeenVSCharCount = 0
+                        state = STATE_BEFORE_EMOJI
+                    } else {
+                        state = STATE_FINISHED
+                    }
+                }
+                STATE_IN_TAG_SEQUENCE -> {
+                    if (AndroidEmoji.isTagSpecChar(codePoint)) {
+                        deleteCharCount += 2 /* Char count of emoji tag spec character. */
+                        // Keep the same state.
+                    } else if (AndroidEmoji.isEmoji(codePoint)) {
+                        deleteCharCount += Character.charCount(codePoint)
+                        state = STATE_FINISHED
+                    } else {
+                        // Couldn't find tag_base character. Delete the last tag_term character.
+                        deleteCharCount = 2  // for U+E007F
+                        state = STATE_FINISHED
+                    }
+                    // TODO: Need handle emoji variation selectors. Issue 35224297
+                }
+                else -> throw IllegalArgumentException("state $state is unknown")
+            }
+        } while (tmpOffset > 0 && state != STATE_FINISHED)
+
+        return offset - deleteCharCount
+    }
+}