capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,139 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import io.github.abc15018045126.sora.lang.styling.color.ConstColor
+import io.github.abc15018045126.sora.lang.styling.color.ResolvableColor
+import io.github.abc15018045126.sora.lang.styling.span.SpanExt
+
+/**
+ * Span describes the appearance and other attributes of text segment
+ *
+ * @author abc15018045126
+ */
+interface Span {
+
+    /**
+     * Set column of this span
+     */
+    var column: Int
+
+    fun shiftColumnBy(deltaColumn: Int) {
+        column += deltaColumn
+    }
+
+    /**
+     * Set style of the span
+     *
+     * @see TextStyle
+     */
+    var style: Long
+
+    /**
+     * Get foreground color ID from style
+     */
+    val foregroundColorId: Int
+        get() = TextStyle.getForegroundColorId(style)
+
+    /**
+     * Get background color ID from style
+     */
+    val backgroundColorId: Int
+        get() = TextStyle.getBackgroundColorId(style)
+
+    /**
+     * Get bits of other text styles that affects measuring
+     */
+    val styleBits: Long
+        get() = TextStyle.getStyleBits(style)
+
+    /**
+     * Set underline color of span. `0` for no underline.
+     * **This is not color ID**
+     */
+    fun setUnderlineColor(color: Int) {
+        if (color == 0) {
+            underlineColor = null
+            return
+        }
+        underlineColor = ConstColor(color)
+    }
+
+    /**
+     * Set underline color with a [ResolvableColor] to resolve colors when the span is rendered.
+     * Null for no underline.
+     */
+    var underlineColor: ResolvableColor?
+
+    /**
+     * Extra data for language internal use
+     */
+    var extra: Any?
+
+    /**
+     * Set extended attribute of this span. The type of `ext` is checked whether it is compatible
+     * with the given `extType`.
+     *
+     * @param extType Type of extension, from [io.github.abc15018045126.sora.lang.styling.span.SpanExtAttrs]
+     * @param ext     The data to set. Use null to unset.
+     */
+    fun setSpanExt(extType: Int, ext: SpanExt?)
+
+    /**
+     * Check if certain extended attribute is set
+     */
+    fun hasSpanExt(extType: Int): Boolean
+
+    /**
+     * Get extended attribute of given type. If it is unset, null is returned.
+     */
+    fun <T> getSpanExt(extType: Int): T?
+
+    /**
+     * Remove all [SpanExt]s
+     */
+    fun removeAllSpanExt()
+
+    /**
+     * Reset all properties of this span, including column, style and ext.
+     */
+    fun reset()
+
+    /**
+     * Create a new span with the same attributes. The new span can be safely modified with affecting
+     * the original span.
+     *
+     * Note that [SpanExt] objects are **shared**s by the old span and new span instance.
+     *
+     * @return new span with the same attribute
+     */
+    fun copy(): Span
+
+    /**
+     * Recycle this span to pool for later use. After calling this method, you should not
+     * make any access to this [Span] instance. And all attributes of this span are reset.
+     *
+     * Note that no matter whether the span is added to pool, it will be reset.
+     *
+     * @return if the span is actually added to the pool.
+     */
+    fun recycle(): Boolean
+
+    companion object {
+        /**
+         * Get an available [Span] object from either cache or new instance.
+         * The result object will be initialized with the given arguments.
+         */
+        @JvmStatic
+        fun obtain(column: Int, style: Long): Span {
+            return SpanFactory.obtain(column, style)
+        }
+
+        /**
+         * Recycle all spans in the given collection
+         */
+        @JvmStatic
+        fun recycleAll(spans: Collection<Span>) {
+            SpanFactory.recycleAll(spans)
+        }
+    }
+
+}

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

