capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,316 @@
+package io.github.abc15018045126.sora.text
+
+import io.github.abc15018045126.sora.util.IntPair
+
+/**
+ * The [Cursor] position will update automatically when the content has been changed by other ways.
+ *
+ * @author abc15018045126
+ */
+class Cursor(private val content: Content) {
+
+    private val indexer: CachedIndexer = CachedIndexer(content)
+    private var leftSel: CharPosition = CharPosition().toBOF()
+    private var rightSel: CharPosition = CharPosition().toBOF()
+    private var cache0: CharPosition? = null
+    private var cache1: CharPosition? = null
+    private var cache2: CharPosition? = null
+
+    private var selDirection = DIRECTION_NONE
+
+    /**
+     * Make left and right cursor on the given position
+     *
+     * @param line   The line position
+     * @param column The column position
+     */
+    fun set(line: Int, column: Int) {
+        setLeft(line, column)
+        setRight(line, column)
+    }
+
+    /**
+     * Make left cursor on the given position
+     *
+     * @param line   The line position
+     * @param column The column position
+     */
+    fun setLeft(line: Int, column: Int) {
+        leftSel = indexer.getCharPosition(line, column).fromThis()
+    }
+
+    /**
+     * Make right cursor on the given position
+     *
+     * @param line   The line position
+     * @param column The column position
+     */
+    fun setRight(line: Int, column: Int) {
+        rightSel = indexer.getCharPosition(line, column).fromThis()
+    }
+
+    /**
+     * Get the left cursor line
+     *
+     * @return line of left cursor
+     */
+    val leftLine: Int
+        get() = leftSel.line
+
+    /**
+     * Get the left cursor column
+     *
+     * @return column of left cursor
+     */
+    val leftColumn: Int
+        get() = leftSel.column
+
+    /**
+     * Get the right cursor line
+     *
+     * @return line of right cursor
+     */
+    val rightLine: Int
+        get() = rightSel.line
+
+    /**
+     * Get the right cursor column
+     *
+     * @return column of right cursor
+     */
+    val rightColumn: Int
+        get() = rightSel.column
+
+    /**
+     * Whether the given position is in selected region
+     *
+     * @param line   The line to query
+     * @param column The column to query
+     * @return Whether is in selected region
+     */
+    fun isInSelectedRegion(line: Int, column: Int): Boolean {
+        if (line in leftLine..rightLine) {
+            var yes = true
+            if (line == leftLine) {
+                yes = column >= leftColumn
+            }
+            if (line == rightLine) {
+                yes = yes && column < rightColumn
+            }
+            return yes
+        }
+        return false
+    }
+
+    /**
+     * Get the left cursor index
+     *
+     * @return index of left cursor
+     */
+    val left: Int
+        get() = leftSel.index
+
+    /**
+     * Get the right cursor index
+     *
+     * @return index of right cursor
+     */
+    val right: Int
+        get() = rightSel.index
+
+    /**
+     * Notify the Indexer to update its cache for current display position
+     *
+     * This will make querying actions quicker
+     *
+     * Especially when the editor user want to set a new cursor position after scrolling long time
+     *
+     * @param line First visible line
+     */
+    fun updateCache(line: Int) {
+        indexer.getCharIndex(line, 0)
+    }
+
+    /**
+     * Get the using Indexer object
+     *
+     * @return Using Indexer
+     */
+    fun getIndexer(): CachedIndexer {
+        return indexer
+    }
+
+    /**
+     * Get whether text is selected
+     *
+     * @return Whether selected
+     */
+    fun isSelected(): Boolean {
+        return leftSel.index != rightSel.index
+    }
+
+    /**
+     * Set current direction of selection.
+     */
+    fun setSelectionDirection(selDirection: Int) {
+        this.selDirection = selDirection
+    }
+
+    /**
+     * Get current direction of selection
+     */
+    fun getSelectionDirection(): Int {
+        return selDirection
+    }
+
+    /**
+     * Get position after moving left once
+     *
+     * @param position A packed pair (line, column) describing the original position
+     * @return A packed pair (line, column) describing the result position
+     */
+    fun getLeftOf(position: Long): Long {
+        val line = IntPair.getFirst(position)
+        val column = IntPair.getSecond(position)
+        val nColumn = TextLayoutHelper.get().getCurPosLeft(column, content.getLine(line))
+        return if (nColumn == column && column == 0) {
+            if (line == 0) {
+                0L
+            } else {
+                val cColumn = content.getColumnCount(line - 1)
+                IntPair.pack(line - 1, cColumn)
+            }
+        } else {
+            IntPair.pack(line, nColumn)
+        }
+    }
+
+    /**
+     * Get position after moving right once
+     *
+     * @param position A packed pair (line, column) describing the original position
+     * @return A packed pair (line, column) describing the result position
+     */
+    fun getRightOf(position: Long): Long {
+        val line = IntPair.getFirst(position)
+        val column = IntPair.getSecond(position)
+        val cColumn = content.getColumnCount(line)
+        val nColumn = TextLayoutHelper.get().getCurPosRight(column, content.getLine(line))
+        return if (nColumn == cColumn && column == nColumn) {
+            if (line + 1 == content.lineCount) {
+                IntPair.pack(line, cColumn)
+            } else {
+                IntPair.pack(line + 1, 0)
+            }
+        } else {
+            IntPair.pack(line, nColumn)
+        }
+    }
+
+    /**
+     * Get copy of left cursor
+     */
+    fun left(): CharPosition {
+        return leftSel.fromThis()
+    }
+
+    /**
+     * Get copy of right cursor
+     */
+    fun right(): CharPosition {
+        return rightSel.fromThis()
+    }
+
+    /**
+     * Get current range of cursor. Modifications to the returned object does not affect cursor positions.
+     *
+     * @return [TextRange] object describing cursor positions
+     */
+    fun getRange(): TextRange {
+        return TextRange(left(), right())
+    }
+
+    /**
+     * Internal call back before insertion
+     *
+     * @param startLine   Start line
+     * @param startColumn Start column
+     */
+    internal fun beforeInsert(startLine: Int, startColumn: Int) {
+        cache0 = indexer.getCharPosition(startLine, startColumn).fromThis()
+    }
+
+    /**
+     * Internal call back before deletion
+     *
+     * @param startLine   Start line
+     * @param startColumn Start column
+     * @param endLine     End line
+     * @param endColumn   End column
+     */
+    internal fun beforeDelete(startLine: Int, startColumn: Int, endLine: Int, endColumn: Int) {
+        cache1 = indexer.getCharPosition(startLine, startColumn).fromThis()
+        cache2 = indexer.getCharPosition(endLine, endColumn).fromThis()
+    }
+
+    /**
+     * Internal call back before replace
+     */
+    internal fun beforeReplace() {
+        indexer.beforeReplace(content)
+    }
+
+    /**
+     * Internal call back after insertion
+     *
+     * @param startLine       Start line
+     * @param startColumn     Start column
+     * @param endLine         End line
+     * @param endColumn       End column
+     * @param insertedContent Inserted content
+     */
+    internal fun afterInsert(
+        startLine: Int, startColumn: Int, endLine: Int, endColumn: Int,
+        insertedContent: CharSequence
+    ) {
+        indexer.afterInsert(content, startLine, startColumn, endLine, endColumn, insertedContent)
+        val beginIdx = cache0?.index ?: 0
+        if (left >= beginIdx) {
+            leftSel = indexer.getCharPosition(left + insertedContent.length).fromThis()
+        }
+        if (right >= beginIdx) {
+            rightSel = indexer.getCharPosition(right + insertedContent.length).fromThis()
+        }
+    }
+
+    /**
+     * Internal call back
+     *
+     * @param startLine      Start line
+     * @param startColumn    Start column
+     * @param endLine        End line
+     * @param endColumn      End column
+     * @param deletedContent Deleted content
+     */
+    internal fun afterDelete(
+        startLine: Int, startColumn: Int, endLine: Int, endColumn: Int,
+        deletedContent: CharSequence
+    ) {
+        indexer.afterDelete(content, startLine, startColumn, endLine, endColumn, deletedContent)
+        val beginIdx = cache1?.index ?: 0
+        val endIdx = cache2?.index ?: 0
+        if (beginIdx > right) {
+            return
+        }
+        val left = left - Math.max(0, Math.min(left - beginIdx, endIdx - beginIdx))
+        val right = right - Math.max(0, Math.min(right - beginIdx, endIdx - beginIdx))
+        leftSel = indexer.getCharPosition(left).fromThis()
+        rightSel = indexer.getCharPosition(right).fromThis()
+    }
+
+    companion object {
+        const val DIRECTION_NONE = 0
+        const val DIRECTION_LTR = 1
+        const val DIRECTION_RTL = 2
+    }
+}

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

