capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/event/ScrollEvent.kt

@@ -0,0 +1,48 @@
+package io.github.abc15018045126.sora.event
+
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Reports a scroll in editor.
+ * The scrolling action can either have run or be running when this event is generated and sent.
+ * <p>
+ * The returned x,y positions are usually positive when over-scrolling is disabled. They represent
+ * the left-top position's pixel in editor.
+ */
+class ScrollEvent @JvmOverloads constructor(
+    editor: CodeEditor,
+    val startX: Int,
+    val startY: Int,
+    val endX: Int,
+    val endY: Int,
+    val cause: Int,
+    val flingVelocityX: Float = 0f,
+    val flingVelocityY: Float = 0f
+) : Event(editor) {
+
+    companion object {
+        /**
+         * Caused by thumb's exact movements
+         */
+        const val CAUSE_USER_DRAG = 1
+
+        /**
+         * Caused by fling after user's movements
+         */
+        const val CAUSE_USER_FLING = 2
+
+        /**
+         * Caused by calling {@link CodeEditor#ensurePositionVisible(int, int)}.
+         * This can happen when this method is manually called or either the user edits the text
+         */
+        const val CAUSE_MAKE_POSITION_VISIBLE = 3
+
+        /**
+         * Caused by the user's thumb reaching the edge of editor viewport, which causes the editor to
+         * scroll to move the selection to text currently outside the viewport.
+         */
+        const val CAUSE_TEXT_SELECTING = 4
+
+        const val CAUSE_SCALE_TEXT = 5
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/event/SelectionChangeEvent.kt

@@ -0,0 +1,81 @@
+package io.github.abc15018045126.sora.event
+
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.widget.CodeEditor
+import io.github.abc15018045126.sora.widget.EditorSearcher
+
+/**
+ * This event happens when text is edited by the user, or the user click the view to change the
+ * position of selection. Even when the actual values of CharPosition are not changed, you may receive the event.
+ * <p>
+ * Note that you should not change returned CharPosition objects because they are shared in an event
+ * dispatch.
+ */
+class SelectionChangeEvent(
+    editor: CodeEditor,
+    val oldLeft: CharPosition?,
+    val oldRight: CharPosition?,
+    val cause: Int
+) : Event(editor) {
+
+    val left: CharPosition = editor.text.cursor.left()
+    val right: CharPosition = editor.text.cursor.right()
+
+    /**
+     * Checks whether text is selected
+     */
+    val isSelected: Boolean
+        get() = left.index != right.index
+
+    companion object {
+        /**
+         * Unknown cause
+         */
+        const val CAUSE_UNKNOWN = 0
+
+        /**
+         * Selection change caused by text modifications
+         */
+        const val CAUSE_TEXT_MODIFICATION = 1
+
+        /**
+         * Set selection by handle
+         */
+        const val CAUSE_SELECTION_HANDLE = 2
+
+        /**
+         * Set selection by single tap
+         */
+        const val CAUSE_TAP = 3
+
+        /**
+         * Set selection because of {@link android.view.inputmethod.InputConnection#setSelection(int, int)}
+         */
+        const val CAUSE_IME = 4
+
+        /**
+         * Long press
+         */
+        const val CAUSE_LONG_PRESS = 5
+
+        /**
+         * Search text by {@link EditorSearcher}
+         */
+        const val CAUSE_SEARCH = 6
+
+        /**
+         * From keyboard or direct method invocation to change selection
+         */
+        const val CAUSE_KEYBOARD_OR_CODE = 7
+
+        /**
+         * From mouse
+         */
+        const val CAUSE_MOUSE_INPUT = 8
+
+        /**
+         * Caused by a dead key press
+         */
+        const val CAUSE_DEAD_KEYS = 9
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/event/SideIconClickEvent.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/event/SnippetEvent.kt

@@ -0,0 +1,41 @@
+package io.github.abc15018045126.sora.event
+
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Notify that snippet controller state is changed.
+ * <br/>
+ * If action is {@link #ACTION_START} and any event receiver intercepts editor, the snippet edit will
+ * stop before moving to any tab stop. And consequently, a {@link SnippetEvent} with action {@link #ACTION_STOP}
+ * will be broadcast immediately.
+ * <br/>
+ * There is at least one tab stop in the list when action is {@link #ACTION_START} or {@link #ACTION_SHIFT}.
+ * But no tab stop is left there when action is {@link #ACTION_STOP}. The last tab stop is where the selection
+ * will be placed when the snippet is finished normally.
+ *
+ * @author abc15018045126
+ */
+class SnippetEvent(
+    editor: CodeEditor,
+    val action: Int,
+    val currentTabStop: Int,
+    val totalTabStop: Int
+) : Event(editor) {
+
+    companion object {
+        /**
+         * Called before controller shifts to any tab stop
+         */
+        const val ACTION_START = 1
+
+        /**
+         * Called when controller shifted to a tab stop
+         */
+        const val ACTION_SHIFT = 2
+
+        /**
+         * Called when controller <strong>has exited</strong> a snippet
+         */
+        const val ACTION_STOP = 3
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/event/SubscriptionReceipt.kt

@@ -0,0 +1,35 @@
+package io.github.abc15018045126.sora.event
+
+import java.lang.ref.WeakReference
+
+/**
+ * Receipt of {@link EventManager#subscribeEvent(Class, EventReceiver)}. You can unsubscribe the event outside
+ * the dispatch process from any thread by calling {@link SubscriptionReceipt#unsubscribe()}
+ *
+ * @author abc15018045126
+ */
+class SubscriptionReceipt<R : Event> internal constructor(
+    private val manager: EventManager,
+    private val clazz: Class<R>,
+    receiver: EventReceiver<R>
+) {
+    private val receiver: WeakReference<EventReceiver<R>> = WeakReference(receiver)
+
+    /**
+     * Unsubscribe the event receiver.
+     * <p>
+     * Does nothing if the listener is already recycled or unsubscribed.
+     */
+    fun unsubscribe() {
+        val receivers = manager.getReceivers(clazz)
+        receivers.lock.writeLock().lock()
+        try {
+            val target = receiver.get()
+            if (target != null) {
+                receivers.receivers.remove(target)
+            }
+        } finally {
+            receivers.lock.writeLock().unlock()
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/event/Unsubscribe.kt

@@ -0,0 +1,28 @@
+package io.github.abc15018045126.sora.event
+
+/**
+ * Instance for unsubscribing for a receiver.
+ * <p>
+ * Note that this instance can be reused during an event dispatch, so
+ * it is not a valid behavior to save the instance in event receivers.
+ * Always use the one given by {@link EventReceiver#onReceive(Event, Unsubscribe)}.
+ */
+class Unsubscribe {
+    var isUnsubscribed: Boolean = false
+        private set
+
+    /**
+     * Unsubscribe the event. And current receiver will not get event again.
+     * References to the receiver are also removed.
+     */
+    fun unsubscribe() {
+        isUnsubscribed = true
+    }
+
+    /**
+     * Reset the flag
+     */
+    fun reset() {
+        isUnsubscribed = false
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/event/Utils.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/event/editorMinorEvents.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/graphics/BubbleHelper.kt

@@ -0,0 +1,59 @@
+package io.github.abc15018045126.sora.graphics
+
+import android.graphics.Matrix
+import android.graphics.Path
+import android.graphics.RectF
+import kotlin.math.sqrt
+
+/**
+ * Helper class for building a bubble rect
+ *
+ * @author abc15018045126
+ */
+object BubbleHelper {
+
+    private val tempMatrix = Matrix()
+
+    /**
+     * Build a bubble into the given Path object. Old content in given Path is cleared.
+     * @param path target Path object
+     * @param bounds The bounds for the bubble
+     */
+    @JvmStatic
+    fun buildBubblePath(path: Path, bounds: RectF) {
+        path.reset()
+
+        var width = bounds.width()
+        val height = bounds.height()
+        val r = height / 2
+        val sqrt2 = sqrt(2.0).toFloat()
+        // Ensure we are convex.
+        width = maxOf(r + sqrt2 * r, width)
+        pathArcTo(path, r, r, r, 90f, 180f)
+        val o1X = width - sqrt2 * r
+        pathArcTo(path, o1X, r, r, -90f, 45f)
+        val r2 = r / 5
+        val o2X = width - sqrt2 * r2
+        pathArcTo(path, o2X, r, r2, -45f, 90f)
+        pathArcTo(path, o1X, r, r, 45f, 45f)
+        path.close()
+
+        tempMatrix.reset()
+        tempMatrix.postTranslate(bounds.left, bounds.top)
+        path.transform(tempMatrix)
+    }
+
+    private fun pathArcTo(
+        path: Path,
+        centerX: Float,
+        centerY: Float,
+        radius: Float,
+        startAngle: Float,
+        sweepAngle: Float
+    ) {
+        path.arcTo(
+            centerX - radius, centerY - radius, centerX + radius, centerY + radius,
+            startAngle, sweepAngle, false
+        )
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/graphics/BufferedDrawPoints.kt

@@ -0,0 +1,37 @@
+package io.github.abc15018045126.sora.graphics
+
+import android.graphics.Canvas
+import android.graphics.Paint
+
+class BufferedDrawPoints {
+
+    private var pointCount: Int = 0
+    private var points: FloatArray = FloatArray(128)
+    private var offsetX: Float = 0f
+    private var offsetY: Float = 0f
+
+    fun drawPoint(cx: Float, cy: Float) {
+        // Check buffer size and grow
+        if (points.size < (pointCount + 1) * 2) {
+            val newBuffer = FloatArray(points.size shl 1)
+            System.arraycopy(points, 0, newBuffer, 0, pointCount * 2)
+            points = newBuffer
+        }
+        points[pointCount * 2] = cx + offsetX
+        points[pointCount * 2 + 1] = cy + offsetY
+        pointCount++
+    }
+
+    fun setOffsets(x: Float, y: Float) {
+        this.offsetX = x
+        this.offsetY = y
+    }
+
+    fun commitPoints(canvas: Canvas, paint: Paint) {
+        if (pointCount == 0) {
+            return
+        }
+        canvas.drawPoints(points, 0, pointCount * 2, paint)
+        pointCount = 0
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/graphics/GraphemeBoundsBreaker.kt

@@ -0,0 +1,31 @@
+package io.github.abc15018045126.sora.graphics
+
+/**
+ * Utility for breaking text by grapheme bounds
+ *
+ * @author abc15018045126
+ */
+object GraphemeBoundsBreaker {
+
+    /**
+     * Find next grapheme break point before the given width
+     */
+    @JvmStatic
+    fun findGraphemeBreakPoint(advances: FloatArray, length: Int, width: Int, start: Int): Int {
+        var currentWidth = 0f
+        var next = start
+        while (next < length) {
+            if (advances[next] == 0f) {
+                // Not grapheme bound
+                next++
+                continue
+            }
+            if (currentWidth + advances[next] > width) {
+                break
+            }
+            currentWidth += advances[next]
+            next++
+        }
+        return next
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/graphics/GraphicCharacter.kt

@@ -0,0 +1,28 @@
+package io.github.abc15018045126.sora.graphics
+
+import io.github.abc15018045126.sora.util.MyCharacter
+
+object GraphicCharacter {
+
+    @JvmStatic
+    fun isCombiningCharacter(codePoint: Int): Boolean {
+        return MyCharacter.isVariationSelector(codePoint) || MyCharacter.isFitzpatrick(codePoint)
+                || MyCharacter.isZWJ(codePoint) || MyCharacter.isZWNJ(codePoint) ||
+                MyCharacter.couldBeEmoji(codePoint)
+                || (Character.charCount(codePoint) == 1 && Character.isSurrogate(codePoint.toChar()))
+                || isASCIICombiningSymbol(codePoint)
+    }
+
+    @JvmStatic
+    fun isASCIICombiningSymbol(codePoint: Int): Boolean {
+        return codePoint == '.'.code || codePoint == '/'.code || codePoint == '!'.code || codePoint == '='.code ||
+                codePoint == '<'.code || codePoint == '>'.code || codePoint == '-'.code
+    }
+
+    @JvmStatic
+    fun couldBeEmojiPart(codePoint: Int): Boolean {
+        return MyCharacter.isVariationSelector(codePoint) || MyCharacter.isFitzpatrick(codePoint)
+                || MyCharacter.isZWJ(codePoint) || MyCharacter.isZWNJ(codePoint) ||
+                MyCharacter.couldBeEmoji(codePoint)
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/graphics/GraphicsCompat.kt

@@ -0,0 +1,48 @@
+package io.github.abc15018045126.sora.graphics
+
+import android.annotation.SuppressLint
+import android.graphics.Canvas
+import android.os.Build
+
+object GraphicsCompat {
+
+    /**
+     * {@link Canvas#drawTextRun(char[], int, int, int, int, float, float, boolean, android.graphics.Paint)} is also available on API 21 & 22,
+     * but with hidden access.
+     * As there is no hidden list checks in those API platforms, it's safe here to call the "New API".
+     */
+    @SuppressLint("NewApi")
+    @JvmStatic
+    fun drawTextRun(
+        canvas: Canvas,
+        text: CharArray,
+        index: Int,
+        count: Int,
+        contextIndex: Int,
+        contextCount: Int,
+        x: Float,
+        y: Float,
+        isRtl: Boolean,
+        paint: android.graphics.Paint
+    ) {
+        canvas.drawTextRun(text, index, count, contextIndex, contextCount, x, y, isRtl, paint)
+    }
+
+    @JvmStatic
+    fun getRunAdvance(
+        paint: Paint,
+        text: CharArray,
+        start: Int,
+        end: Int,
+        contextStart: Int,
+        contextEnd: Int,
+        isRtl: Boolean,
+        offset: Int
+    ): Float {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            paint.getRunAdvance(text, start, end, contextStart, contextEnd, isRtl, offset)
+        } else {
+            paint.measureTextRunAdvance(text, start, offset, contextStart, contextEnd, isRtl)
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/graphics/Paint.kt

@@ -0,0 +1,191 @@
+package io.github.abc15018045126.sora.graphics
+
+import android.annotation.SuppressLint
+import android.graphics.Typeface
+import android.os.Build
+import androidx.annotation.CallSuper
+import io.github.abc15018045126.sora.text.ContentLine
+import io.github.abc15018045126.sora.text.FunctionCharacters
+
+open class Paint @JvmOverloads constructor(
+    var isRenderFunctionCharacters: Boolean = false
+) : android.graphics.Paint() {
+
+    var spaceWidth: Float = 0f
+        private set
+
+    init {
+        spaceWidth = measureText(" ")
+    }
+
+    open fun onAttributeUpdate() {
+        spaceWidth = measureText(" ")
+    }
+
+    fun setTypefaceWrapped(typeface: Typeface?) {
+        super.setTypeface(typeface)
+        onAttributeUpdate()
+    }
+
+    fun setTextSizeWrapped(textSize: Float) {
+        super.setTextSize(textSize)
+        onAttributeUpdate()
+    }
+
+    fun setFontFeatureSettingsWrapped(settings: String?) {
+        super.setFontFeatureSettings(settings)
+        onAttributeUpdate()
+    }
+
+    @CallSuper
+    override fun setLetterSpacing(letterSpacing: Float) {
+        super.setLetterSpacing(letterSpacing)
+        onAttributeUpdate()
+    }
+
+    @SuppressLint("NewApi")
+    fun myGetTextRunAdvances(
+        chars: CharArray,
+        index: Int,
+        count: Int,
+        contextIndex: Int,
+        contextCount: Int,
+        isRtl: Boolean,
+        advances: FloatArray?,
+        advancesIndex: Int
+    ): Float {
+        var advance = getTextRunAdvances(
+            chars,
+            index,
+            count,
+            contextIndex,
+            contextCount,
+            isRtl,
+            advances,
+            advancesIndex
+        )
+        if (isRenderFunctionCharacters) {
+            for (i in 0 until count) {
+                val ch = chars[index + i]
+                if (FunctionCharacters.isEditorFunctionChar(ch)) {
+                    val width = measureText(FunctionCharacters.getNameForFunctionCharacter(ch))
+                    if (advances != null) {
+                        advance -= advances[advancesIndex + i]
+                        advances[advancesIndex + i] = width
+                    } else {
+                        advance -= measureText(ch.toString())
+                    }
+                    advance += width
+                }
+            }
+        }
+        return advance
+    }
+
+    /**
+     * Get the advance of text with the context positions related to shaping the characters
+     */
+    fun measureTextRunAdvance(
+        text: CharArray,
+        start: Int,
+        end: Int,
+        contextStart: Int,
+        contextEnd: Int,
+        isRtl: Boolean
+    ): Float {
+        return myGetTextRunAdvances(
+            text,
+            start,
+            end - start,
+            contextStart,
+            contextEnd - contextStart,
+            isRtl,
+            null,
+            0
+        )
+    }
+
+    /**
+     * Find offset for a certain advance returned by [.measureTextRunAdvance]
+     */
+    fun findOffsetByRunAdvance(
+        text: ContentLine, intStart: Int, end: Int,
+        contextStart: Int, contextEnd: Int, isRtl: Boolean,
+        advance: Float
+    ): Int {
+        var start = intStart
+        if (isRenderFunctionCharacters) {
+            var lastEnd = start
+            var current = 0f
+            val textChars = text.backingCharArray
+            for (i in start until end) {
+                val ch = textChars[i]
+                if (FunctionCharacters.isEditorFunctionChar(ch)) {
+                    val result = if (lastEnd == i) i else breakTextImpl(
+                        text,
+                        lastEnd,
+                        i,
+                        contextStart,
+                        contextEnd,
+                        isRtl,
+                        advance - current
+                    )
+                    if (result < i) {
+                        return result
+                    }
+                    current += measureTextRunAdvance(
+                        textChars,
+                        lastEnd,
+                        i,
+                        contextStart,
+                        contextEnd,
+                        isRtl
+                    )
+                    current += measureText(FunctionCharacters.getNameForFunctionCharacter(ch))
+                    if (current >= advance) {
+                        return i
+                    }
+                    lastEnd = i + 1
+                }
+            }
+            if (lastEnd < end) {
+                return breakTextImpl(
+                    text,
+                    lastEnd,
+                    end,
+                    contextStart,
+                    contextEnd,
+                    isRtl,
+                    advance - current
+                )
+            }
+            return end
+        } else {
+            return breakTextImpl(text, start, end, contextStart, contextEnd, isRtl, advance)
+        }
+    }
+
+    private fun breakTextImpl(
+        text: ContentLine,
+        start: Int,
+        end: Int,
+        contextStart: Int,
+        contextEnd: Int,
+        isRtl: Boolean,
+        advance: Float
+    ): Int {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            getOffsetForAdvance(
+                text.backingCharArray,
+                start,
+                end,
+                contextStart,
+                contextEnd,
+                isRtl,
+                advance
+            )
+        } else {
+            start + breakText(text.backingCharArray, start, end - start, advance, null)
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/graphics/RectUtils.kt

@@ -0,0 +1,16 @@
+package io.github.abc15018045126.sora.graphics
+
+import android.graphics.RectF
+
+object RectUtils {
+
+    @JvmStatic
+    fun contains(rect: RectF, x: Float, y: Float, extraXSpace: Float): Boolean {
+        return (x >= rect.left - extraXSpace && x <= rect.right + extraXSpace && y >= rect.top && y <= rect.bottom)
+    }
+
+    @JvmStatic
+    fun almostContains(rect: RectF, x: Float, y: Float, extraSpace: Float): Boolean {
+        return (x >= rect.left - extraSpace && x <= rect.right + extraSpace && y >= rect.top - extraSpace && y <= rect.bottom + extraSpace)
+    }
+}