capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,104 @@
+package io.github.abc15018045126.sora.text.bidi
+
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.text.ContentLine
+import io.github.abc15018045126.sora.text.ContentListener
+import io.github.abc15018045126.sora.util.IntPair
+import java.util.Arrays
+
+/**
+ * Companion for [Content] to manage line directions
+ *
+ * @author abc15018045126
+ */
+class ContentBidi(content: Content) : ContentListener {
+
+    private val entries = arrayOfNulls<DirectionsEntry>(MAX_BIDI_CACHE_ENTRY_COUNT)
+    private val text: Content = content
+    var isEnabled: Boolean = false
+        set(enabled) {
+            field = enabled
+            if (!enabled) {
+                Arrays.fill(entries, null)
+            }
+        }
+
+    init {
+        text.addContentListener(this)
+    }
+
+    fun getLineDirections(lineText: ContentLine, line: Int): Directions {
+        if (!isEnabled) {
+            return Directions(longArrayOf(IntPair.pack(0, 0)), lineText.length)
+        }
+        synchronized(this) {
+            for (i in entries.indices) {
+                val entry = entries[i]
+                if (entry != null && entry.line == line) {
+                    return entry.dir
+                }
+            }
+        }
+        val dir = TextBidi.getDirections(lineText)
+        synchronized(this) {
+            System.arraycopy(entries, 0, entries, 1, entries.size - 1)
+            entries[0] = DirectionsEntry(dir, line)
+        }
+        return dir
+    }
+
+    @Synchronized
+    override fun afterDelete(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        deletedContent: CharSequence
+    ) {
+        val delta = endLine - startLine
+        for (i in entries.indices) {
+            val entry = entries[i] ?: continue
+            if (entry.line >= startLine) {
+                if (entry.line > endLine) {
+                    entry.line -= delta
+                } else {
+                    entries[i] = null
+                }
+            }
+        }
+    }
+
+    @Synchronized
+    override fun afterInsert(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        insertedContent: CharSequence
+    ) {
+        val delta = endLine - startLine
+        for (i in entries.indices) {
+            val entry = entries[i] ?: continue
+            if (entry.line > startLine) {
+                entry.line += delta
+            } else if (entry.line == startLine) {
+                entries[i] = null
+            }
+        }
+    }
+
+    override fun beforeReplace(content: Content) {}
+
+    fun destroy() {
+        text.removeContentListener(this)
+        Arrays.fill(entries, null)
+    }
+
+    private class DirectionsEntry(var dir: Directions, var line: Int)
+
+    companion object {
+        const val MAX_BIDI_CACHE_ENTRY_COUNT = 64
+    }
+}

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

@@ -0,0 +1,43 @@
+package io.github.abc15018045126.sora.text.bidi
+
+import io.github.abc15018045126.sora.util.IntPair
+
+/**
+ * Manages directions in a text segment
+ *
+ * @author abc15018045126
+ */
+class Directions(private var runs: LongArray, private var length: Int) : IDirections {
+
+    fun setData(runs: LongArray, length: Int) {
+        this.runs = runs
+        this.length = length
+    }
+
+    fun setLength(length: Int) {
+        this.length = length
+    }
+
+    fun getLength(): Int {
+        return length
+    }
+
+    override val runCount: Int
+        get() = runs.size
+
+    override fun getRunStart(i: Int): Int {
+        return IntPair.getFirst(runs[i])
+    }
+
+    override fun getRunEnd(i: Int): Int {
+        return if (i == runs.size - 1) length else getRunStart(i + 1)
+    }
+
+    override fun getRunLevel(i: Int): Int {
+        return IntPair.getSecond(runs[i])
+    }
+
+    override fun isRunRtl(i: Int): Boolean {
+        return (getRunLevel(i) and 1) == 1
+    }
+}

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

@@ -0,0 +1,9 @@
+package io.github.abc15018045126.sora.text.bidi
+
+interface IDirections {
+    val runCount: Int
+    fun getRunStart(i: Int): Int
+    fun getRunEnd(i: Int): Int
+    fun getRunLevel(i: Int): Int
+    fun isRunRtl(i: Int): Boolean
+}

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