@@ -0,0 +1,46 @@
+package io.github.abc15018045126.sora.text
+
+/**
+ * Utility for ASCII function characters
+ *
+ * @author abc15018045126
+ */
+object FunctionCharacters {
+
+    private val names = arrayOf(
+        "NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK",
+        "BEL", "BS", "HT", "LF", "VT", "FF", "CR", "SO",
+        "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK",
+        "SYN", "ETB", "CAN", "EM", "SUB", "ESC", "FS",
+        "GS", "RS", "US", "SP"
+    )
+
+    /**
+     * Check if the letter is ASCII function character.
+     */
+    @JvmStatic
+    fun isFunctionCharacter(letter: Char): Boolean {
+        return letter.code < 32 || letter.code == 127
+    }
+
+    /**
+     * Check if the letter is ASCII function character, '\t' excluded.
+     */
+    @JvmStatic
+    fun isEditorFunctionChar(letter: Char): Boolean {
+        return letter != '\t' && isFunctionCharacter(letter)
+    }
+
+    /**
+     * Get the name of function character
+     */
+    @JvmStatic
+    fun getNameForFunctionCharacter(letter: Char): String {
+        if (letter.code < 32) {
+            return names[letter.code]
+        } else if (letter.code == 127) {
+            return "DEL"
+        }
+        return "UNK"
+    }
+}

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

