capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/{widget/component/EditorBuiltinComponent.java → text/ContentExtensions.kt}

@@ -1,4 +1,4 @@
-/*
+/*******************************************************************************
  *    sora-editor - the awesome code editor for Android
  *    https://github.com/abc15018045126/sora-editor
  *    Copyright (C) 2020-2024  abc15018045126
@@ -18,31 +18,21 @@
  *     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 io.github.abc15018045126.sora.widget.component;
+ ******************************************************************************/
+
+package io.github.abc15018045126.sora.text
 
 /**
- * Builtin editor component.
- *
- * @author abc15018045126
- * @see EditorAutoCompletion
- * @see EditorTextActionWindow
- * @see Magnifier
- * @see EditorDiagnosticTooltipWindow
+ * A delegate method.
+ * Notify the UndoManager to batch edit.
+ * @see Content.beginBatchEdit
+ * @see Content.endBatchEdit
  */
-public interface EditorBuiltinComponent {
-
-    /**
-     * Check whether this component is enabled
-     */
-    boolean isEnabled();
-
-    /**
-     * Enable/disable this builtin component
-     */
-    void setEnabled(boolean enabled);
-
+fun Content.batchEdit(block: (Content) -> Unit): Content {
+    this.beginBatchEdit()
+    block(this)
+    this.endBatchEdit()
+    return this
 }
-

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

@@ -0,0 +1,149 @@
+package io.github.abc15018045126.sora.text
+
+import java.io.*
+import java.nio.charset.Charset
+
+/**
+ * Helper class for creating or saving [Content] objects, with minimal extra memory usage when
+ * processing.
+ *
+ * @author abc15018045126
+ */
+object ContentIO {
+
+    private const val BUFFER_SIZE = 16384
+
+    /**
+     * Create a [Content] from stream.
+     * The stream will get closed if the operation is successfully done.
+     * @param stream Source stream
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun createFrom(stream: InputStream): Content {
+        return createFrom(stream, Charset.defaultCharset())
+    }
+
+    /**
+     * Create a [Content] from stream.
+     * The stream will get closed if the operation is successfully done.
+     * @param stream Source stream
+     * @param charset Charset for decoding the content
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun createFrom(stream: InputStream, charset: Charset): Content {
+        return createFrom(InputStreamReader(stream, charset))
+    }
+
+    /**
+     * Create a [Content] from reader.
+     *
+     * The reader will get closed if the operation is successfully done.
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun createFrom(reader: Reader): Content {
+        val content = Content()
+        content.isUndoEnabled = false
+        val buffer = CharArray(BUFFER_SIZE)
+        val wrapper = CharArrayWrapper(buffer, 0)
+        var count: Int
+        while (reader.read(buffer).also { count = it } != -1) {
+            if (count > 0) {
+                if (buffer[count - 1] == '\r') {
+                    val peek = reader.read()
+                    if (peek == '\n'.toInt()) {
+                        wrapper.setDataCount(count - 1)
+                        var line = content.lineCount - 1
+                        content.insert(line, content.getColumnCount(line), wrapper)
+                        line = content.lineCount - 1
+                        content.insert(line, content.getColumnCount(line), "\r\n")
+                        continue
+                    } else if (peek != -1) {
+                        wrapper.setDataCount(count)
+                        var line = content.lineCount - 1
+                        content.insert(line, content.getColumnCount(line), wrapper)
+                        line = content.lineCount - 1
+                        content.insert(line, content.getColumnCount(line), peek.toChar().toString())
+                        continue
+                    }
+                }
+                wrapper.setDataCount(count)
+                val line = content.lineCount - 1
+                content.insert(line, content.getColumnCount(line), wrapper)
+            }
+        }
+        reader.close()
+        content.isUndoEnabled = true
+        return content
+    }
+
+    /**
+     * Write the text to the given stream with default charset. Close the stream if [closeOnSucceed] is true.
+     *
+     * @param text Text to be written
+     * @param stream Output stream
+     * @param closeOnSucceed If true, the stream will be closed when operation is successfully
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun writeTo(text: Content, stream: OutputStream, closeOnSucceed: Boolean) {
+        writeTo(text, stream, Charset.defaultCharset(), closeOnSucceed)
+    }
+
+    /**
+     * Write the text to the given stream with given charset. Close the stream if [closeOnSucceed] is true.
+     *
+     * @param text Text to be written
+     * @param stream Output stream
+     * @param charset Charset of output bytes
+     * @param closeOnSucceed If true, the stream will be closed when operation is successfully
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun writeTo(text: Content, stream: OutputStream, charset: Charset, closeOnSucceed: Boolean) {
+        writeTo(text, OutputStreamWriter(stream, charset), closeOnSucceed)
+    }
+
+    /**
+     * Write the text to the given writer. Close the writer if [closeOnSucceed] is true.
+     *
+     * If you use [BufferedWriter], make sure you set an appropriate buffer size. We recommend using the default size (8192) or larger.
+     *
+     * @param text Text to be written
+     * @param writer Output writer
+     * @param closeOnSucceed If true, the stream will be closed when operation is successfully
+     */
+    @JvmStatic
+    @Throws(IOException::class)
+    fun writeTo(text: Content, writer: Writer, closeOnSucceed: Boolean) {
+        // Use buffered writer to avoid frequently IO when there are a lot of short lines
+        val buffered = if (writer is BufferedWriter) writer else BufferedWriter(writer, BUFFER_SIZE)
+        try {
+            text.runReadActionsOnLines(0, text.lineCount - 1, Content.ContentLineConsumer2 { _, line, _ ->
+                try {
+                    // Write line content
+                    buffered.write(line.backingCharArray, 0, line.length)
+                    // Write line feed (the last line has empty line feed)
+                    buffered.write(line.lineSeparatorSafe.chars)
+                } catch (e: IOException) {
+                    // To be handled by outer code
+                    throw RuntimeException(e)
+                }
+            })
+        } catch (e: RuntimeException) {
+            val cause = e.cause
+            if (cause is IOException) {
+                throw cause
+            } else {
+                throw e
+            }
+        }
+        buffered.flush()
+        if (closeOnSucceed) {
+            buffered.close()
+        }
+    }
+
+}

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

@@ -0,0 +1,252 @@
+package io.github.abc15018045126.sora.text
+
+import android.text.GetChars
+import io.github.abc15018045126.sora.annotations.UnsupportedUserUsage
+import io.github.abc15018045126.sora.text.bidi.BidiRequirementChecker
+import io.github.abc15018045126.sora.text.bidi.TextBidi
+import io.github.abc15018045126.sora.util.ShareableData
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * [ContentLine] represents a single line of text in the editor.
+ * It provides efficient text manipulation methods and supports RTL/Bidi content.
+ */
+class ContentLine : CharSequence, GetChars, BidiRequirementChecker, ShareableData<ContentLine> {
+
+    internal var value: CharArray
+    override var length: Int = 0
+        internal set
+
+    internal var rtlAffectingCount: Int = 0
+    private var _lineSeparator: LineSeparator? = null
+    var lineSeparator: LineSeparator?
+        get() = _lineSeparator
+        set(value) {
+            _lineSeparator = value
+        }
+    
+    val lineSeparatorSafe: LineSeparator
+        get() = _lineSeparator ?: LineSeparator.NONE
+
+    private var refCount: AtomicInteger? = null
+
+    constructor() : this(true)
+
+    constructor(text: CharSequence?) : this(true) {
+        insert(0, text)
+    }
+
+    constructor(src: ContentLine) : this(src.length + 16) {
+        length = src.length
+        rtlAffectingCount = src.rtlAffectingCount
+        _lineSeparator = src.lineSeparator
+        System.arraycopy(src.value, 0, value, 0, length)
+    }
+
+    constructor(size: Int) {
+        length = 0
+        value = CharArray(size)
+    }
+
+    private constructor(initialize: Boolean) {
+        if (initialize) {
+            length = 0
+            value = CharArray(32)
+        } else {
+            // Used by subSequence or copy to delay initialization of value or use provided array
+            value = CharArray(0)
+        }
+    }
+
+    private fun checkIndex(index: Int) {
+        if (index < 0 || index > length) {
+            throw StringIndexOutOfBoundsException("index = $index, length = $length")
+        }
+    }
+
+    private fun ensureCapacity(capacity: Int) {
+        if (value.size < capacity) {
+            val newLength = if (value.size * 2 < capacity) capacity + 2 else value.size * 2
+            val newValue = CharArray(newLength)
+            System.arraycopy(value, 0, newValue, 0, length)
+            value = newValue
+        }
+    }
+
+    fun insert(dstOffset: Int, s: CharSequence?): ContentLine {
+        val str = s ?: "null"
+        return this.insert(dstOffset, str, 0, str.length)
+    }
+
+    fun insert(dstOffset: Int, s: CharSequence?, start: Int, end: Int): ContentLine {
+        val str = s ?: "null"
+        if (dstOffset < 0 || dstOffset > this.length) {
+            throw IndexOutOfBoundsException("dstOffset $dstOffset")
+        }
+        if (start < 0 || end < 0 || start > end || end > str.length) {
+            throw IndexOutOfBoundsException("start $start, end $end, s.length() ${str.length}")
+        }
+        val len = end - start
+        ensureCapacity(length + len)
+        System.arraycopy(value, dstOffset, value, dstOffset + len, length - dstOffset)
+        var currentOffset = dstOffset
+        for (i in start until end) {
+            val ch = str[i]
+            value[currentOffset++] = ch
+            if (TextBidi.couldAffectRtl(ch)) {
+                rtlAffectingCount++
+            }
+        }
+        length += len
+        return this
+    }
+
+    fun insert(offset: Int, c: Char): ContentLine {
+        ensureCapacity(length + 1)
+        if (offset < length) {
+            System.arraycopy(value, offset, value, offset + 1, length - offset)
+        }
+        if (TextBidi.couldAffectRtl(c)) {
+            rtlAffectingCount++
+        }
+        value[offset] = c
+        length += 1
+        return this
+    }
+
+    fun delete(start: Int, end: Int): ContentLine {
+        var e = end
+        if (start < 0) {
+            throw StringIndexOutOfBoundsException(start)
+        }
+        if (e > length) {
+            e = length
+        }
+        if (start > e) {
+            throw StringIndexOutOfBoundsException()
+        }
+        val len = e - start
+        if (len > 0) {
+            for (i in start until e) {
+                if (TextBidi.couldAffectRtl(value[i])) {
+                    rtlAffectingCount--
+                }
+            }
+            System.arraycopy(value, start + len, value, start, length - e)
+            length -= len
+        }
+        return this
+    }
+
+    override fun mayNeedBidi(): Boolean {
+        return rtlAffectingCount > 0
+    }
+
+    fun append(text: CharSequence): ContentLine {
+        return this.insert(length, text)
+    }
+
+    @UnsupportedUserUsage
+    override fun get(index: Int): Char {
+        if (index >= length) {
+            val sep = lineSeparatorSafe
+            return if (sep.length > 0) {
+                sep.content[index - length]
+            } else {
+                '\n'
+            }
+        }
+        return value[index]
+    }
+
+    override fun subSequence(startIndex: Int, endIndex: Int): ContentLine {
+        checkIndex(startIndex)
+        checkIndex(endIndex)
+        if (endIndex < startIndex) {
+            throw StringIndexOutOfBoundsException("start is greater than end")
+        }
+        val subLen = endIndex - startIndex
+        val newValue = CharArray(subLen + 16)
+        System.arraycopy(value, startIndex, newValue, 0, subLen)
+        val res = ContentLine(false)
+        res.value = newValue
+        res.length = subLen
+
+        if (rtlAffectingCount > 0) {
+            for (i in 0 until res.length) {
+                if (TextBidi.couldAffectRtl(newValue[i])) {
+                    res.rtlAffectingCount++
+                }
+            }
+        }
+        return res
+    }
+
+    fun appendTo(sb: StringBuilder) {
+        sb.append(value, 0, length)
+    }
+
+    override fun toString(): String {
+        return String(value, 0, length)
+    }
+
+    fun toStringWithNewline(): String {
+        if (value.size == length) {
+            ensureCapacity(length + 1)
+        }
+        value[length] = '\n'
+        return String(value, 0, length + 1)
+    }
+
+    val backingCharArray: CharArray
+        get() = value
+
+    override fun getChars(srcBegin: Int, srcEnd: Int, dst: CharArray, dstBegin: Int) {
+        if (srcBegin < 0) {
+            throw StringIndexOutOfBoundsException(srcBegin)
+        }
+        if (srcEnd < 0 || srcEnd > length) {
+            throw StringIndexOutOfBoundsException(srcEnd)
+        }
+        if (srcBegin > srcEnd) {
+            throw StringIndexOutOfBoundsException("srcBegin > srcEnd")
+        }
+        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin)
+    }
+
+    fun copy(): ContentLine {
+        val clone = ContentLine(false)
+        clone.length = length
+        clone.value = CharArray(value.size)
+        System.arraycopy(value, 0, clone.value, 0, length)
+        clone.rtlAffectingCount = rtlAffectingCount
+        clone._lineSeparator = _lineSeparator
+        return clone
+    }
+
+    override fun retain() {
+        if (refCount == null) {
+            refCount = AtomicInteger(2)
+            return
+        }
+        refCount!!.incrementAndGet()
+    }
+
+    override fun release() {
+        if (refCount == null) {
+            return
+        }
+        val count = refCount!!.decrementAndGet()
+        if (count < 0) {
+            throw IllegalStateException("illegal operation. There is no active owner")
+        }
+    }
+
+    override fun isMutable(): Boolean {
+        return refCount == null || refCount!!.get() == 1
+    }
+
+    override fun toMutable(): ContentLine {
+        return if (isMutable()) this else copy()
+    }
+}

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