@@ -0,0 +1,67 @@
+package io.github.abc15018045126.sora.text.bidi
+
+import android.text.TextUtils
+import java.text.Bidi
+import io.github.abc15018045126.sora.util.IntPair
+import io.github.abc15018045126.sora.util.TemporaryCharBuffer
+
+/**
+ * Text bidirectional utils. Some codes are from AOSP
+ *
+ * @author abc15018045126
+ */
+object TextBidi {
+
+    /**
+     * Compute text directions for the given text
+     */
+    @JvmStatic
+    fun getDirections(text: CharSequence): Directions {
+        val len = text.length
+        if (doesNotNeedBidi(text)) {
+            return Directions(longArrayOf(IntPair.pack(0, 0)), len)
+        }
+        val chars = TemporaryCharBuffer.obtain(len)
+        TextUtils.getChars(text, 0, len, chars, 0)
+        val bidi = Bidi(chars, 0, null, 0, text.length, Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT)
+        val runs = LongArray(bidi.runCount)
+        for (i in runs.indices) {
+            runs[i] = IntPair.pack(bidi.getRunStart(i), bidi.getRunLevel(i))
+        }
+        TemporaryCharBuffer.recycle(chars)
+        return Directions(runs, len)
+    }
+
+    @JvmStatic
+    fun couldAffectRtl(c: Char): Boolean {
+        val i = c.code
+        return (i in 0x0590..0x08FF) ||  // RTL scripts
+                i == 0x200E ||  // Bidi format character
+                i == 0x200F ||  // Bidi format character
+                (i in 0x202A..0x202E) ||  // Bidi format characters
+                (i in 0x2066..0x2069) ||  // Bidi format characters
+                (i in 0xD800..0xDFFF) ||  // Surrogate pairs
+                (i in 0xFB1D..0xFDFF) ||  // Hebrew and Arabic presentation forms
+                (i in 0xFE70..0xFEFE)    // Arabic presentation forms
+    }
+
+    /**
+     * Returns true if there is no character present that may potentially affect RTL layout.
+     * Since this calls couldAffectRtl() above, it's also quite conservative, in the way that
+     * it may return 'false' (needs bidi) although careful consideration may tell us it should
+     * return 'true' (does not need bidi).
+     */
+    @JvmStatic
+    fun doesNotNeedBidi(text: CharSequence): Boolean {
+        if (text is BidiRequirementChecker) {
+            return !text.mayNeedBidi()
+        }
+        val len = text.length
+        for (i in 0 until len) {
+            if (couldAffectRtl(text[i])) {
+                return false
+            }
+        }
+        return true
+    }
+}

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

@@ -0,0 +1,45 @@
+package io.github.abc15018045126.sora.text.bidi
+
+import io.github.abc15018045126.sora.util.IntPair
+import java.text.Bidi
+
+/**
+ * Helper class for reordering logical text runs to visual runs.
+ *
+ * @author abc15018045126
+ */
+class VisualDirections(dirs: Directions) : IDirections {
+    private val runs: Array<RunInfo?> // Bidi.reorderVisually takes Object[]
+
+    private class RunInfo(var range: Long, var level: Int)
+
+    init {
+        val runCount = dirs.runCount
+        runs = arrayOfNulls(runCount)
+        val paramLevels = ByteArray(runCount)
+        for (i in 0 until runCount) {
+            paramLevels[i] = dirs.getRunLevel(i).toByte()
+            runs[i] = RunInfo(IntPair.pack(dirs.getRunStart(i), dirs.getRunEnd(i)), dirs.getRunLevel(i))
+        }
+        Bidi.reorderVisually(paramLevels, 0, runs, 0, runCount)
+    }
+
+    override val runCount: Int
+        get() = runs.size
+
+    override fun getRunStart(i: Int): Int {
+        return IntPair.getFirst(runs[i]!!.range)
+    }
+
+    override fun getRunEnd(i: Int): Int {
+        return IntPair.getSecond(runs[i]!!.range)
+    }
+
+    override fun getRunLevel(i: Int): Int {
+        return runs[i]!!.level
+    }
+
+    override fun isRunRtl(i: Int): Boolean {
+        return (getRunLevel(i) and 1) != 0
+    }
+}

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