@@ -0,0 +1,58 @@
+package io.github.abc15018045126.sora.text
+
+import android.icu.text.BreakIterator
+import android.os.Build
+import io.github.abc15018045126.sora.util.IntPair
+import io.github.abc15018045126.sora.util.MyCharacter
+
+/**
+ * Utility class for invoking ICU library according to Android platform.
+ * Provide default implementation on old platforms without ICU.
+ *
+ * @author abc15018045126
+ */
+object ICUUtils {
+
+    /**
+     * Get word range for the given offset
+     *
+     * @param text   Text to analyze
+     * @param offset Required char offset of word
+     * @return Packed integer pair (start, end). Always contains the position {@code offset}
+     */
+    @JvmStatic
+    fun getWordRange(text: CharSequence, offset: Int, useIcu: Boolean): Long {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && useIcu) {
+            val itr = BreakIterator.getWordInstance()
+            itr.setText(CharSequenceIterator(text))
+            val end = itr.following(offset)
+            val start = itr.previous()
+            if (offset in start..end) {
+                return IntPair.pack(start, end)
+            } else {
+                return getWordRangeFallback(text, offset)
+            }
+        } else {
+            return getWordRangeFallback(text, offset)
+        }
+    }
+
+    /**
+     * Primitive implementation of {@link #getWordRange(CharSequence, int, boolean)}
+     * when ICU is not enabled
+     */
+    @JvmStatic
+    fun getWordRangeFallback(text: CharSequence, offset: Int): Long {
+        var start = offset
+        var end = offset
+        while (end < text.length && MyCharacter.isJavaIdentifierPart(text[end])) {
+            end++
+        }
+        if (end > offset) {
+            while (start > 0 && MyCharacter.isJavaIdentifierPart(text[start - 1])) {
+                start--
+            }
+        }
+        return IntPair.pack(start, end)
+    }
+}

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

@@ -0,0 +1,63 @@
+package io.github.abc15018045126.sora.text
+
+/**
+ * A helper class for ITextContent to transform (line,column) and index
+ *
+ * @author Rose
+ */
+interface Indexer {
+
+    /**
+     * Get the index of (line,column)
+     *
+     * @param line   The line position of index
+     * @param column The column position of index
+     * @return Calculated index
+     */
+    fun getCharIndex(line: Int, column: Int): Int
+
+    /**
+     * Get the line position of index
+     *
+     * @param index The index you want to know its line
+     * @return Line position of index
+     */
+    fun getCharLine(index: Int): Int
+
+    /**
+     * Get the column position of index
+     *
+     * @param index The index you want to know its column
+     * @return Column position of index
+     */
+    fun getCharColumn(index: Int): Int
+
+    /**
+     * Get the CharPosition for the given index
+     *
+     * @param index The index you want to get
+     * @return The CharPosition object.
+     */
+    fun getCharPosition(index: Int): CharPosition
+
+    /**
+     * Get the CharPosition for the given (line,column)
+     *
+     * @param line   The line position you want to get
+     * @param column The column position you want to get
+     * @return The CharPosition object.
+     */
+    fun getCharPosition(line: Int, column: Int): CharPosition
+
+    /**
+     * @param dest Destination of result
+     * @see #getCharPosition(int)
+     */
+    fun getCharPosition(index: Int, dest: CharPosition)
+
+    /**
+     * @param dest Destination of result
+     * @see #getCharPosition(int, int)
+     */
+    fun getCharPosition(line: Int, column: Int, dest: CharPosition)
+}

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