@@ -0,0 +1,67 @@
+package io.github.abc15018045126.sora.text
+
+import io.github.abc15018045126.sora.annotations.UnsupportedUserUsage
+
+/**
+ * This is the listener for content.
+ * You will receive calls when the Content object is going to change or changed.
+ *
+ * @author abc15018045126
+ */
+interface ContentListener {
+
+    /**
+     * This is to notify you that you will receive [ContentListener.afterDelete]
+     * and [ContentListener.afterInsert] calls.
+     * These two calls are an action of replacement.
+     * ** You are not expected to make changes to this Content object at this method. **
+     *
+     * @param content The target Content object being replaced text
+     */
+    fun beforeReplace(content: Content)
+
+    /**
+     * This is to notify you that the given Content object has inserted text with the given position and text
+     *
+     * @param content         The Content which has inserted the given text
+     * @param startLine       The insertion position line
+     * @param startColumn     The insertion position column on the line
+     * @param endLine         The line position of the last character in inserted content
+     * @param endColumn       The column position after the last character in inserted content
+     * @param insertedContent The content inserted
+     */
+    fun afterInsert(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        insertedContent: CharSequence
+    )
+
+    /**
+     * This is to notify you that the Content object has deleted the text with the given position.
+     *
+     * @param content        The Content which has deleted text
+     * @param startLine      The start line of deleted text
+     * @param startColumn    The start column of deleted text
+     * @param endLine        The end line of deleted text
+     * @param endColumn      The end column of deleted text(But this character not deleted)
+     * @param deletedContent The text deleted.Generated by Content object.
+     */
+    fun afterDelete(
+        content: Content,
+        startLine: Int,
+        startColumn: Int,
+        endLine: Int,
+        endColumn: Int,
+        deletedContent: CharSequence
+    )
+
+    /**
+     * Internal API
+     */
+    @UnsupportedUserUsage
+    fun beforeModification(content: Content) {
+    }
+}

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