@@ -0,0 +1,19 @@
+package io.github.abc15018045126.sora.text.breaker
+
+import io.github.abc15018045126.sora.text.ContentLine
+
+/**
+ * Breakpoint optimizer used when breaking text to visual rows
+ */
+interface WordBreaker {
+
+    fun getOptimizedBreakPoint(start: Int, end: Int): Int
+
+    object Factory {
+
+        @JvmStatic
+        fun newInstance(text: ContentLine): WordBreaker {
+            return WordBreakerProgram(text)
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+package io.github.abc15018045126.sora.text.breaker
+
+class WordBreakerEmpty private constructor() : WordBreaker {
+
+    override fun getOptimizedBreakPoint(start: Int, end: Int): Int {
+        return end
+    }
+
+    companion object {
+        @JvmField
+        val INSTANCE: WordBreaker = WordBreakerEmpty()
+    }
+}

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

@@ -0,0 +1,36 @@
+package io.github.abc15018045126.sora.text.breaker
+
+import io.github.abc15018045126.sora.text.CharSequenceIterator
+import io.github.abc15018045126.sora.text.ContentLine
+import java.text.BreakIterator
+import kotlin.math.max
+import kotlin.math.min
+
+open class WordBreakerIcu(text: ContentLine) : WordBreaker {
+
+    protected val wrappingIterator: BreakIterator
+    protected val chars: CharArray
+
+    init {
+        this.chars = text.backingCharArray
+        val textIterator = CharSequenceIterator(text)
+        wrappingIterator = BreakIterator.getLineInstance()
+        wrappingIterator.setText(textIterator)
+    }
+
+    override fun getOptimizedBreakPoint(start: Int, end: Int): Int {
+        var resultEnd = end
+        // Merging trailing whitespaces is not supported by editor, so force to break here
+        if (resultEnd > 0 && !Character.isWhitespace(chars[resultEnd - 1]) && !wrappingIterator.isBoundary(resultEnd)) {
+            // Break text at last boundary
+            val lastBoundary = wrappingIterator.preceding(resultEnd)
+            if (lastBoundary != BreakIterator.DONE) {
+                val suggestedNext = max(start, min(resultEnd, lastBoundary))
+                if (suggestedNext > start) {
+                    resultEnd = suggestedNext
+                }
+            }
+        }
+        return resultEnd
+    }
+}

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

@@ -0,0 +1,23 @@
+package io.github.abc15018045126.sora.text.breaker
+
+import io.github.abc15018045126.sora.text.ContentLine
+
+class WordBreakerProgram(text: ContentLine) : WordBreakerIcu(text) {
+
+    override fun getOptimizedBreakPoint(start: Int, end: Int): Int {
+        val icuResult = super.getOptimizedBreakPoint(start, end)
+        if (icuResult != end || end <= start || /* end > start */ Character.isWhitespace(chars[end - 1])) {
+            return icuResult
+        }
+        // Add extra opportunities for dots
+        var index = end - 1
+        while (index > start) {
+            if (chars[index] == '.' && index - 1 >= start && !Character.isDigit(chars[index - 1])) {
+                // Break after this dot
+                return index + 1
+            }
+            index--
+        }
+        return end
+    }
+}

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

@@ -0,0 +1,55 @@
+package io.github.abc15018045126.sora.text.method
+
+import android.text.Editable
+import android.text.method.MetaKeyKeyListener
+import android.view.KeyEvent
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Handles key events such as SHIFT
+ *
+ * @author abc15018045126
+ */
+class KeyMetaStates(private val editor: CodeEditor) : MetaKeyKeyListener() {
+
+    /**
+     * Dummy text used for Android original APIs
+     */
+    private val dest: Editable = Editable.Factory.getInstance().newEditable("")
+    var isCtrlPressed = false
+        private set
+
+    fun onKeyDown(event: KeyEvent) {
+        super.onKeyDown(editor, dest, event.keyCode, event)
+        isCtrlPressed = event.isCtrlPressed
+    }
+
+    fun onKeyUp(event: KeyEvent) {
+        super.onKeyUp(editor, dest, event.keyCode, event)
+        isCtrlPressed = event.isCtrlPressed
+    }
+
+    fun getMetaState(event: KeyEvent): Int {
+        return getMetaState(dest, event)
+    }
+
+    val isShiftPressed: Boolean
+        get() = getMetaState(dest, META_SHIFT_ON) == 1
+
+    val isAltPressed: Boolean
+        get() = getMetaState(dest, META_ALT_ON) == 1
+
+    val isSymPressed: Boolean
+        get() = getMetaState(dest, META_SYM_ON) == 1
+
+    val isSelecting: Boolean
+        get() = isShiftPressed && !isAltPressed
+
+    fun adjustAfterKeyPress() {
+        adjustMetaAfterKeypress(dest)
+    }
+
+    fun clearMetaStates(states: Int) {
+        clearMetaKeyState(editor, dest, states)
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/util/BinaryHeap.kt

@@ -0,0 +1,216 @@
+package io.github.abc15018045126.sora.util
+
+import android.util.SparseIntArray
+import io.github.abc15018045126.sora.util.IntPair.getFirst
+import io.github.abc15018045126.sora.util.IntPair.getSecond
+import io.github.abc15018045126.sora.util.IntPair.pack
+import java.util.concurrent.locks.Lock
+import java.util.concurrent.locks.ReentrantLock
+
+/**
+ * A general implementation of big root heap
+ *
+ * @author abc15018045126
+ */
+class BinaryHeap {
+
+    /**
+     * Lock for multi-thread reusing
+     */
+    @JvmField
+    val lock: Lock = ReentrantLock()
+
+    /**
+     * Map from id to its position in heap array
+     */
+    private val idToPosition: SparseIntArray = SparseIntArray()
+
+    /**
+     * Id allocator
+     */
+    private var idAllocator = 1
+
+    /**
+     * Current node count in heap
+     */
+    private var nodeCount = 0
+
+    /**
+     * Node array for heap.
+     * first:  id
+     * second: data
+     */
+    private var nodes: LongArray = LongArray(129)
+
+    private fun id(value: Long): Int {
+        return getFirst(value)
+    }
+
+    private fun data(value: Long): Int {
+        return getSecond(value)
+    }
+
+    /**
+     * Clear all the nodes in the heap
+     */
+    fun clear() {
+        nodeCount = 0
+        idToPosition.clear()
+        idAllocator = 1
+    }
+
+    /**
+     * Ensure there is enough space
+     *
+     * @param capacity desired space size
+     */
+    fun ensureCapacity(capacity: Int) {
+        var cap = capacity
+        cap++
+        if (nodes.size < cap) {
+            val origin = nodes
+            if (nodes.size shl 1 >= cap) {
+                nodes = LongArray(nodes.size shl 1)
+            } else {
+                nodes = LongArray(cap)
+            }
+            System.arraycopy(origin, 0, nodes, 0, nodeCount + 1)
+        }
+    }
+
+    /**
+     * Get the max value in this heap or zero if no node is in heap
+     *
+     * @return Max value
+     */
+    fun top(): Int {
+        if (nodeCount == 0) {
+            return 0
+        }
+        return data(nodes[1])
+    }
+
+    /**
+     * Get total node count in heap
+     */
+    fun getNodeCount(): Int {
+        return nodeCount
+    }
+
+    /**
+     * Internal implementation to move down nodes
+     *
+     * @param position target node's position in heap
+     */
+    private fun heapifyDown(position: Int) {
+        var pos = position
+        var child = pos * 2
+        while (child <= nodeCount) {
+            val parentNode = nodes[pos]
+            var childNode: Long
+            if (child + 1 <= nodeCount && data(nodes[child + 1]) > data(nodes[child])) {
+                child = child + 1
+            }
+            childNode = nodes[child]
+            if (data(parentNode) < data(childNode)) {
+                idToPosition.put(id(childNode), pos)
+                idToPosition.put(id(parentNode), child)
+                nodes[child] = parentNode
+                nodes[pos] = childNode
+                pos = child
+            } else {
+                break
+            }
+            child = pos * 2
+        }
+    }
+
+    /**
+     * Internal implementation to move up nodes
+     *
+     * @param position target node's position in heap
+     */
+    private fun heapifyUp(position: Int) {
+        var pos = position
+        var parent = pos / 2
+        while (parent >= 1) {
+            val childNode = nodes[pos]
+            val parentNode = nodes[parent]
+            if (data(childNode) > data(parentNode)) {
+                idToPosition.put(id(childNode), parent)
+                idToPosition.put(id(parentNode), pos)
+                nodes[pos] = parentNode
+                nodes[parent] = childNode
+                pos = parent
+            } else {
+                break
+            }
+            parent = pos / 2
+        }
+    }
+
+    /**
+     * Add a new node to the heap
+     *
+     * @return ID of node
+     * @throws IllegalStateException when there is no new id available
+     */
+    fun push(value: Int): Int {
+        ensureCapacity(nodeCount + 1)
+        if (idAllocator == Int.MAX_VALUE) {
+            throw IllegalStateException("unable to allocate more id")
+        }
+        val id = idAllocator++
+        nodeCount++
+        nodes[nodeCount] = pack(id, value)
+        idToPosition.put(id, nodeCount)
+        heapifyUp(nodeCount)
+        return id
+    }
+
+    /**
+     * Update the value of node with given id to newValue
+     *
+     * @param id       ID returned by push()
+     * @param newValue new value for this node
+     * @throws IllegalArgumentException when the id is invalid
+     */
+    fun update(id: Int, newValue: Int) {
+        val position = idToPosition.get(id, 0)
+        if (position == 0) {
+            throw IllegalArgumentException("trying to update with an invalid id")
+        }
+        val origin = data(nodes[position])
+        nodes[position] = pack(id(nodes[position]), newValue)
+        if (origin < newValue) {
+            heapifyUp(position)
+        } else if (origin > newValue) {
+            heapifyDown(position)
+        }
+    }
+
+    /**
+     * Remove node with given id
+     *
+     * @param id ID returned by push()
+     * @throws IllegalArgumentException when the id is invalid
+     */
+    fun remove(id: Int) {
+        val position = idToPosition.get(id, 0)
+        if (position == 0) {
+            throw IllegalArgumentException("trying to remove with an invalid id")
+        }
+        idToPosition.delete(id)
+        //Replace removed node with last node
+        nodes[position] = nodes[nodeCount]
+        //Release node
+        nodes[nodeCount--] = 0
+        //Do not update heap if it is just the last node
+        if (position == nodeCount + 1) {
+            return
+        }
+        idToPosition.put(id(nodes[position]), position)
+        heapifyUp(position)
+        heapifyDown(position)
+    }
+}