capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/layout/LineBreakLayout.kt

@@ -0,0 +1,370 @@
+package io.github.abc15018045126.sora.widget.layout
+
+import android.util.SparseArray
+import io.github.abc15018045126.sora.graphics.Paint
+import io.github.abc15018045126.sora.graphics.SingleCharacterWidths
+import io.github.abc15018045126.sora.lang.analysis.StyleUpdateRange
+import io.github.abc15018045126.sora.lang.styling.inlayHint.InlayHint
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.text.ContentLine
+import io.github.abc15018045126.sora.util.BlockIntList
+import io.github.abc15018045126.sora.util.IntPair
+import io.github.abc15018045126.sora.widget.CodeEditor
+import io.github.abc15018045126.sora.widget.EditorTouchEventHandler
+import java.util.NoSuchElementException
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Layout implementation of editor
+ * This layout is never broke unless there is actually a newline character
+ *
+ * @author Rose
+ */
+class LineBreakLayout(editor: CodeEditor, text: Content?) : AbstractLayout(editor, text) {
+
+    private val reuseCount = AtomicInteger(0)
+    private var widthMaintainer: BlockIntList? = null
+    private var inlineElementsWidths: BlockIntList? = null
+    private var measurer: SingleCharacterWidths? = null
+
+    init {
+        measurer = SingleCharacterWidths(editor.tabWidth)
+        measurer?.isHandleFunctionCharacters = editor.isRenderFunctionCharacters
+        widthMaintainer = BlockIntList()
+        inlineElementsWidths = BlockIntList()
+        measureAllLines(widthMaintainer!!, inlineElementsWidths!!)
+    }
+
+    private fun measureAllLines(widthMaintainer: BlockIntList, inlineElementsWidths: BlockIntList) {
+        val text = this.text ?: return
+        val editor = this.editor ?: return
+        val shadowPaint = Paint(editor.isRenderFunctionCharacters)
+        shadowPaint.set(editor.textPaint)
+        shadowPaint.onAttributeUpdate()
+        val reuseCountLocal = reuseCount.get()
+        val measurerLocal = measurer
+        val monitor = TaskMonitor(1, object : TaskMonitor.Callback {
+            override fun onCompleted(results: Array<Any?>, cancelledCount: Int) {
+                val currentEditor = this@LineBreakLayout.editor
+                if (currentEditor == null || cancelledCount > 0) {
+                    return
+                }
+                io.github.abc15018045126.sora.util.EditorHandler.post {
+                    if (currentEditor.isReleased) return@post
+                    if (this@LineBreakLayout.editor !== currentEditor || reuseCountLocal != reuseCount.get()) {
+                        return@post
+                    }
+                    currentEditor.setLayoutBusy(false)
+                    val touch: io.github.abc15018045126.sora.widget.EditorTouchEventHandler = currentEditor.touchHandler!!
+                    touch.scrollBy(0f, 0f)
+
+                }
+
+            }
+        })
+        val task = object : LayoutTask<Void?>(monitor) {
+            override fun compute(): Void? {
+                widthMaintainer.lock.lock()
+                try {
+                    text.runReadActionsOnLines(0, text.lineCount - 1, object : Content.ContentLineConsumer2 {
+                        override fun accept(index: Int, line: ContentLine, abortFlag: Content.ContentLineConsumer2.AbortFlag) {
+                            val width = measurerLocal?.measureText(line, 0, line.length, shadowPaint)?.toInt() ?: 0
+                            val inlineElementsWidth = measureInlayHints(getInlayHints(index), shadowPaint)
+                            if (shouldRun()) {
+                                widthMaintainer.add(width + inlineElementsWidth)
+                                inlineElementsWidths.add(inlineElementsWidth)
+                            } else {
+                                abortFlag.set = true
+                            }
+                        }
+                    })
+                } finally {
+                    widthMaintainer.lock.unlock()
+                }
+                return null
+            }
+
+            override fun shouldRun(): Boolean {
+                return super.shouldRun() && reuseCount.get() == reuseCountLocal
+            }
+        }
+        editor.setLayoutBusy(true)
+        submitTask(task)
+    }
+
+    private fun measureInlayHints(inlayHints: List<InlayHint>, paint: Paint): Int {
+        val editor = this.editor ?: return 0
+        var width = 0f
+        for (inlayHint in inlayHints) {
+            val renderer = editor.getInlayHintRendererForType(inlayHint.type) ?: continue
+            val w = renderer.measure(
+                inlayHint,
+                paint,
+                editor.renderer.createTextRowParams().toInlayHintRenderParams()
+            )
+            width += w
+        }
+        return width.toInt()
+    }
+
+    private fun measureLineAndUpdateInlineWidths(lineIndex: Int, useAdd: Boolean = false): Int {
+        val text = this.text ?: return 0
+        val editor = this.editor ?: return 0
+        val line = text.getLine(lineIndex)
+        val inlayHintsWidth = measureInlayHints(getInlayHints(lineIndex), editor.textPaint)
+        if (useAdd) {
+            inlineElementsWidths?.add(lineIndex, inlayHintsWidth)
+        } else {
+            inlineElementsWidths?.set(lineIndex, inlayHintsWidth)
+        }
+        return (measurer?.measureText(line, 0, line.length, editor.textPaint)?.toInt() ?: 0) + inlayHintsWidth
+    }
+
+    private fun measureTextRegion(lineIndex: Int, start: Int, end: Int): Int {
+        val text = this.text ?: return 0
+        val editor = this.editor ?: return 0
+        val line = text.getLine(lineIndex)
+        return measurer?.measureText(line, start, end, editor.textPaint)?.toInt() ?: 0
+    }
+
+    override fun obtainRowIterator(initialRow: Int, preloadedLines: SparseArray<ContentLine>?): RowIterator {
+        return LineBreakLayoutRowItr(this, text!!, initialRow, preloadedLines)
+    }
+
+    override fun invalidateLines(range: StyleUpdateRange) {
+        val text = this.text ?: return
+        val itr = range.lineIndexIterator(text.lineCount - 1)
+        while (itr.hasNext()) {
+            val line = itr.nextInt()
+            widthMaintainer?.set(line, measureLineAndUpdateInlineWidths(line))
+        }
+    }
+
+    override val rowCount: Int
+        get() = text?.lineCount ?: 0
+
+    override fun afterInsert(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        insertedContent: CharSequence
+    ) {
+        super.afterInsert(content, startLine, startColumn, endLine, endColumn, insertedContent)
+        val editor = this.editor ?: return
+        val widthMaintainer = this.widthMaintainer ?: return
+        val inlineElementsWidths = this.inlineElementsWidths ?: return
+        
+        for (i in startLine..endLine) {
+            if (i == startLine) {
+                if (endLine == startLine) {
+                    val oldInlayWidths = inlineElementsWidths.get(i)
+                    val newInlayWidths = measureInlayHints(getInlayHints(i), editor.textPaint)
+                    inlineElementsWidths.set(i, newInlayWidths)
+                    widthMaintainer.set(i, widthMaintainer.get(i) + measureTextRegion(i, startColumn, endColumn) + (newInlayWidths - oldInlayWidths))
+                } else {
+                    widthMaintainer.set(i, measureLineAndUpdateInlineWidths(i))
+                }
+            } else {
+                widthMaintainer.add(i, measureLineAndUpdateInlineWidths(i, true))
+            }
+        }
+    }
+
+    override fun afterDelete(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        deletedContent: CharSequence
+    ) {
+        super.afterDelete(content, startLine, startColumn, endLine, endColumn, deletedContent)
+        val editor = this.editor ?: return
+        val widthMaintainer = this.widthMaintainer ?: return
+        val inlineElementsWidths = this.inlineElementsWidths ?: return
+
+        if (startLine < endLine) {
+            widthMaintainer.removeRange(startLine + 1, endLine + 1)
+            inlineElementsWidths.removeRange(startLine + 1, endLine + 1)
+        }
+        if (startLine == endLine) {
+            val oldInlayWidths = inlineElementsWidths.get(startLine)
+            val newInlayWidths = measureInlayHints(getInlayHints(startLine), editor.textPaint)
+            inlineElementsWidths.set(startLine, newInlayWidths)
+            widthMaintainer.set(startLine, widthMaintainer.get(startLine)
+                    - (measurer?.measureText(deletedContent, 0, endColumn - startColumn, editor.textPaint)?.toInt() ?: 0)
+                    + (newInlayWidths - oldInlayWidths))
+        } else {
+            widthMaintainer.set(startLine, measureLineAndUpdateInlineWidths(startLine))
+        }
+    }
+
+    override fun getRowAt(rowIndex: Int): Row {
+        val row = Row()
+        row.lineIndex = rowIndex
+        row.startColumn = 0
+        row.isLeadingRow = true
+        row.isTrailingRow = true
+        row.endColumn = text?.getColumnCount(rowIndex) ?: 0
+        row.inlayHints = getInlayHints(rowIndex)
+        return row
+    }
+
+    override fun getRowIndexForPosition(index: Int): Int {
+        val editor = this.editor ?: return 0
+        return editor.text.indexer.getCharPosition(index).line
+    }
+
+    override fun destroyLayout() {
+        super.destroyLayout()
+        widthMaintainer = null
+        inlineElementsWidths = null
+        measurer = null
+    }
+
+    override fun getLineNumberForRow(row: Int): Int {
+        val lineCount = text?.lineCount ?: 1
+        return max(0, min(row, lineCount - 1))
+    }
+
+    override val layoutWidth: Int
+        get() {
+            val widthMaintainer = this.widthMaintainer ?: return Int.MAX_VALUE / 10
+            return if (widthMaintainer.size() == 0) Int.MAX_VALUE / 10 else widthMaintainer.max
+        }
+
+    override val layoutHeight: Int
+        get() = (text?.lineCount ?: 0) * (editor?.logicalRowHeight ?: 0)
+
+    override fun getRowTop(row: Int): Int {
+        return row * (editor?.logicalRowHeight ?: 0)
+    }
+
+    override fun getRowBottom(row: Int): Int {
+        return (row + 1) * (editor?.logicalRowHeight ?: 0)
+    }
+
+    override fun getRowIndexForY(y: Float): Int {
+        val rh = editor?.logicalRowHeight ?: 1
+        return (y / rh).toInt()
+    }
+
+    override fun getCharPositionForLayoutOffset(xOffset: Float, yOffset: Float): Long {
+        val editor = this.editor ?: return 0
+        val text = this.text ?: return 0
+        val lineCount = text.lineCount
+        val line = min(lineCount - 1, max((yOffset / editor.rowHeight).toInt(), 0))
+        val tr = editor.renderer.createTextRow(line)
+        val res = tr.getIndexForCursorOffset(xOffset)
+        return IntPair.pack(line, res)
+    }
+
+    override fun getCharLayoutOffset(line: Int, column: Int, array: FloatArray?): FloatArray {
+        var dest = array
+        if (dest == null || dest.size < 2) {
+            dest = FloatArray(2)
+        }
+        val editor = this.editor ?: return dest
+        dest[0] = editor.getRowBottom(line).toFloat()
+        val tr = editor.renderer.createTextRow(line)
+        dest[1] = tr.getCursorOffsetForIndex(column)
+        return dest
+    }
+
+    override fun getRowCountForLine(line: Int): Int {
+        return 1
+    }
+
+    override fun getDownPosition(line: Int, column: Int): Long {
+        val text = this.text ?: return 0
+        val c_line = text.lineCount
+        return if (line + 1 >= c_line) {
+            IntPair.pack(line, text.getColumnCount(line))
+        } else {
+            val c_column = text.getColumnCount(line + 1)
+            val newColumn = if (column > c_column) c_column else column
+            IntPair.pack(line + 1, newColumn)
+        }
+    }
+
+    override fun getUpPosition(line: Int, column: Int): Long {
+        val text = this.text ?: return 0
+        if (line - 1 < 0) {
+            return IntPair.pack(0, 0)
+        }
+        val c_column = text.getColumnCount(line - 1)
+        val newColumn = if (column > c_column) c_column else column
+        return IntPair.pack(line - 1, newColumn)
+    }
+
+    fun reuse(text: Content) {
+        val editor = this.editor ?: return
+        this.text = text
+        reuseCount.getAndIncrement()
+        measurer = SingleCharacterWidths(editor.tabWidth)
+        measurer?.isHandleFunctionCharacters = editor.isRenderFunctionCharacters
+        try {
+            val wm = widthMaintainer
+            if (wm != null && wm.lock.tryLock(5, TimeUnit.MILLISECONDS)) {
+                wm.lock.unlock()
+                wm.clear()
+                inlineElementsWidths?.clear()
+                measureAllLines(wm, inlineElementsWidths!!)
+            } else {
+                widthMaintainer = BlockIntList()
+                inlineElementsWidths = BlockIntList()
+                measureAllLines(widthMaintainer!!, inlineElementsWidths!!)
+            }
+        } catch (e: InterruptedException) {
+            throw RuntimeException("Unable to wait for lock", e)
+        }
+    }
+
+    class LineBreakLayoutRowItr(
+        private val layout: AbstractLayout,
+        private val text: Content,
+        private val initRow: Int,
+        private val preloadedLines: SparseArray<ContentLine>?
+    ) : RowIterator {
+
+        private val result: Row = Row()
+        private var currentRow: Int = initRow
+
+        init {
+            result.isLeadingRow = true
+            result.isTrailingRow = true
+            result.startColumn = 0
+        }
+
+        override fun next(): Row {
+            if (!hasNext()) {
+                throw NoSuchElementException()
+            }
+            result.lineIndex = currentRow
+            var line = preloadedLines?.get(currentRow)
+            if (line == null) {
+                line = text.getLine(currentRow)
+            }
+            result.endColumn = line.length
+            result.inlayHints = layout.getInlayHints(result.lineIndex)
+            currentRow++
+            return result
+        }
+
+        override fun hasNext(): Boolean {
+            return currentRow >= 0 && currentRow < text.lineCount
+        }
+
+        override fun reset() {
+            currentRow = initRow
+        }
+    }
+    fun findRow(line: Int): Int {
+        return line
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/layout/Row.kt

@@ -0,0 +1,57 @@
+package io.github.abc15018045126.sora.widget.layout
+
+import io.github.abc15018045126.sora.lang.styling.inlayHint.InlayHint
+
+/**
+ * This class represents a 'row' in editor.
+ * Editor uses this to draw rows
+ *
+ * @author abc15018045126
+ */
+class Row {
+    /**
+     * The index in lines
+     * But not row index
+     */
+    @JvmField
+    var lineIndex: Int = 0
+
+    /**
+     * Whether this row is the first one of a line.
+     * Editor will draw line number to left of this row to indicate this
+     */
+    @JvmField
+    var isLeadingRow: Boolean = false
+
+    /**
+     * Whether this row is the last one of a line.
+     * Editor will draw soft-wrap or line-break indicator according to this
+     */
+    @JvmField
+    var isTrailingRow: Boolean = false
+
+    /**
+     * Start index in target line
+     */
+    @JvmField
+    var startColumn: Int = 0
+
+    /**
+     * End index in target line
+     */
+    @JvmField
+    var endColumn: Int = 0
+
+    /**
+     * Inlay hints on the row
+     */
+    @JvmField
+    @JvmSuppressWildcards
+    var inlayHints: List<InlayHint> = emptyList()
+
+    /**
+     * Extra translation when rendering
+     */
+    @JvmField
+    var renderTranslateX: Float = 0f
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/layout/RowElement.kt

@@ -0,0 +1,52 @@
+package io.github.abc15018045126.sora.widget.layout
+
+import io.github.abc15018045126.sora.lang.styling.inlayHint.InlayHint
+
+/**
+ * Element on a row
+ *
+ * @author abc15018045126
+ */
+class RowElement {
+    /**
+     * Type of element.
+     *
+     * @see RowElementTypes
+     */
+    @JvmField
+    var type: Int = 0
+
+    /* Fields for type TEXT */
+
+    /**
+     * Start column of text
+     */
+    @JvmField
+    var startColumn: Int = 0
+
+    /**
+     * End column of text
+     */
+    @JvmField
+    var endColumn: Int = 0
+
+    /**
+     * Direction of the text run
+     */
+    @JvmField
+    var isRtlText: Boolean = false
+
+    /* Fields for type INLAY_HINT */
+
+    /**
+     * The inlay hint
+     */
+    @JvmField
+    var inlayHint: InlayHint? = null
+
+    /**
+     * The expected column position to display after
+     */
+    @JvmField
+    var displayColumnPosition: Int = 0
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/layout/RowElementTypes.kt

@@ -0,0 +1,18 @@
+package io.github.abc15018045126.sora.widget.layout
+
+/**
+ * Type constants for [RowElement]
+ *
+ * @author abc15018045126
+ */
+object RowElementTypes {
+    /**
+     * Unidirectional text segment
+     */
+    const val TEXT = 0
+
+    /**
+     * Inlay hint
+     */
+    const val INLAY_HINT = 1
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/layout/RowIterator.kt

@@ -0,0 +1,38 @@
+package io.github.abc15018045126.sora.widget.layout
+
+import java.util.NoSuchElementException
+
+/**
+ * Row iterator.
+ * This iterator is able to return a series of Row objects linearly
+ * Editor uses this to get information of rows and paint them accordingly
+ *
+ * @author Rose
+ */
+interface RowIterator {
+    /**
+     * Return next Row object
+     *
+     * The result should not be stored, because implementing classes will always return the same
+     * object due to performance
+     *
+     * @return Row object contains the information about a row
+     * @throws NoSuchElementException If no more row available
+     */
+    fun next(): Row
+
+    /**
+     * Whether there is more Row object
+     *
+     * @return Whether more row available
+     */
+    fun hasNext(): Boolean
+
+    /**
+     * Reset the position to its original position.
+     *
+     * This can be useful when the elements should be iterated for
+     * several times.
+     */
+    fun reset()
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/layout/ViewMeasureHelper.kt

@@ -0,0 +1,135 @@
+package io.github.abc15018045126.sora.widget.layout
+
+import android.view.View
+import io.github.abc15018045126.sora.graphics.Paint
+import io.github.abc15018045126.sora.graphics.SingleCharacterWidths
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.util.IntPair
+import io.github.abc15018045126.sora.util.MutableInt
+import kotlin.math.ceil
+import kotlin.math.max
+import kotlin.math.min
+
+object ViewMeasureHelper {
+    /**
+     * Get desired view size for the given arguments
+     */
+    @JvmStatic
+    fun getDesiredSize(
+        widthMeasureSpec: Int,
+        heightMeasureSpec: Int,
+        gutterSize: Float,
+        rowHeight: Float,
+        wordwrap: Boolean,
+        tabSize: Int,
+        text: Content,
+        paint: Paint
+    ): Long {
+        var widthMS = widthMeasureSpec
+        var heightMS = heightMeasureSpec
+        val widthMode = View.MeasureSpec.getMode(widthMS)
+        val heightMode = View.MeasureSpec.getMode(heightMS)
+        val maxSize = 0X3FFFFFFF
+        val maxWidth: Int = if (widthMode == View.MeasureSpec.UNSPECIFIED) {
+            maxSize
+        } else {
+            View.MeasureSpec.getSize(widthMS)
+        }
+        val maxHeight: Int = if (heightMode == View.MeasureSpec.UNSPECIFIED) {
+            maxSize
+        } else {
+            View.MeasureSpec.getSize(heightMS)
+        }
+        val measurer = SingleCharacterWidths(tabSize)
+        if (wordwrap) {
+            if (widthMode != View.MeasureSpec.EXACTLY) {
+                val lines = if (heightMode != View.MeasureSpec.EXACTLY) IntArray(text.lineCount) else null
+                val lineMaxSize = MutableInt(0)
+                text.runReadActionsOnLines(0, text.lineCount - 1, Content.ContentLineConsumer { index, line, _ ->
+                    val measured = ceil(
+                        measurer.measureText(
+                            line.backingCharArray,
+                            0,
+                            line.length,
+                            paint
+                        ).toDouble()
+                    ).toInt()
+                    if (measured > lineMaxSize.value) {
+                        lineMaxSize.value = measured
+                    }
+                    if (lines != null) {
+                        lines[index] = measured
+                    }
+                })
+                val width = min(maxWidth.toDouble(), (lineMaxSize.value + gutterSize).toDouble())
+                    .toInt()
+                widthMS = View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY)
+                if (lines != null) {
+                    val rowCount = MutableInt(0)
+                    val availableSize = (width - gutterSize).toInt()
+                    if (availableSize <= 0) {
+                        rowCount.value = text.length
+                    } else {
+                        for (i in lines.indices) {
+                            rowCount.value += max(
+                                1.0,
+                                ceil(1.0 * lines[i] / availableSize)
+                            ).toInt()
+                        }
+                    }
+                    val height = min((rowHeight * rowCount.value).toInt(), maxHeight)
+                    heightMS = View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
+                }
+            } else {
+                if (heightMode != View.MeasureSpec.EXACTLY) {
+                    val rowCount = MutableInt(0)
+                    val availableSize = (maxWidth - gutterSize).toInt()
+                    if (availableSize <= 0) {
+                        rowCount.value = text.length
+                    } else {
+                        text.runReadActionsOnLines(0, text.lineCount - 1, Content.ContentLineConsumer { _, line, _ ->
+                            val measured = ceil(
+                                measurer.measureText(
+                                    line.backingCharArray,
+                                    0,
+                                    line.length,
+                                    paint
+                                ).toDouble()
+                            ).toInt()
+                            rowCount.value += max(
+                                1.0,
+                                ceil(1.0 * measured / availableSize)
+                            ).toInt()
+                        })
+                    }
+                    val height = min((rowHeight * rowCount.value).toInt(), maxHeight)
+                    heightMS = View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
+                }
+            }
+        } else {
+            if (widthMode != View.MeasureSpec.EXACTLY) {
+                val lineMaxSize = MutableInt(0)
+                text.runReadActionsOnLines(0, text.lineCount - 1, Content.ContentLineConsumer { _, line, _ ->
+                    val measured = ceil(
+                        measurer.measureText(
+                            line.backingCharArray,
+                            0,
+                            line.length,
+                            paint
+                        ).toDouble()
+                    ).toInt()
+                    if (measured > lineMaxSize.value) {
+                        lineMaxSize.value = measured
+                    }
+                })
+                val width = min((lineMaxSize.value + gutterSize).toInt(), maxWidth)
+                widthMS = View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY)
+            }
+            if (heightMode != View.MeasureSpec.EXACTLY) {
+                val height = min(maxHeight, (rowHeight * text.lineCount).toInt())
+                heightMS = View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY)
+            }
+        }
+        return IntPair.pack(widthMS, heightMS)
+    }
+}