capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/CodeBlock.kt

@@ -0,0 +1,165 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import java.util.Objects
+
+/**
+ * Code block info model
+ *
+ * @author Rose
+ */
+class CodeBlock {
+
+    /**
+     * Start line of code block
+     */
+    @JvmField
+    var startLine: Int = 0
+
+    /**
+     * Start column of code block
+     */
+    @JvmField
+    var startColumn: Int = 0
+
+    /**
+     * End line of code block
+     */
+    @JvmField
+    var endLine: Int = 0
+
+    /**
+     * End column of code block
+     */
+    @JvmField
+    var endColumn: Int = 0
+
+    /**
+     * Indicates that this BlockLine should be drawn vertically until the bottom of its end line
+     */
+    @JvmField
+    var toBottomOfEndLine: Boolean = false
+
+    fun clear() {
+        startLine = 0
+        startColumn = 0
+        endLine = 0
+        endColumn = 0
+        toBottomOfEndLine = false
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || javaClass != other.javaClass) return false
+        val codeBlock = other as CodeBlock
+        return startLine == codeBlock.startLine &&
+                startColumn == codeBlock.startColumn &&
+                endLine == codeBlock.endLine &&
+                endColumn == codeBlock.endColumn &&
+                toBottomOfEndLine == codeBlock.toBottomOfEndLine
+    }
+
+    override fun hashCode(): Int {
+        return Objects.hash(startLine, startColumn, endLine, endColumn, toBottomOfEndLine)
+    }
+
+    override fun toString(): String {
+        return "BlockLine{" +
+                "startLine=$startLine" +
+                ", startColumn=$startColumn" +
+                ", endLine=$endLine" +
+                ", endColumn=$endColumn" +
+                ", toBottomOfEndLine=$toBottomOfEndLine" +
+                '}'
+    }
+
+    companion object {
+        @JvmField
+        val COMPARATOR_END = Comparator<CodeBlock> { a, b ->
+            val res = Integer.compare(a.endLine, b.endLine)
+            if (res == 0) {
+                Integer.compare(a.endColumn, b.endColumn)
+            } else {
+                res
+            }
+        }
+
+        @JvmField
+        val COMPARATOR_START = Comparator<CodeBlock> { a, b ->
+            val res = Integer.compare(a.startLine, b.startLine)
+            if (res == 0) {
+                Integer.compare(a.startColumn, b.startColumn)
+            } else {
+                res
+            }
+        }
+
+        /**
+         * Performs a binary search to find the index of the smallest code block whose end line is
+         * greater than or equal to the specified line.
+         *
+         * This implementation also handles the case where the elements in the list are
+         * `null`. If a null element is encountered at `mid`, we look for the
+         * first non-null element either before and after the element and set it as `mid`.
+         *
+         * @param line   The line number to search for.
+         * @param blocks The list of code blocks to search within.
+         * @return The index of the smallest code block with an end line greater than or equal to the
+         * specified line. If no matching code block is found, -1 is returned.
+         */
+        @JvmStatic
+        fun binarySearchEndBlock(line: Int, blocks: List<CodeBlock>?): Int {
+            if (blocks == null || blocks.isEmpty()) {
+                return -1
+            }
+
+            var left = 0
+            var right = blocks.size - 1
+            val max = right
+
+            while (left <= right) {
+                var mid = left + (right - left) / 2
+                if (mid < 0 || mid > max) {
+                    return -1
+                }
+
+                var block = blocks[mid]
+                if (block == null) {
+                    var nonNullLeft = mid - 1
+                    var nonNullRight = mid + 1
+
+                    while (true) {
+                        if (nonNullLeft < left && nonNullRight > right) {
+                            return -1
+                        } else if (nonNullLeft >= left && blocks[nonNullLeft] != null) {
+                            mid = nonNullLeft
+                            break
+                        } else if (nonNullRight <= right && blocks[nonNullRight] != null) {
+                            mid = nonNullRight
+                            break
+                        }
+                        nonNullLeft--
+                        nonNullRight++
+                    }
+
+                    block = blocks[mid]
+                }
+
+                val row = block!!.endLine
+                when {
+                    row > line -> right = mid - 1
+                    row < line -> left = mid + 1
+                    else -> {
+                        left = mid
+                        break
+                    }
+                }
+            }
+
+            if (left < 0 || left > max) {
+                return -1
+            }
+
+            return left
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/EmptyReader.kt

@@ -0,0 +1,30 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+class EmptyReader : Spans.Reader {
+
+    private val spans: List<Span> = listOf(
+        SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong())
+    )
+
+    override fun moveToLine(line: Int) {
+    }
+
+    override fun getSpanAt(index: Int): Span {
+        return spans[index]
+    }
+
+    override fun getSpanCount(): Int {
+        return 1
+    }
+
+    override fun getSpansOnLine(line: Int): List<Span> {
+        return ArrayList(spans)
+    }
+
+    companion object {
+        @JvmField
+        val INSTANCE = EmptyReader()
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/HighlightTextContainer.kt

@@ -18,7 +18,7 @@
  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  *     USA
  *
- *     Please contact abc15018045126 by email 2073412493@qq.com if you need
+ *     Please contact abc15018045126 by email abc15018045126@gmail.com if you need
  *     additional information or have any questions
  ******************************************************************************/
 

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/MappedSpanUpdater.kt

@@ -0,0 +1,180 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import io.github.abc15018045126.sora.lang.styling.span.SpanExtAttrs
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+/**
+ * Update spans on text change event
+ *
+ * @author abc15018045126
+ */
+object MappedSpanUpdater {
+
+    @JvmStatic
+    fun shiftSpansOnMultiLineDelete(
+        map: MutableList<MutableList<Span>>,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int
+    ) {
+        var lineCount = endLine - startLine - 1
+        // Remove unrelated lines
+        while (lineCount > 0) {
+            SpanFactory.recycleAll(map.removeAt(startLine + 1))
+            lineCount--
+        }
+        // Clean up start line
+        val startLineSpans = map[startLine]
+        var index = startLineSpans.size - 1
+        while (index > 0) {
+            if (startLineSpans[index].column >= startColumn) {
+                startLineSpans.removeAt(index).recycle()
+                index--
+            } else {
+                break
+            }
+        }
+        // Shift end line
+        val endLineSpans = map.removeAt(startLine + 1)
+        for (i in endLineSpans.indices) {
+            endLineSpans[i].shiftColumnBy(startColumn - endColumn)
+        }
+        while (endLineSpans.size > 1) {
+            if (endLineSpans[0].column <= startColumn && endLineSpans[1].column <= startColumn) {
+                endLineSpans.removeAt(0).recycle()
+            } else {
+                break
+            }
+        }
+        if (endLineSpans[0].column <= startColumn) {
+            endLineSpans[0].column = startColumn
+        }
+        startLineSpans.addAll(endLineSpans)
+    }
+
+    @JvmStatic
+    fun shiftSpansOnSingleLineDelete(map: MutableList<MutableList<Span>>?, line: Int, startCol: Int, endCol: Int) {
+        if (map.isNullOrEmpty()) {
+            return
+        }
+        val spanList = map[line]
+        var startIndex = findSpanIndexFor(spanList, 0, startCol)
+        if (startIndex == -1) {
+            // No span is to be updated
+            return
+        }
+        var endIndex = findSpanIndexFor(spanList, startIndex, endCol)
+        if (endIndex == -1) {
+            endIndex = spanList.size
+        }
+        // Remove spans inside delete text
+        val removeCount = endIndex - startIndex
+        for (i in 0 until removeCount) {
+            spanList.removeAt(startIndex).recycle()
+        }
+        // Shift spans
+        val delta = endCol - startCol
+        while (startIndex < spanList.size) {
+            spanList[startIndex].shiftColumnBy(-delta)
+            startIndex++
+        }
+        // Ensure there is span
+        if (spanList.isEmpty() || spanList[0].column != 0) {
+            spanList.add(0, SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong()))
+        }
+        // Remove spans with length 0
+        var i = 0
+        while (i + 1 < spanList.size) {
+            if (spanList[i].column >= spanList[i + 1].column) {
+                spanList.removeAt(i).recycle()
+                i--
+            }
+            i++
+        }
+    }
+
+    @JvmStatic
+    fun shiftSpansOnSingleLineInsert(map: MutableList<MutableList<Span>>?, line: Int, startCol: Int, endCol: Int) {
+        if (map.isNullOrEmpty()) {
+            return
+        }
+        val spanList = map[line]
+        var index = findSpanIndexFor(spanList, 0, startCol)
+        if (index == -1) {
+            return
+        }
+        val originIndex = index
+        // Shift spans after insert position
+        val delta = endCol - startCol
+        while (index < spanList.size) {
+            spanList[index++].shiftColumnBy(delta)
+        }
+        // Add extra span for line start
+        if (originIndex == 0) {
+            val first = spanList[0]
+            if (first.column == EditorColorScheme.TEXT_NORMAL && first.hasSpanExt(SpanExtAttrs.EXT_UNDERLINE_COLOR)) {
+                first.column = 0
+            } else {
+                spanList.add(0, SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong()))
+            }
+        }
+    }
+
+    @JvmStatic
+    fun shiftSpansOnMultiLineInsert(
+        map: MutableList<MutableList<Span>>,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int
+    ) {
+        // Find extended span
+        val startLineSpans = map[startLine]
+        var extendedSpanIndex = findSpanIndexFor(startLineSpans, 0, startColumn)
+        if (extendedSpanIndex == -1) {
+            extendedSpanIndex = startLineSpans.size - 1
+        }
+        if (startLineSpans[extendedSpanIndex].column > startColumn) {
+            extendedSpanIndex--
+        }
+        val extendedSpan: Span
+        if (extendedSpanIndex < 0 || extendedSpanIndex >= startLineSpans.size) {
+            extendedSpan = SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong())
+        } else {
+            extendedSpan = startLineSpans[extendedSpanIndex]
+        }
+        // Create map lines for new lines
+        for (i in 0 until endLine - startLine) {
+            val list = mutableListOf<Span>()
+            val newSpan = extendedSpan.copy()
+            newSpan.column = 0
+            list.add(newSpan)
+            map.add(startLine + 1, list)
+        }
+        // Add original spans to new line
+        val endLineSpans = map[endLine]
+        var idx = extendedSpanIndex
+        while (idx < startLineSpans.size) {
+            val span = startLineSpans[idx++]
+            val newSpan = span.copy()
+            newSpan.column = Math.max(0, span.column - startColumn + endColumn)
+            endLineSpans.add(newSpan)
+        }
+        while (extendedSpanIndex + 1 < startLineSpans.size) {
+            startLineSpans.removeAt(startLineSpans.size - 1).recycle()
+        }
+        if (endLineSpans.size > 1 && endLineSpans[0].column == 0 && endLineSpans[1].column == 0) {
+            endLineSpans.removeAt(0).recycle()
+        }
+    }
+
+    private fun findSpanIndexFor(spans: List<Span>, initialPosition: Int, targetCol: Int): Int {
+        for (i in initialPosition until spans.size) {
+            if (spans[i].column >= targetCol) {
+                return i
+            }
+        }
+        return -1
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/MappedSpans.kt

@@ -0,0 +1,210 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import androidx.annotation.NonNull
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+import java.util.*
+
+/**
+ * Store spans by mapping.
+ *
+ * @see Builder
+ */
+class MappedSpans private constructor(@NonNull private val spanMap: MutableList<MutableList<Span>>) : Spans {
+
+    override fun adjustOnInsert(start: CharPosition, end: CharPosition) {
+        val startLine = start.line
+        val endLine = end.line
+        val startColumn = start.column
+        val endColumn = end.column
+        if (startLine == endLine) {
+            MappedSpanUpdater.shiftSpansOnSingleLineInsert(spanMap, startLine, startColumn, endColumn)
+        } else {
+            MappedSpanUpdater.shiftSpansOnMultiLineInsert(spanMap, startLine, startColumn, endLine, endColumn)
+        }
+    }
+
+    override fun adjustOnDelete(start: CharPosition, end: CharPosition) {
+        val startLine = start.line
+        val endLine = end.line
+        val startColumn = start.column
+        val endColumn = end.column
+        if (startLine == endLine) {
+            MappedSpanUpdater.shiftSpansOnSingleLineDelete(spanMap, startLine, startColumn, endColumn)
+        } else {
+            MappedSpanUpdater.shiftSpansOnMultiLineDelete(spanMap, startLine, startColumn, endLine, endColumn)
+        }
+    }
+
+    override fun read(): Spans.Reader {
+        return MappedSpansAccessor()
+    }
+
+    override fun supportsModify(): Boolean {
+        return true
+    }
+
+    override fun modify(): Spans.Modifier {
+        return MappedSpansAccessor()
+    }
+
+    override fun getLineCount(): Int {
+        return spanMap.size
+    }
+
+    /**
+     * Allow you to build a span map linearly.
+     */
+    class Builder @JvmOverloads constructor(lineCapacity: Int = 128) {
+        private val spans: MutableList<MutableList<Span>> = ArrayList(lineCapacity)
+        private var last: Span? = null
+
+        /**
+         * Add a new span if required.
+         *
+         * If no special style is specified, you can use colorId as style long integer
+         *
+         * @param spanLine Line
+         * @param column   Column
+         * @param style    Style of text
+         */
+        fun addIfNeeded(spanLine: Int, column: Int, style: Long) {
+            val currentLast = last
+            if (currentLast != null && currentLast.style == style) {
+                return
+            }
+            add(spanLine, SpanFactory.obtainNoExt(column, style))
+        }
+
+        /**
+         * Add a span directly
+         *
+         * Note: the line should always >= the line of span last committed
+         *
+         * If two spans are on the same line, you must add them in order by their column
+         *
+         * @param spanLine The line position of span
+         * @param span     The span
+         */
+        fun add(spanLine: Int, span: Span) {
+            var mapLine = spans.size - 1
+            if (spanLine == mapLine) {
+                spans[spanLine].add(span)
+            } else if (spanLine > mapLine) {
+                var extendedSpan = last
+                if (extendedSpan == null) {
+                    extendedSpan = SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong())
+                }
+                while (mapLine < spanLine) {
+                    val lineSpans = mutableListOf<Span>()
+                    lineSpans.add(copyAndSetColumn(extendedSpan, 0))
+                    spans.add(lineSpans)
+                    mapLine++
+                }
+                val lineSpans = spans[spanLine]
+                if (span.column == 0) {
+                    lineSpans.clear()
+                }
+                lineSpans.add(span)
+            } else {
+                throw IllegalStateException("Invalid position")
+            }
+            last = span
+        }
+
+        /**
+         * This method must be called when whole text is analyzed.
+         * **Note that it is not the line count but line index!**
+         *
+         * @param line The line is the line last of text
+         */
+        fun determine(line: Int) {
+            var mapLine = spans.size - 1
+            var extendedSpan = last
+            if (extendedSpan == null) {
+                extendedSpan = SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong())
+            }
+            while (mapLine < line) {
+                val lineSpans = mutableListOf<Span>()
+                lineSpans.add(copyAndSetColumn(extendedSpan, 0))
+                spans.add(lineSpans)
+                mapLine++
+            }
+        }
+
+        /**
+         * Ensure the list not empty
+         */
+        fun addNormalIfNull() {
+            if (spans.isEmpty()) {
+                val spanList = mutableListOf<Span>()
+                spanList.add(SpanFactory.obtainNoExt(0, EditorColorScheme.TEXT_NORMAL.toLong()))
+                spans.add(spanList)
+            }
+        }
+
+        fun build(): MappedSpans {
+            return MappedSpans(spans)
+        }
+    }
+
+    private inner class MappedSpansAccessor : Spans.Reader, Spans.Modifier {
+        private var span: MutableList<Span>? = null
+
+        private fun checkLine() {
+            if (span == null) {
+                throw IllegalStateException("line must be set first")
+            }
+        }
+
+        override fun moveToLine(line: Int) {
+            if (line == -1) {
+                span = null
+                return
+            }
+            span = spanMap[line]
+        }
+
+        override fun getSpanCount(): Int {
+            checkLine()
+            return span!!.size
+        }
+
+        override fun getSpanAt(index: Int): Span {
+            checkLine()
+            return span!![index]
+        }
+
+        override fun getSpansOnLine(line: Int): List<Span> {
+            return Collections.unmodifiableList(spanMap[line])
+        }
+
+        override fun setSpansOnLine(line: Int, spans: List<Span>) {
+            val lastLine = spanMap[spanMap.size - 1]
+            val extend = lastLine[lastLine.size - 1]
+            while (spanMap.size <= line) {
+                val list = mutableListOf<Span>()
+                list.add(copyAndSetColumn(extend, 0))
+                spanMap.add(list)
+            }
+            spanMap[line] = ArrayList(spans)
+        }
+
+        override fun addLineAt(line: Int, spans: List<Span>) {
+            spanMap.add(line, ArrayList(spans))
+        }
+
+        override fun deleteLineAt(line: Int) {
+            spanMap.removeAt(line)
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        private fun copyAndSetColumn(s: Span, column: Int): Span {
+            val span = s.copy()
+            span.column = column
+            return span
+        }
+    }
+}