@@ -0,0 +1,41 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import io.github.abc15018045126.sora.lang.styling.span.internal.NoExtSpanImpl
+import io.github.abc15018045126.sora.lang.styling.span.internal.SpanImpl
+
+/**
+ * Factory for [Span]
+ */
+object SpanFactory {
+
+    /**
+     * Get an available [Span] object from either cache or new instance.
+     * The result object will be initialized with the given arguments.
+     */
+    @JvmStatic
+    fun obtain(column: Int, style: Long): Span {
+        return SpanImpl.obtain(column, style)
+    }
+
+    /**
+     * Get an available [Span] object from either cache or new instance.
+     *
+     * Note that the span can not have additional fields beside
+     */
+    @JvmStatic
+    fun obtainNoExt(column: Int, style: Long): Span {
+        return NoExtSpanImpl.obtain(column, style)
+    }
+
+    /**
+     * Recycle all spans in the given collection
+     */
+    @JvmStatic
+    fun recycleAll(spans: Collection<Span>) {
+        for (span in spans) {
+            if (!span.recycle()) {
+                return
+            }
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/lang/styling/SpanPool.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/Spans.kt

@@ -0,0 +1,104 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+/**
+ * Spans object saves spans in editor.
+ */
+interface Spans {
+
+    /**
+     * Adjust spans on insert.
+     * Must be implemented.
+     */
+    fun adjustOnInsert(start: CharPosition, end: CharPosition)
+
+    /**
+     * Adjust spans on delete.
+     * Must be implemented.
+     */
+    fun adjustOnDelete(start: CharPosition, end: CharPosition)
+
+    /**
+     * Read spans.
+     * Must be implemented.
+     */
+    fun read(): Reader
+
+    /**
+     * Check whether the class supports [modify]
+     */
+    fun supportsModify(): Boolean
+
+    /**
+     * Modify the content.
+     *
+     * Optional to implement.
+     */
+    fun modify(): Modifier
+
+    /**
+     * Get line count of the spans
+     */
+    fun getLineCount(): Int
+
+    /**
+     * Reader reads the spans in a [Spans] object.
+     */
+    interface Reader {
+
+        /**
+         * Start reading the spans on the given line.
+         * You may prepare some data here if the actual spans are not stored by [Span] objects.
+         *
+         * line may be -1 to release the reader.
+         */
+        fun moveToLine(line: Int)
+
+        /**
+         * Get span count on current line
+         */
+        fun getSpanCount(): Int
+
+        /**
+         * Get span at position [index].
+         * The result object is read-only. Callers should not modify this object.
+         */
+        fun getSpanAt(index: Int): Span
+
+        /**
+         * Get all spans on the given line. This ignores the line argument set by [Reader.moveToLine]
+         * The list contains at least 1 span. And the result list is unmodifiable.
+         */
+        fun getSpansOnLine(line: Int): List<Span>
+    }
+
+    /**
+     * Modifier updates the spans in a [Spans] object.
+     */
+    interface Modifier {
+
+        /**
+         * Set the line's spans to the new ones. The given [spans] list should not be stored,
+         * but the content of it can be copied.
+         *
+         * If the line index exceeds the current capacity, implementation of this should expand the capacity
+         * without throwing an exception. Set spans of the filled lines to color [EditorColorScheme.TEXT_NORMAL]
+         * or extends previous styles.
+         */
+        fun setSpansOnLine(line: Int, spans: List<out Span>)
+
+        /**
+         * Add a line at the given position.
+         * The given [spans] list should not be stored,
+         * but the content of it can be copied.
+         */
+        fun addLineAt(line: Int, spans: List<out Span>)
+
+        /**
+         * Remove a line
+         */
+        fun deleteLineAt(line: Int)
+    }
+}

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

@@ -0,0 +1,219 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import io.github.abc15018045126.sora.lang.styling.line.LineAnchorStyle
+import io.github.abc15018045126.sora.lang.styling.line.LineStyles
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.util.MutableInt
+import java.util.*
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * This class stores styles of text and other decorations in editor related to code.
+ *
+ * Note that this does not save any information related to languages. No extra space is provided
+ * for communication between analyzers and auto-completion. You should manage it by yourself.
+ *
+ * If you are going to extend this class, please read the source code carefully in advance
+ */
+@Suppress("unused")
+open class Styles @JvmOverloads constructor(
+    @JvmField
+    var spans: Spans? = null,
+    initCodeBlocks: Boolean = true
+) {
+
+    @JvmField
+    var lineStyles: MutableList<LineStyles>? = null
+    @JvmField
+    var styleTypeCount: MutableMap<Class<*>, MutableInt>? = null
+
+    @JvmField
+    var blocks: MutableList<CodeBlock>? = null
+
+    /**
+     * Internal, automatically generated
+     */
+    @JvmField
+    var blocksByStart: MutableList<CodeBlock>? = null
+
+    @JvmField
+    var suppressSwitch = Int.MAX_VALUE
+
+    @JvmField
+    var isIndentCountMode = false
+
+    init {
+        if (initCodeBlocks) {
+            blocks = ArrayList(128)
+        }
+    }
+
+    /**
+     * Get analyzed spans
+     */
+    fun getSpans(): Spans? = spans
+
+    /**
+     * Returns suppress switch
+     *
+     * @return suppress switch
+     * @see Styles.suppressSwitch
+     */
+    fun getSuppressSwitch(): Int = suppressSwitch
+
+    /**
+     * Set suppress switch for editor
+     */
+    fun setSuppressSwitch(suppressSwitch: Int) {
+        this.suppressSwitch = suppressSwitch
+    }
+
+    fun isIndentCountMode(): Boolean = isIndentCountMode
+
+    fun setIndentCountMode(indentCountMode: Boolean) {
+        this.isIndentCountMode = indentCountMode
+    }
+
+    /**
+     * Add a new code block info
+     *
+     * @param block Info of code block
+     */
+    fun addCodeBlock(block: CodeBlock) {
+        Objects.requireNonNull(block, "CodeBlock must not be null")
+        blocks?.add(block)
+    }
+
+    /**
+     * Adjust styles on insert.
+     */
+    fun adjustOnInsert(start: CharPosition, end: CharPosition) {
+        spans?.adjustOnInsert(start, end)
+        val delta = end.line - start.line
+        if (delta == 0) {
+            return
+        }
+        val currentBlocks = blocks
+        if (currentBlocks != null) {
+            BlocksUpdater.update(currentBlocks, start.line, delta)
+        }
+        val currentLineStyles = lineStyles
+        if (currentLineStyles != null) {
+            for (styles in currentLineStyles) {
+                if (styles.line > start.line) {
+                    styles.line = styles.line + delta
+                    styles.updateElements()
+                }
+            }
+        }
+    }
+
+    /**
+     * Adjust styles on delete.
+     */
+    fun adjustOnDelete(start: CharPosition, end: CharPosition) {
+        spans?.adjustOnDelete(start, end)
+        val delta = start.line - end.line
+        if (delta == 0) {
+            return
+        }
+        val currentBlocks = blocks
+        if (currentBlocks != null) {
+            BlocksUpdater.update(currentBlocks, start.line, delta)
+        }
+        val currentLineStyles = lineStyles
+        if (currentLineStyles != null) {
+            val itr = currentLineStyles.iterator()
+            while (itr.hasNext()) {
+                val styles = itr.next()
+                val line = styles.line
+                if (line > end.line) {
+                    styles.line = line + delta
+                    styles.updateElements()
+                } else if (line > start.line /* line <= end.line */) {
+                    itr.remove()
+                }
+            }
+        }
+    }
+
+    fun addLineStyle(style: LineAnchorStyle) {
+        if (lineStyles == null) {
+            lineStyles = ArrayList()
+            styleTypeCount = ConcurrentHashMap()
+        }
+        val type = style.javaClass
+        val currentLineStyles = lineStyles!!
+        for (lineStyle in currentLineStyles) {
+            if (lineStyle.line == style.line) {
+                styleCountUpdate(type, lineStyle.addStyle(style))
+                return
+            }
+        }
+        val lineStyle = LineStyles(style.line)
+        currentLineStyles.add(lineStyle)
+        styleCountUpdate(type, lineStyle.addStyle(style))
+    }
+
+    private fun styleCountUpdate(type: Class<*>, delta: Int) {
+        val countMap = styleTypeCount ?: return
+        var res = countMap[type]
+        if (res == null) {
+            res = MutableInt(0)
+            countMap[type] = res
+        }
+        res.value += delta
+    }
+
+    /**
+     * Remove the style of given kind from line
+     */
+    fun eraseLineStyle(line: Int, type: Class<out LineAnchorStyle>) {
+        val currentLineStyles = lineStyles ?: return
+        for (lineStyle in currentLineStyles) {
+            if (lineStyle.line == line) {
+                styleCountUpdate(type, -lineStyle.eraseStyle(type))
+                break
+            }
+        }
+    }
+
+    /**
+     * Remove all line styles
+     */
+    fun eraseAllLineStyles() {
+        val currentLineStyles = lineStyles ?: return
+        currentLineStyles.clear()
+        styleTypeCount?.clear()
+    }
+
+    /**
+     * Do some extra work before finally sending the result to editor.
+     */
+    fun finishBuilding() {
+        val currentBlocks = blocks
+        if (currentBlocks != null) {
+            var pre = -1
+            var sort = false
+            for (i in 0 until currentBlocks.size - 1) {
+                val cur = currentBlocks[i + 1].endLine
+                if (pre > cur) {
+                    sort = true
+                    break
+                }
+                pre = cur
+            }
+            if (sort) {
+                Collections.sort(currentBlocks, CodeBlock.COMPARATOR_END)
+            }
+            blocksByStart = ArrayList(currentBlocks)
+            Collections.sort(blocksByStart, CodeBlock.COMPARATOR_START)
+        } else {
+            blocksByStart = null
+        }
+        lineStyles?.let {
+            Collections.sort(it)
+        }
+    }
+
+}

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

@@ -0,0 +1,82 @@
+package io.github.abc15018045126.sora.lang.styling
+
+import android.util.Log
+import io.github.abc15018045126.sora.text.CharPosition
+
+object StylesUtils {
+
+    private const val LOG_TAG = "StylesUtils"
+
+    /**
+     * Check given position's span.
+     * If [io.github.abc15018045126.sora.lang.styling.TextStyle.NO_COMPLETION_BIT] is set, true is returned.
+     */
+    @JvmStatic
+    fun checkNoCompletion(styles: Styles?, pos: CharPosition): Boolean {
+        val span = getSpanForPosition(styles, pos)
+        return span == null || TextStyle.isNoCompletion(span.style)
+    }
+
+    /**
+     * Get [Span] for the given position.
+     */
+    @JvmStatic
+    fun getSpanForPosition(styles: Styles?, pos: CharPosition): Span? {
+        return getSpanForPositionImpl(styles, pos, 0)
+    }
+
+    /**
+     * Get following [Span] for the given position.
+     */
+    @JvmStatic
+    fun getFollowingSpanForPosition(styles: Styles?, pos: CharPosition): Span? {
+        return getSpanForPositionImpl(styles, pos, 1)
+    }
+
+    private fun getSpanForPositionImpl(styles: Styles?, pos: CharPosition, spanIndexOffset: Int): Span? {
+        val line = pos.line
+        val column = pos.column
+        // Do not make completion without styles. The language may be empty or busy analyzing spans
+        if (styles == null) {
+            return null
+        }
+        val spans = styles.spans ?: return null
+        var ex: Exception? = null
+        val reader = spans.read()
+        try {
+            reader.moveToLine(line)
+            var index = reader.getSpanCount() - 1
+            if (index == -1) {
+                return null
+            }
+            for (i in 0 until reader.getSpanCount()) {
+                if (reader.getSpanAt(i).column > column) {
+                    index = i - 1
+                    break
+                }
+            }
+            index += spanIndexOffset
+            if (index < 0 || index >= reader.getSpanCount()) {
+                return null
+            }
+            return reader.getSpanAt(index)
+        } catch (e: Exception) {
+            // Unexpected exception. Maybe there is something wrong in language implementation
+            ex = e
+            return null
+        } finally {
+            try {
+                reader.moveToLine(-1)
+            } catch (e1: Exception) {
+                if (ex != null) {
+                    ex.addSuppressed(e1)
+                } else {
+                    Log.e(LOG_TAG, "failed to close $reader", e1)
+                }
+            }
+            if (ex != null) {
+                Log.e(LOG_TAG, "failed to get spans from $reader at $pos", ex)
+            }
+        }
+    }
+}