capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,273 @@
+package io.github.abc15018045126.sora.util
+
+import java.util.ArrayList
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.math.max
+import kotlin.math.min
+
+open class SegmentList<T>(private val segmentCapacity: Int = DEFAULT_SEGMENT_CAPACITY) : AbstractMutableList<T>() {
+
+    companion object {
+        const val DEFAULT_SEGMENT_CAPACITY = 8192
+    }
+
+    private val segments = ArrayList<Segment<T>>()
+    private var _size: Int = 0
+
+    override val size: Int
+        get() = _size
+
+    init {
+        if (segmentCapacity < 4) {
+            throw IllegalArgumentException("block size should be at least 4")
+        }
+    }
+
+    private fun checkInsertIndex(index: Int) {
+        if (index < 0 || index > size) {
+            throw IndexOutOfBoundsException("index $index out of bounds. length = $size")
+        }
+    }
+
+    private fun checkAccessIndex(index: Int) {
+        if (index < 0 || index >= size) {
+            throw IndexOutOfBoundsException("index $index out of bounds. length = $size")
+        }
+    }
+
+    private class FindResult<T>(
+        var segment: Segment<T>? = null,
+        var offset: Int = 0,
+        var blockIndex: Int = 0
+    ) {
+        fun set(segment: Segment<T>, offset: Int, segIndex: Int): FindResult<T> {
+            this.segment = segment
+            this.offset = offset
+            this.blockIndex = segIndex
+            return this
+        }
+    }
+
+    private val result = FindResult<T>()
+
+    private fun makeResult(segment: Segment<T>, offset: Int, segIndex: Int): FindResult<T> {
+        return result.set(segment, offset, segIndex)
+    }
+
+    private fun getSegment(index: Int): FindResult<T> {
+        if (segments.isEmpty()) {
+            segments.add(Segment(segmentCapacity))
+        }
+        var offset = 0
+        var backBlock = segments[segments.size - 1]
+        var backOffset = size - backBlock.size
+        
+        // Iterating from both ends
+        var i = 0
+        var j = segments.size - 1
+        while (i <= j) {
+            var block = segments[i]
+            if ((index >= offset && index < offset + block.size) || i + 1 == segments.size) {
+                return makeResult(block, offset, i)
+            }
+            offset += block.size
+
+            block = backBlock
+            if ((index >= backOffset && index < backOffset + block.size) || (j == segments.size - 1 && index == size)) {
+                return makeResult(block, backOffset, j)
+            }
+            if (j > 0) {
+                backBlock = segments[j - 1]
+                backOffset -= backBlock.size
+            }
+            i++
+            j--
+        }
+        throw IllegalStateException("unreachable")
+    }
+
+    private fun getSegmentMut(index: Int): FindResult<T> {
+        val res = getSegment(index)
+        res.segment = ensureMutable(res.blockIndex)
+        return res
+    }
+
+    private fun ensureMutable(segIdx: Int): Segment<T> {
+        val block = segments[segIdx]
+        val n = block.toMutable()
+        if (block !== n) {
+            segments[segIdx] = n
+            block.release()
+            return n
+        }
+        return block
+    }
+
+    override fun set(index: Int, element: T): T {
+        checkAccessIndex(index)
+        val result = getSegmentMut(index)
+        return result.segment!!.set(index - result.offset, element)
+    }
+
+    override fun add(index: Int, element: T) {
+        checkInsertIndex(index)
+        val result = getSegmentMut(index)
+        result.segment!!.add(index - result.offset, element)
+        _size++
+        adjustElements(result.blockIndex, result.segment!!)
+        if (result.segment!!.size >= segmentCapacity) {
+            val divPoint = segmentCapacity / 2
+            val seg = Segment<T>(segmentCapacity)
+            val sub = result.segment!!.subList(divPoint, result.segment!!.size)
+            seg.addAll(sub)
+            sub.clear()
+            segments.add(result.blockIndex + 1, seg)
+        }
+    }
+
+    override fun removeAt(index: Int): T {
+        checkAccessIndex(index)
+        val result = getSegmentMut(index)
+        val res = result.segment!!.removeAt(index - result.offset)
+        _size--
+        mergeSegment(index - 1, index)
+        mergeSegment(index, index + 1)
+        return res
+    }
+
+    override fun get(index: Int): T {
+        checkAccessIndex(index)
+        val result = getSegment(index)
+        return result.segment!![index - result.offset]
+    }
+
+    override fun removeRange(fromIndex: Int, toIndex: Int) {
+        if (fromIndex > toIndex) throw IndexOutOfBoundsException("start > end")
+        if (fromIndex < 0 || toIndex > size)
+            throw IndexOutOfBoundsException("start = $fromIndex, end = $toIndex, length = $size")
+        if (fromIndex == toIndex) return
+        val res = getSegment(fromIndex)
+        var offset = res.offset
+        var index = res.blockIndex
+        var seg = res.segment!!
+
+        while (toIndex - offset > 0 && index < segments.size) {
+            val segLength = seg.size
+            if (fromIndex <= offset && toIndex >= offset + segLength) {
+                // Remove the segment
+                segments.removeAt(index)
+                seg.release()
+            } else {
+                ensureMutable(index)
+                seg = segments[index]
+                val sub = seg.subList(max(fromIndex - offset, 0), min(toIndex - offset, segLength))
+                sub.clear()
+                index++
+            }
+            offset += segLength
+            if (index < segments.size)
+                seg = segments[index]
+        }
+        mergeSegment(index - 1, index)
+        _size -= toIndex - fromIndex
+    }
+
+    override fun clear() {
+        for (seg in segments) {
+            seg.release()
+        }
+        segments.clear()
+        _size = 0
+    }
+
+    fun shallowCopy(): SegmentList<T> {
+        val list = SegmentList<T>(segmentCapacity)
+        list.segments.clear()
+        for (seg in segments) {
+            seg.retain()
+        }
+        list.segments.addAll(segments)
+        list._size = _size
+        return list
+    }
+
+    private fun mergeSegment(seg1: Int, seg2: Int) {
+        var s1 = seg1
+        var s2 = seg2
+        if (s1 > s2) {
+            val tmp = s1
+            s1 = s2
+            s2 = tmp
+        }
+        if (s1 == s2 || s1 < 0 || s2 >= segments.size) return
+        var pre = segments[s1]
+        val aft = segments[s2]
+        if (pre.size + aft.size <= segmentCapacity * 3 / 4) {
+            ensureMutable(s1)
+            pre = segments[s1]
+            pre.addAll(aft)
+            segments.removeAt(s2)
+            aft.release()
+        }
+    }
+
+    private fun adjustElements(segIdx: Int, mutCur: Segment<T>) {
+        if (segIdx > 0) {
+            val pre = segments[segIdx - 1]
+            if (pre.isMutable() && pre.size <= segmentCapacity * 4 / 5 && mutCur.size > segmentCapacity * 4 / 5) {
+                val sub = mutCur.subList(0, segmentCapacity * 4 / 5 - pre.size)
+                pre.addAll(sub)
+                sub.clear()
+            }
+        }
+    }
+
+    fun forEachCompat(consumer: ConsumerCompat<T>) {
+        for (i in segments.indices) {
+            val seg = segments[i]
+            for (i1 in 0 until seg.size) {
+                consumer.accept(seg[i1])
+            }
+        }
+    }
+
+    fun interface ConsumerCompat<T> {
+        fun accept(obj: T)
+    }
+
+    private class Segment<T> : ArrayList<T>, ShareableData<Segment<T>> {
+
+        constructor() : super()
+        constructor(initialCapacity: Int) : super(initialCapacity)
+
+        private val refCount = AtomicInteger(1)
+
+        override fun retain() {
+            refCount.incrementAndGet()
+        }
+
+        override fun release() {
+            if (refCount.decrementAndGet() < 0) {
+                throw IllegalStateException("illegal release invocation")
+            }
+        }
+
+        override fun isMutable(): Boolean {
+            return refCount.get() == 1
+        }
+
+        override fun toMutable(): Segment<T> {
+            return if (isMutable()) {
+                this
+            } else {
+                copy()
+            }
+        }
+
+        fun copy(): Segment<T> {
+            val res = Segment<T>(this.size)
+            res.addAll(this)
+            return res
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/util/ShareableData.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/util/TemporaryCharBuffer.kt

@@ -0,0 +1,31 @@
+package io.github.abc15018045126.sora.util
+
+object TemporaryCharBuffer {
+
+    private var sTemp: CharArray? = null
+
+    @JvmStatic
+    fun obtain(len: Int): CharArray {
+        var buf: CharArray?
+
+        synchronized(TemporaryCharBuffer::class.java) {
+            buf = sTemp
+            sTemp = null
+        }
+
+        if (buf == null || buf!!.size < len) {
+            buf = CharArray(len)
+        }
+
+        return buf!!
+    }
+
+    @JvmStatic
+    fun recycle(temp: CharArray) {
+        if (temp.size > 1000) return
+
+        synchronized(TemporaryCharBuffer::class.java) {
+            sTemp = temp
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+package io.github.abc15018045126.sora.util
+
+object TemporaryFloatBuffer {
+
+    private val sCache = FloatArrayCache()
+
+    @JvmStatic
+    fun obtain(len: Int): FloatArray {
+        return sCache.obtain(len)
+    }
+
+    @JvmStatic
+    fun recycle(temp: FloatArray) {
+        sCache.recycle(temp)
+    }
+
+    class FloatArrayCache {
+
+        private var temp: FloatArray? = null
+
+        fun obtain(len: Int): FloatArray {
+            var buf: FloatArray?
+
+            synchronized(this) {
+                buf = temp
+                temp = null
+            }
+
+            if (buf == null || buf!!.size < len) {
+                buf = FloatArray(len)
+            }
+
+            return buf!!
+        }
+
+        fun recycle(temp: FloatArray) {
+            if (temp.size > 1000) return
+
+            synchronized(this) {
+                this.temp = temp
+            }
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+package io.github.abc15018045126.sora.util
+
+import android.util.TypedValue
+import android.view.ContextThemeWrapper
+
+object ThemeUtils {
+
+    @JvmStatic
+    fun getColorPrimary(context: ContextThemeWrapper): Int {
+        val typedValue = TypedValue()
+        context.theme.resolveAttribute(android.R.attr.colorPrimary, typedValue, true)
+        return typedValue.data
+    }
+}

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

@@ -0,0 +1,137 @@
+package io.github.abc15018045126.sora.util
+
+import kotlin.math.abs
+import kotlin.math.max
+
+/**
+ * @author Rose
+ * TrieTree to query values quickly
+ */
+class TrieTree<T> {
+
+    @JvmField
+    val root: Node<T> = Node()
+    private var maxLen = 0
+
+    fun put(v: String, token: T) {
+        maxLen = max(v.length, maxLen)
+        addInternal(root, v, 0, v.length, token)
+    }
+
+    fun put(v: CharSequence, off: Int, len: Int, token: T) {
+        maxLen = max(maxLen, len)
+        addInternal(root, v, off, len, token)
+    }
+
+    operator fun get(s: CharSequence, offset: Int, len: Int): T? {
+        if (len > maxLen) {
+            return null
+        }
+        return getInternal(root, s, offset, len)
+    }
+
+    private fun getInternal(node: Node<T>, s: CharSequence, offset: Int, len: Int): T? {
+        if (len == 0) {
+            return node.token
+        }
+        val point = s[offset]
+        val sub = node.map.get(point) ?: return null
+        return getInternal(sub, s, offset + 1, len - 1)
+    }
+
+    private fun addInternal(node: Node<T>, v: CharSequence, i: Int, len: Int, token: T) {
+        val point = v[i]
+        var sub = node.map.get(point)
+        if (sub == null) {
+            sub = Node()
+            node.map.put(point, sub)
+        }
+        if (len == 1) {
+            sub.token = token
+        } else {
+            addInternal(sub, v, i + 1, len - 1, token)
+        }
+    }
+
+    class Node<T> {
+
+        @JvmField
+        val map: HashCharMap<Node<T>> = HashCharMap()
+
+        @JvmField
+        var token: T? = null
+    }
+
+    /**
+     * Hashmap with fixed length
+     *
+     * @author abc15018045126
+     */
+    class HashCharMap<V> {
+
+        private val columns: Array<LinkedPair<V>?> = arrayOfNulls(CAPACITY)
+        private val ends: Array<LinkedPair<V>?> = arrayOfNulls(CAPACITY)
+
+        companion object {
+            private const val CAPACITY = 64
+
+            private fun position(first: Int): Int {
+                return abs(first xor (first shl 6) * if (first and 1 != 0) 3 else 1) % CAPACITY
+            }
+        }
+
+        fun get(first: Char): V? {
+            val position = position(first.code)
+            var pair = columns[position]
+            while (pair != null) {
+                if (pair.first == first) {
+                    return pair.second
+                }
+                pair = pair.next
+            }
+            return null
+        }
+
+        private fun get(first: Char, position: Int): LinkedPair<V>? {
+            var pair = columns[position]
+            while (pair != null) {
+                if (pair.first == first) {
+                    return pair
+                }
+                pair = pair.next
+            }
+            return null
+        }
+
+        fun put(first: Char, second: V) {
+            val position = position(first.code)
+            if (ends[position] == null) {
+                val pair = LinkedPair<V>()
+                ends[position] = pair
+                columns[position] = pair
+                pair.first = first
+                pair.second = second
+                return
+            }
+            var p = get(first, position)
+            if (p == null) {
+                p = LinkedPair()
+                ends[position]!!.next = p
+                ends[position] = p
+            }
+            p.first = first
+            p.second = second
+        }
+    }
+
+    /**
+     * 数据节点
+     *
+     * @author Rose
+     */
+    class LinkedPair<V> {
+        @JvmField var next: LinkedPair<V>? = null
+        @JvmField var first: Char = '\u0000'
+        @JvmField var second: V? = null
+    }
+}

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

@@ -0,0 +1,39 @@
+package io.github.abc15018045126.sora.util
+
+import android.content.Context
+import android.content.res.TypedArray
+import android.os.Build
+import android.util.Log
+import android.view.ViewConfiguration
+
+object ViewUtils {
+
+    private const val LOG_TAG = "ViewUtils"
+
+    const val DEFAULT_SCROLL_FACTOR: Float = 32f
+
+    const val HOVER_TOOLTIP_SHOW_TIMEOUT: Long = 1000
+
+    const val HOVER_TAP_SLOP: Int = 20
+
+    @JvmStatic
+    fun getVerticalScrollFactor(context: Context): Float {
+        var verticalScrollFactor: Float
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val configuration = ViewConfiguration.get(context)
+            verticalScrollFactor = configuration.scaledVerticalScrollFactor
+        } else {
+            var a: TypedArray? = null
+            try {
+                a = context.obtainStyledAttributes(intArrayOf(android.R.attr.listPreferredItemHeight))
+                verticalScrollFactor = a.getDimension(0, DEFAULT_SCROLL_FACTOR)
+            } catch (e: Exception) {
+                Log.e(LOG_TAG, "Failed to get vertical scroll factor, using default.", e)
+                verticalScrollFactor = DEFAULT_SCROLL_FACTOR
+            } finally {
+                a?.recycle()
+            }
+        }
+        return verticalScrollFactor
+    }
+}

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

@@ -0,0 +1,11 @@
+package io.github.abc15018045126.sora.util.regex
+
+data class RegexBackrefGrammar(
+    @JvmField val backrefStartChar: Char,
+    @JvmField val escapeChar: Char
+) {
+    companion object {
+        @JvmField
+        val DEFAULT = RegexBackrefGrammar('$', '\\')
+    }
+}

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

@@ -0,0 +1,27 @@
+package io.github.abc15018045126.sora.util.regex
+
+import java.util.regex.Matcher
+
+object RegexBackrefHelper {
+
+    @JvmStatic
+    fun computeReplacement(matcher: Matcher, grammar: RegexBackrefGrammar, replacementPattern: String): String {
+        val parser = RegexBackrefParser(grammar)
+        val tokens = parser.parse(replacementPattern, matcher.groupCount())
+        return computeReplacement(matcher, tokens)
+    }
+
+    @JvmStatic
+    fun computeReplacement(matcher: Matcher, tokens: List<RegexBackrefToken>): String {
+        val sb = StringBuilder()
+        for (token in tokens) {
+            if (token.isReference) {
+                val text = matcher.group(token.group)
+                sb.append(text ?: "")
+            } else {
+                sb.append(token.text)
+            }
+        }
+        return sb.toString()
+    }
+}

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

@@ -0,0 +1,89 @@
+package io.github.abc15018045126.sora.util.regex
+
+import java.util.ArrayList
+
+class RegexBackrefParser(private val grammar: RegexBackrefGrammar) {
+
+    fun parse(pattern: String, groupCount: Int): List<RegexBackrefToken> {
+        val pat = pattern + '\u0000' // add an extra char to truncate trailing backref
+        val result = ArrayList<RegexBackrefToken>()
+        val escapeChar = grammar.escapeChar
+        val backrefChar = grammar.backrefStartChar
+        var index = 0
+        val len = pat.length
+        // State 0: Text
+        // State 1: Right after escape character
+        // State 2: Require first digit for backref
+        // State 3: Scan reset digits for backref
+        var state = 0
+        var textStart = 0
+        var currentGroup: Long = 0
+        while (index < len) {
+            val ch = pat[index]
+            when (state) {
+                0 -> {
+                    if (ch == escapeChar) {
+                        result.add(RegexBackrefToken(false, pat.substring(textStart, index), -1))
+                        state = 1
+                    } else if (ch == backrefChar) {
+                        result.add(RegexBackrefToken(false, pat.substring(textStart, index), -1))
+                        state = 2
+                    }
+                }
+                1 -> {
+                    if (ch == escapeChar || ch == backrefChar) {
+                        result.add(RegexBackrefToken(false, ch.toString(), -1))
+                    } else {
+                        result.add(RegexBackrefToken(false, pat.substring(index - 1, index + 1), -1))
+                    }
+                    state = 0
+                    textStart = index + 1
+                }
+                2 -> {
+                    if (ch in '0'..'9') {
+                        currentGroup = (ch - '0').toLong()
+                        if (currentGroup <= groupCount) {
+                            state = 3 // scan rest digits
+                        } else {
+                            // not backref, fallback to plain text
+                            textStart = index - 1
+                            index--
+                            state = 0
+                        }
+                    } else {
+                        // not backref, fallback to plain text
+                        textStart = index - 1
+                        index--
+                        state = 0
+                    }
+                }
+                3 -> {
+                    if (ch in '0'..'9') {
+                        val newGroup = currentGroup * 10 + (ch - '0')
+                        if (newGroup <= groupCount) {
+                            currentGroup = newGroup
+                        } else {
+                            result.add(RegexBackrefToken(true, null, currentGroup.toInt()))
+                            textStart = index
+                            state = 0
+                        }
+                    } else {
+                        result.add(RegexBackrefToken(true, null, currentGroup.toInt()))
+                        textStart = index
+                        state = 0
+                    }
+                }
+            }
+
+            index++
+        }
+
+        if (state != 0) {
+            throw IllegalArgumentException("illegal backref expression")
+        } else {
+            result.add(RegexBackrefToken(false, pat.substring(textStart, len - 1), -1))
+        }
+
+        return result
+    }
+}

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

@@ -0,0 +1,16 @@
+package io.github.abc15018045126.sora.util.regex
+
+import java.util.regex.Matcher
+
+class RegexBackrefToken(
+    val isReference: Boolean,
+    val text: String?,
+    val group: Int
+) {
+    fun getReplacementText(matcher: Matcher): String? {
+        if (isReference) {
+            return matcher.group(group)
+        }
+        return text
+    }
+}