@@ -0,0 +1,177 @@
+package io.github.abc15018045126.sora.text
+
+import java.io.IOException
+import java.io.Reader
+import kotlin.math.max
+import kotlin.math.min
+
+/**
+ * Reference of a content due to be accessed in read-only mode.
+ * Access can be validated during accesses.
+ * [io.github.abc15018045126.sora.text.TextReference.ValidateFailedException] may be thrown if the check is failed.
+ * The result of methods may be dirty when the content is modified.
+ *
+ * @author abc15018045126
+ */
+class ContentReference(private val content: Content) : TextReference(content) {
+
+    override fun get(index: Int): Char {
+        validateAccess()
+        return content[index]
+    }
+
+    fun charAt(line: Int, column: Int): Char {
+        validateAccess()
+        return content.getLine(line)[column]
+    }
+
+    fun getCharIndex(line: Int, column: Int): Int {
+        validateAccess()
+        return content.getCharIndex(line, column)
+    }
+
+    fun getCharPosition(line: Int, column: Int): CharPosition {
+        validateAccess()
+        return content.getIndexer().getCharPosition(line, column)
+    }
+
+    fun getCharPosition(index: Int): CharPosition {
+        validateAccess()
+        return content.getIndexer().getCharPosition(index)
+    }
+
+    /**
+     * @see Content.getLineCount
+     */
+    val lineCount: Int
+        get() {
+            validateAccess()
+            return content.lineCount
+        }
+
+    /**
+     * @see Content.getColumnCount
+     */
+    fun getColumnCount(line: Int): Int {
+        validateAccess()
+        return content.getColumnCount(line)
+    }
+
+    /**
+     * @see Content.getLineSeparatorUnsafe
+     */
+    fun getLineSeparator(line: Int): String {
+        validateAccess()
+        return content.getLineSeparatorUnsafe(line).content
+    }
+
+    /**
+     * @see Content.getLineString
+     */
+    fun getLine(line: Int): String {
+        validateAccess()
+        return content.getLineString(line)
+    }
+
+    /**
+     * @see Content.getLineChars
+     */
+    fun getLineChars(line: Int, dest: CharArray) {
+        validateAccess()
+        content.getLineChars(line, dest)
+    }
+
+    /**
+     * @see Content.getLine
+     */
+    fun appendLineTo(sb: StringBuilder, line: Int) {
+        validateAccess()
+        content.getLine(line).appendTo(sb)
+    }
+
+    /**
+     * @see Content.getDocumentVersion
+     */
+    val documentVersionValue: Long
+        get() {
+            validateAccess()
+            return content.documentVersion.get()
+        }
+
+    /**
+     * Create a reader to read the text
+     */
+    fun createReader(): Reader {
+        return RefReader()
+    }
+
+    override val reference: Content
+        get() = super.reference as Content
+
+    override fun setValidator(validator: Validator?): ContentReference {
+        super.setValidator(validator)
+        return this
+    }
+
+    private inner class RefReader : Reader() {
+
+        private var markedLine = 0
+        private var markedColumn = 0
+        private var line = 0
+        private var column = 0
+
+        override fun read(chars: CharArray, offset: Int, length: Int): Int {
+            if (chars.size < offset + length) {
+                throw IllegalArgumentException("size not enough")
+            }
+            var read = 0
+            while (read < length && line < lineCount) {
+                val targetLine = content.getLine(line)
+                val lineSep = targetLine.lineSeparatorSafe
+                val separatorLength = lineSep.length
+                val columnCount = targetLine.length
+                var toRead = min(columnCount - column, length - read)
+                toRead = max(0, toRead)
+                if (toRead > 0) {
+                    content.getRegionOnLine(line, column, column + toRead, chars, offset + read)
+                }
+                column += toRead
+                read += toRead
+                while (read < length && columnCount <= column && column < columnCount + separatorLength) {
+                    chars[offset + read] = lineSep.content[column - columnCount]
+                    read++
+                    column++
+                }
+                if (column >= columnCount + separatorLength) {
+                    line++
+                    column = 0
+                }
+            }
+            if (read == 0) {
+                return -1
+            }
+            return read
+        }
+
+        override fun close() {
+            line = Int.MAX_VALUE
+            column = Int.MAX_VALUE
+        }
+
+        override fun markSupported(): Boolean {
+            return true
+        }
+
+        @Throws(IOException::class)
+        override fun mark(readAheadLimit: Int) {
+            markedLine = line
+            markedColumn = column
+        }
+
+        @Throws(IOException::class)
+        override fun reset() {
+            line = markedLine
+            column = markedColumn
+        }
+    }
+}