capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,314 @@
+package io.github.abc15018045126.sora.util
+
+import java.util.ArrayList
+import java.util.Collections
+import java.util.concurrent.locks.Lock
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.math.max
+import kotlin.math.min
+
+class BlockIntList(private val blockSize: Int = 1000) {
+
+    companion object {
+        private const val CACHE_COUNT = 8
+        private const val CACHE_SWITCH = 30
+    }
+
+    @JvmField
+    val lock: Lock = ReentrantLock()
+    private val recycled = ArrayList<Block>()
+    private val caches = ArrayList<Cache>(CACHE_COUNT + 2)
+    var size: Int = 0
+        private set
+    private var modCount: Int = 0
+    private var head: Block = Block()
+    private var foundIndex: Int = 0
+    private var foundBlock: Block? = null
+    private var updateTime: Int = 0
+    var max: Int = 0
+        get() {
+            if (modCount != updateTime) {
+                updateTime = modCount
+                computeMax()
+            }
+            return field
+        }
+        private set
+
+    init {
+        if (blockSize <= 4) {
+            throw IllegalArgumentException("block size must be bigger than 4")
+        }
+    }
+
+    private fun computeMax() {
+        var m = 0
+        var block: Block? = head
+        while (block != null) {
+            m = max(m, block.max)
+            block = block.next
+        }
+        max = m
+    }
+
+    private fun findBlock1(index: Int) {
+        var distance = index
+        var usedNo = -1
+        var fromBlock: Block = head
+        for (i in caches.indices) {
+            val c = caches[i]
+            if (c.indexOfStart < index && (index - c.indexOfStart) < distance) {
+                distance = index - c.indexOfStart
+                fromBlock = c.block!!
+                usedNo = i
+            }
+        }
+        if (usedNo != -1) {
+            Collections.swap(caches, 0, usedNo)
+        }
+        var crossCount = 0
+        while (distance >= fromBlock.size) {
+            if (fromBlock.next != null) {
+                distance -= fromBlock.size
+                fromBlock = fromBlock.next!!
+            } else {
+                break
+            }
+            crossCount++
+        }
+        if (crossCount >= CACHE_SWITCH) {
+            caches.add(cache(index - distance, fromBlock))
+        }
+        if (caches.size > CACHE_COUNT) {
+            caches.removeAt(caches.size - 1)
+        }
+        foundIndex = distance
+        foundBlock = fromBlock
+    }
+
+    private fun invalidateCacheFrom(index: Int) {
+        var i = 0
+        while (i < caches.size) {
+            if (caches[i].indexOfStart >= index) {
+                caches.removeAt(i)
+                i--
+            }
+            i++
+        }
+    }
+
+    private fun newBlock(): Block {
+        if (recycled.isEmpty()) {
+            return Block()
+        }
+        return recycled.removeAt(recycled.size - 1)
+    }
+
+    fun add(element: Int) {
+        add(size, element)
+    }
+
+    fun add(index: Int, element: Int) {
+        var idx = index
+        if (idx < 0 || idx > size) {
+            throw ArrayIndexOutOfBoundsException("index = $idx, length = $size")
+        }
+        findBlock1(idx)
+        invalidateCacheFrom(idx)
+        var block = foundBlock!!
+        idx = foundIndex
+        while (idx > block.size) {
+            if (block.next == null) {
+                break
+            } else {
+                idx -= block.size
+                block = block.next!!
+            }
+        }
+        block.add(idx, element)
+        size++
+        if (block.size > blockSize) {
+            block.separate()
+        }
+        modCount++
+    }
+
+    fun remove(index: Int): Int {
+        var idx = index
+        if (idx < 0 || idx >= size) {
+            throw ArrayIndexOutOfBoundsException("index = $idx, length = $size")
+        }
+        val backup = idx
+        var previous: Block? = null
+        var block: Block? = head
+        while (idx >= block!!.size) {
+            idx -= block.size
+            previous = block
+            block = block.next
+        }
+        val removedValue = block.remove(idx)
+        invalidateCacheFrom(backup - idx)
+        if (block.size == 0 && previous != null) {
+            previous.next = block.next
+            recycled.add(block)
+        } else if (block.size < blockSize / 4 && previous != null && previous.size + block.size < blockSize / 2) {
+            previous.next = block.next
+            System.arraycopy(block.data, 0, previous.data, previous.size, block.size)
+            previous.size += block.size
+        }
+        modCount++
+        size--
+        return removedValue
+    }
+
+    operator fun set(index: Int, element: Int): Int {
+        if (index < 0 || index >= size) {
+            throw ArrayIndexOutOfBoundsException("index = $index, length = $size")
+        }
+        findBlock1(index)
+        val old = foundBlock!!.set(foundIndex, element)
+        modCount++
+        return old
+    }
+
+    operator fun get(index: Int): Int {
+        if (index < 0 || index >= size) {
+            throw ArrayIndexOutOfBoundsException("index = $index, length = $size")
+        }
+        findBlock1(index)
+        return foundBlock!![foundIndex]
+    }
+
+    fun removeRange(fromIndex: Int, toIndex: Int) {
+        var fromIdx = fromIndex
+        var toIdx = toIndex
+        if (toIdx > size || fromIdx < 0 || fromIdx > toIdx) {
+            throw IndexOutOfBoundsException()
+        }
+        var previous: Block? = null
+        var block: Block? = head
+        while (fromIdx >= block!!.size) {
+            fromIdx -= block.size
+            toIdx -= block.size
+            previous = block
+            block = block.next
+        }
+        var deleteLength = toIdx - fromIdx
+        var begin = fromIdx
+        while (deleteLength > 0) {
+            if (begin == 0 && deleteLength >= block!!.size) {
+                if (previous != null) {
+                    previous.next = block.next
+                    recycled.add(block)
+                }
+                deleteLength -= block.size
+                block.size = 0
+                block = block.next
+                continue
+            }
+            begin = 0
+            val end = min(block!!.size, begin + deleteLength)
+            block.remove(begin, end)
+            deleteLength -= (end - begin)
+            previous = block
+            block = block.next
+        }
+        size -= (toIndex - fromIndex)
+    }
+
+    fun clear() {
+        head = Block()
+        size = 0
+        caches.clear()
+        foundBlock = null
+        foundIndex = 0
+    }
+
+    fun size(): Int {
+        return size
+    }
+
+    private fun cache(index: Int, block: Block): Cache {
+        val c = Cache()
+        c.indexOfStart = index
+        c.block = block
+        return c
+    }
+
+    private inner class Block {
+        val data: IntArray = IntArray(blockSize + 5)
+        var size: Int = 0
+        var max: Int = 0
+        var next: Block? = null
+
+        fun add(index: Int, element: Int) {
+            System.arraycopy(data, index, data, index + 1, size - index)
+            data[index] = element
+            size++
+            if (element > max) {
+                max = element
+            }
+        }
+
+        operator fun set(index: Int, element: Int): Int {
+            val old = data[index]
+            data[index] = element
+            if (old == max) {
+                if (element >= old) {
+                    max = element
+                } else {
+                    compute()
+                }
+            } else if (element > max) {
+                max = element
+            }
+            return old
+        }
+
+        operator fun get(index: Int): Int {
+            return data[index]
+        }
+
+        fun remove(index: Int): Int {
+            val oldValue = data[index]
+            System.arraycopy(data, index + 1, data, index, size - index - 1)
+            size--
+            if (oldValue == max) {
+                compute()
+            }
+            return oldValue
+        }
+
+        fun remove(start: Int, end: Int) {
+            System.arraycopy(data, end, data, start, size - end)
+            size -= (end - start)
+            compute()
+        }
+
+        fun separate() {
+            val oldNext = this.next
+            val newNext = newBlock()
+            val divPoint = blockSize * 3 / 4
+            System.arraycopy(this.data, divPoint, newNext.data, 0, this.size - divPoint)
+            newNext.size = this.size - divPoint
+            this.size = divPoint
+            this.next = newNext
+            newNext.next = oldNext
+            compute()
+            newNext.compute()
+        }
+
+        private fun compute() {
+            var m = 0
+            for (i in 0 until size) {
+                m = max(m, data[i])
+            }
+            max = m
+        }
+    }
+
+    private class Cache {
+        var block: Block? = null
+        var indexOfStart: Int = 0
+    }
+}

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