@@ -0,0 +1,95 @@
+package io.github.abc15018045126.sora.text
+
+internal class InsertTextHelper {
+
+    private var text: CharSequence? = null
+    var index: Int = 0
+        private set
+    var indexNext: Int = 0
+        private set
+    private var length: Int = 0
+
+    private fun init(text: CharSequence) {
+        this.text = text
+        index = -1
+        indexNext = 0
+        length = text.length
+    }
+
+    fun forward(): Int {
+        this.index = indexNext
+        if (index == length) {
+            return TYPE_EOF
+        }
+        var ch = text!![index]
+        when (ch) {
+            '\n' -> {
+                indexNext = index + 1
+                return TYPE_NEWLINE
+            }
+            '\r' -> {
+                if (index + 1 < length && text!![index + 1] == '\n') {
+                    indexNext = index + 2
+                } else {
+                    indexNext = index + 1
+                }
+                return TYPE_NEWLINE
+            }
+            else -> {
+                indexNext = index + 1
+                while (indexNext < length) {
+                    ch = text!![indexNext]
+                    if (ch == '\n' || ch == '\r') {
+                        break
+                    }
+                    indexNext++
+                }
+                return TYPE_LINE_CONTENT
+            }
+        }
+    }
+
+    fun recycle() {
+        synchronized(InsertTextHelper::class.java) {
+            for (i in sCached.indices) {
+                if (sCached[i] == null) {
+                    sCached[i] = this
+                    reset()
+                    break
+                }
+            }
+        }
+    }
+
+    fun reset() {
+        text = null
+        index = 0
+        length = 0
+    }
+
+    companion object {
+        private val sCached = arrayOfNulls<InsertTextHelper>(8)
+        const val TYPE_LINE_CONTENT: Int = 0
+        const val TYPE_NEWLINE: Int = 1
+        const val TYPE_EOF: Int = 2
+
+        @Synchronized
+        private fun obtain(): InsertTextHelper {
+            for (i in sCached.indices) {
+                if (sCached[i] != null) {
+                    val cache = sCached[i]
+                    sCached[i] = null
+                    return cache!!
+                }
+            }
+            return InsertTextHelper()
+        }
+
+        @JvmStatic
+        fun forInsertion(text: CharSequence): InsertTextHelper {
+            val o = obtain()
+            o.init(text)
+            return o
+        }
+    }
+}

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

@@ -0,0 +1,51 @@
+package io.github.abc15018045126.sora.text
+
+/**
+ * Line separator types
+ *
+ * @author abc15018045126
+ */
+enum class LineSeparator(val content: String) {
+    /**
+     * Line Feed
+     */
+    LF("\n"),
+
+    /**
+     * Carriage Return
+     */
+    CR("\r"),
+
+    /**
+     * Carriage Return and Line Feed
+     */
+    CRLF("\r\n"),
+
+    /**
+     * Unknown or no line separator
+     */
+    NONE("");
+
+    val length: Int
+        get() = content.length
+
+    val chars: CharArray
+        get() = content.toCharArray()
+
+    companion object {
+        @JvmStatic
+        fun fromSeparatorString(text: CharSequence, start: Int, end: Int): LineSeparator {
+            val len = end - start
+            if (len == 1) {
+                val ch = text[start]
+                if (ch == '\n') return LF
+                if (ch == '\r') return CR
+            } else if (len == 2) {
+                if (text[start] == '\r' && text[start + 1] == '\n') {
+                    return CRLF
+                }
+            }
+            return NONE
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+package io.github.abc15018045126.sora.text
+
+import android.util.Log
+import io.github.abc15018045126.sora.lang.styling.Span
+import java.util.concurrent.ArrayBlockingQueue
+import java.util.concurrent.BlockingQueue
+
+class SpanRecycler private constructor() {
+
+    private val taskQueue: BlockingQueue<MutableList<Span>> = ArrayBlockingQueue(8)
+    private var recycleThread: RecycleThread? = null
+
+    fun recycle(spans: MutableList<Span>?) {
+        if (spans == null) {
+            return
+        }
+        if (recycleThread == null || !recycleThread!!.isAlive) {
+            recycleThread = RecycleThread()
+            recycleThread!!.start()
+        }
+        taskQueue.offer(spans)
+    }
+
+    private inner class RecycleThread internal constructor() : Thread() {
+
+        init {
+            isDaemon = true
+            name = "SpanRecycleDaemon"
+        }
+
+        override fun run() {
+            try {
+                while (!isInterrupted) {
+                    try {
+                        val spans = taskQueue.take()
+                        var count = 0
+                        val size = spans.size
+                        for (i in 0 until size) {
+                            val recycled = spans.removeAt(size - 1 - i).recycle()
+                            if (!recycled) {
+                                break
+                            }
+                            count++
+                        }
+                        Log.i(LOG_TAG, "Called recycle() on $count spans")
+                    } catch (e: InterruptedException) {
+                        e.printStackTrace()
+                        break
+                    }
+                }
+            } catch (e: Exception) {
+                Log.w(LOG_TAG, e)
+            }
+            Log.i(LOG_TAG, "Recycler exited")
+        }
+    }
+
+    companion object {
+        private const val LOG_TAG = "SpanRecycler"
+        private var INSTANCE: SpanRecycler? = null
+
+        @JvmStatic
+        @Synchronized
+        fun getInstance(): SpanRecycler {
+            if (INSTANCE == null) {
+                INSTANCE = SpanRecycler()
+            }
+            return INSTANCE!!
+        }
+    }
+}