@@ -0,0 +1,29 @@
+package io.github.abc15018045126.sora.util
+
+import android.content.ClipData
+import android.content.Intent
+
+object ClipDataUtils {
+
+    @JvmStatic
+    fun clipDataToString(clipData: ClipData?): String {
+        if (clipData == null) {
+            return ""
+        }
+        val sb = StringBuilder()
+        for (i in 0 until clipData.itemCount) {
+            if (i > 0) {
+                sb.append('\n')
+            }
+            val item = clipData.getItemAt(i)
+            if (item.text != null) {
+                sb.append(item.text)
+            } else if (item.uri != null) {
+                sb.append(item.uri.toString())
+            } else if (item.intent != null) {
+                sb.append(item.intent.toUri(Intent.URI_INTENT_SCHEME))
+            }
+        }
+        return sb.toString()
+    }
+}

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

@@ -0,0 +1,10 @@
+package io.github.abc15018045126.sora.util
+
+import kotlin.math.abs
+
+object Floats {
+    @JvmStatic
+    fun withinDelta(a: Float, b: Float, delta: Float): Boolean {
+        return abs(a - b) < abs(delta)
+    }
+}

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

@@ -0,0 +1,76 @@
+package io.github.abc15018045126.sora.util
+
+/**
+ * Pack two int numbers into a long number, and unpack it.
+ * <p>
+ * This is effective for passing two primitive 32-bit numbers without creating a new object.
+ *
+ * @author abc15018045126
+ */
+object IntPair {
+
+    /**
+     * Convert an integer to a long whose binary bits are equal to the given integer
+     */
+    private fun toUnsignedLong(x: Int): Long {
+        return x.toLong() and 0xffffffffL
+    }
+
+    /**
+     * Pack two int number into a long number
+     *
+     * @param first  First of pair
+     * @param second Second of pair
+     * @return Packed value
+     */
+    @JvmStatic
+    fun pack(first: Int, second: Int): Long {
+        return (toUnsignedLong(first) shl 32) or toUnsignedLong(second)
+    }
+
+    /**
+     * Get second of pair
+     *
+     * @param packedValue Packed value
+     * @return Second of pair
+     */
+    @JvmStatic
+    fun getSecond(packedValue: Long): Int {
+        return (packedValue and 0xFFFFFFFFL).toInt()
+    }
+
+    /**
+     * Get first of pair
+     *
+     * @param packedValue Packed value
+     * @return First of pair
+     */
+    @JvmStatic
+    fun getFirst(packedValue: Long): Int {
+        return (packedValue ushr 32).toInt()
+    }
+
+    /**
+     * Pack an int number and a floating-number into a long number
+     *
+     * @param first  First of pair
+     * @param second Second of pair (float)
+     * @return Packed value
+     */
+    @JvmStatic
+    fun packIntFloat(first: Int, second: Float): Long {
+        return pack(first, java.lang.Float.floatToRawIntBits(second))
+    }
+
+    /**
+     * Get second of pair, but as a floating number
+     *
+     * @param packedValue Packed value
+     * @return Second of pair
+     * @see #packIntFloat(int, float)
+     */
+    @JvmStatic
+    fun getSecondAsFloat(packedValue: Long): Float {
+        return java.lang.Float.intBitsToFloat(getSecond(packedValue))
+    }
+}

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

@@ -0,0 +1,78 @@
+package io.github.abc15018045126.sora.util
+
+import android.util.Log
+import java.util.WeakHashMap
+
+class Logger private constructor(private val name: String) {
+
+    fun d(msg: String) {
+        Log.d(name, msg)
+    }
+
+    fun d(msg: String, vararg format: Any) {
+        Log.d(name, String.format(msg, *format))
+    }
+
+    fun i(msg: String) {
+        Log.i(name, msg)
+    }
+
+    fun i(msg: String, vararg format: Any) {
+        Log.i(name, String.format(msg, *format))
+    }
+
+    fun v(msg: String) {
+        Log.v(name, msg)
+    }
+
+    fun v(msg: String, vararg format: Any) {
+        Log.v(name, String.format(msg, *format))
+    }
+
+    fun w(msg: String) {
+        Log.w(name, msg)
+    }
+
+    fun w(msg: String, vararg format: Any) {
+        Log.w(name, String.format(msg, *format))
+    }
+
+    fun w(msg: String, e: Throwable) {
+        Log.w(name, msg, e)
+    }
+
+    fun w(msg: String, e: Throwable, vararg format: Any) {
+        Log.w(name, String.format(msg, *format), e)
+    }
+
+    fun e(msg: String) {
+        Log.e(name, msg)
+    }
+
+    fun e(msg: String, vararg format: Any) {
+        Log.e(name, String.format(msg, *format))
+    }
+
+    fun e(msg: String, e: Throwable) {
+        Log.e(name, msg, e)
+    }
+
+    fun e(msg: String, e: Throwable, vararg format: Any) {
+        Log.e(name, String.format(msg, *format), e)
+    }
+
+    companion object {
+        private val map: MutableMap<String, Logger> = WeakHashMap()
+
+        @JvmStatic
+        @Synchronized
+        fun instance(name: String): Logger {
+            var logger = map[name]
+            if (logger == null) {
+                logger = Logger(name)
+                map[name] = logger
+            }
+            return logger!!
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+package io.github.abc15018045126.sora.util
+
+/**
+ * ArrayList for primitive type long
+ *
+ * @author abc15018045126
+ */
+class LongArrayList {
+
+    private var data: LongArray = LongArray(64)
+    private var length: Int = 0
+
+    /**
+     * Add a value at end
+     */
+    fun add(value: Long) {
+        data[length++] = value
+        if (data.size == length) {
+            val newData = LongArray(length shl 1)
+            System.arraycopy(data, 0, newData, 0, length)
+            data = newData
+        }
+    }
+
+    /**
+     * Get length of the list
+     */
+    val size: Int
+        get() = length
+
+    fun size(): Int = length
+
+    /**
+     * Set element at given index to {@code value}
+     * @throws ArrayIndexOutOfBoundsException if index is invalid
+     */
+    fun set(index: Int, value: Long) {
+        if (index >= length || index < 0) {
+            throw ArrayIndexOutOfBoundsException(index)
+        }
+        data[index] = value
+    }
+
+    /**
+     * Refers to C++ algorithm lower_bound().
+     * Compare by {@link IntPair#getFirst(long)} on each element.
+     * <p>
+     * Note that, you guarantee the sequence in list is in ascendant order.
+     *
+     * @param key Target value
+     * @return Index of target value, or index of the insertion point (that's the index of first element
+     * bigger than {@code key} or array length)
+     */
+    fun lowerBoundByFirst(key: Int): Int {
+        var low = 0
+        var high = length - 1
+
+        while (low <= high) {
+            val mid = (low + high) ushr 1
+            val midVal = IntPair.getFirst(data[mid])
+
+            if (midVal < key)
+                low = mid + 1
+            else if (midVal > key)
+                high = mid - 1
+            else
+                return mid // key found
+        }
+        return low  // key not found.
+    }
+
+    fun lowerBound(key: Long): Int {
+        var low = 0
+        var high = length - 1
+
+        while (low <= high) {
+            val mid = (low + high) ushr 1
+            val midVal = data[mid]
+
+            if (midVal < key)
+                low = mid + 1
+            else if (midVal > key)
+                high = mid - 1
+            else
+                return mid // key found
+        }
+        return low  // key not found.
+    }
+
+    /**
+     * Get element at given index
+     * @throws ArrayIndexOutOfBoundsException if index is invalid
+     */
+    fun get(index: Int): Long {
+        if (index >= length || index < 0) {
+            throw ArrayIndexOutOfBoundsException(index)
+        }
+        return data[index]
+    }
+
+    fun clear() {
+        length = 0
+    }
+}

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

@@ -0,0 +1,14 @@
+package io.github.abc15018045126.sora.util
+
+class MutableInt(
+    @JvmField var value: Int
+) {
+
+    fun decreaseAndGet(): Int {
+        return --value
+    }
+
+    fun increase() {
+        value++
+    }
+}

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

@@ -0,0 +1,35 @@
+package io.github.abc15018045126.sora.util
+
+import java.util.ArrayList
+
+class MutableIntList {
+    private val data = ArrayList<Int>()
+
+    fun add(value: Int) {
+        data.add(value)
+    }
+
+    fun get(index: Int): Int {
+        return data[index]
+    }
+
+    fun size(): Int {
+        return data.size
+    }
+    
+    val size: Int
+        get() = data.size
+
+    fun clear() {
+        data.clear()
+    }
+    
+    fun set(index: Int, value: Int) {
+        if (index >= data.size) {
+             for (i in data.size..index) {
+                 data.add(0)
+             }
+        }
+        data[index] = value
+    }
+}