capacitor-sora-editor 1.2.1 → 1.8.2

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

@@ -0,0 +1,103 @@
+package io.github.abc15018045126.sora.event
+
+import android.view.KeyEvent
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Receives key related events in editor.
+ * <p>
+ * You may set a boolean for editor to return to the Android KeyEvent framework.
+ *
+ * @author abc15018045126
+ * @see ResultedEvent.result
+ * <p>
+ * This class mirrors methods of {@link KeyEvent}, but some methods are changed:
+ * @see #isAltPressed()
+ * @see #isShiftPressed()
+ */
+open class EditorKeyEvent(
+    editor: CodeEditor,
+    private val src: KeyEvent,
+    val eventType: Type
+) : ResultedEvent<Boolean>(editor) {
+
+    private val shiftPressed: Boolean = editor.getKeyMetaStates().isShiftPressed
+    private val altPressed: Boolean = editor.getKeyMetaStates().isAltPressed
+
+    override fun canIntercept(): Boolean {
+        return true
+    }
+
+    val action: Int
+        get() = src.action
+
+    val keyCode: Int
+        get() = src.keyCode
+
+    val repeatCount: Int
+        get() = src.repeatCount
+
+    val metaState: Int
+        get() = src.metaState
+
+    val modifiers: Int
+        get() = src.modifiers
+
+    val downTime: Long
+        get() = src.downTime
+
+    override val eventTime: Long
+        get() = src.eventTime
+
+    /**
+     * editor change: track shift/alt by {@link KeyMetaStates}
+     */
+    fun isShiftPressed(): Boolean {
+        return shiftPressed
+    }
+
+    /**
+     * editor change: track shift/alt by {@link KeyMetaStates}
+     */
+    fun isAltPressed(): Boolean {
+        return altPressed
+    }
+
+    fun isCtrlPressed(): Boolean {
+        return (src.metaState and KeyEvent.META_CTRL_ON) != 0
+    }
+
+    fun markAsConsumed() {
+        interceptAndSetResult(true)
+    }
+
+    fun result(editorResult: Boolean): Boolean {
+        val res = result
+        val userResult = res ?: false
+        return if (isIntercepted()) {
+            userResult
+        } else {
+            userResult || editorResult
+        }
+    }
+
+    /**
+     * The type of {@link EditorKeyEvent}.
+     */
+    enum class Type {
+        /**
+         * Used for {@link CodeEditor#onKeyUp(int, KeyEvent)}.
+         */
+        UP,
+
+        /**
+         * Used for {@link CodeEditor#onKeyDown(int, KeyEvent)}.
+         */
+        DOWN,
+
+        /**
+         * Used for {@link CodeEditor#onKeyMultiple(int, int, KeyEvent)}.
+         */
+        MULTIPLE
+    }
+}

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

@@ -0,0 +1,111 @@
+package io.github.abc15018045126.sora.event
+
+import android.view.InputDevice
+import android.view.MotionEvent
+import io.github.abc15018045126.sora.lang.styling.Span
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.TextRange
+import io.github.abc15018045126.sora.widget.CodeEditor
+import io.github.abc15018045126.sora.widget.REGION_DIVIDER
+import io.github.abc15018045126.sora.widget.REGION_DIVIDER_MARGIN
+import io.github.abc15018045126.sora.widget.REGION_LINE_NUMBER
+import io.github.abc15018045126.sora.widget.REGION_OUTBOUND
+import io.github.abc15018045126.sora.widget.REGION_SIDE_ICON
+import io.github.abc15018045126.sora.widget.REGION_TEXT
+import io.github.abc15018045126.sora.widget.IN_BOUND as WIDGET_IN_BOUND
+import io.github.abc15018045126.sora.widget.OUT_BOUND as WIDGET_OUT_BOUND
+
+/**
+ * Base class for click events
+ *
+ * @author abc15018045126
+ * @see ClickEvent
+ * @see DoubleClickEvent
+ * @see LongPressEvent
+ * @see ContextClickEvent
+ * @see HoverEvent
+ */
+abstract class EditorMotionEvent(
+    editor: CodeEditor,
+    private val pos: CharPosition,
+    private val event: MotionEvent,
+    val span: Span?,
+    val spanRange: TextRange?,
+    val motionRegion: Int,
+    val motionBound: Int
+) : Event(editor) {
+
+    companion object {
+        /**
+         * Motion occurred outside of editor.
+         */
+        const val REGION_OUTBOUND = io.github.abc15018045126.sora.widget.REGION_OUTBOUND
+
+        /**
+         * Motion occurred in line number region.
+         */
+        const val REGION_LINE_NUMBER = io.github.abc15018045126.sora.widget.REGION_LINE_NUMBER
+
+        /**
+         * Motion occurred in side icon region.
+         */
+        const val REGION_SIDE_ICON = io.github.abc15018045126.sora.widget.REGION_SIDE_ICON
+
+        /**
+         * Motion occurred in divider margin region.
+         */
+        const val REGION_DIVIDER_MARGIN = io.github.abc15018045126.sora.widget.REGION_DIVIDER_MARGIN
+
+        /**
+         * Motion occurred in line divider region.
+         */
+        const val REGION_DIVIDER = io.github.abc15018045126.sora.widget.REGION_DIVIDER
+
+        /**
+         * Motion occurred in text region.
+         */
+        const val REGION_TEXT = io.github.abc15018045126.sora.widget.REGION_TEXT
+
+        /**
+         * Motion occurred in editor bounds on the Y-axis.
+         */
+        const val IN_BOUND = io.github.abc15018045126.sora.widget.IN_BOUND
+
+        /**
+         * Motion occurred outside of editor bounds on the Y-axis.
+         */
+        const val OUT_BOUND = io.github.abc15018045126.sora.widget.OUT_BOUND
+    }
+
+    override fun canIntercept(): Boolean {
+        return true
+    }
+
+    val isFromMouse: Boolean
+        get() = event.isFromSource(InputDevice.SOURCE_MOUSE)
+
+    val line: Int
+        get() = pos.line
+
+    val column: Int
+        get() = pos.column
+
+    val index: Int
+        get() = pos.index
+
+    fun getCharPosition(): CharPosition {
+        return pos.fromThis()
+    }
+
+    val x: Float
+        get() = event.x
+
+    val y: Float
+        get() = event.y
+
+    /**
+     * Get original event object from Android framework
+     */
+    val causingEvent: MotionEvent
+        get() = event
+}

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

@@ -0,0 +1,69 @@
+package io.github.abc15018045126.sora.event
+
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * An Event object describes an event of editor.
+ * It includes several attributes such as time and the editor object.
+ * Subclasses of Event will define their own fields or methods.
+ *
+ * @author abc15018045126
+ */
+abstract class Event @JvmOverloads constructor(
+    val editor: CodeEditor,
+    open val eventTime: Long = System.currentTimeMillis()
+) {
+    var interceptTargets: Int = 0
+        private set
+
+    /**
+     * Check whether this event can be intercepted (so that the event is not sent to other
+     * receivers after being intercepted)
+     * Intercept-able events:
+     *
+     * @see LongPressEvent
+     * @see ClickEvent
+     * @see DoubleClickEvent
+     * @see EditorKeyEvent
+     */
+    open fun canIntercept(): Boolean {
+        return false
+    }
+
+    /**
+     * Intercept the event for all targets.
+     * <p>
+     * Make sure {@link #canIntercept()} returns true. Otherwise, an {@link UnsupportedOperationException}
+     * will be thrown.
+     *
+     * @see InterceptTarget
+     */
+    fun intercept() {
+        if (!canIntercept()) {
+            throw UnsupportedOperationException("intercept() not supported")
+        }
+        interceptTargets = InterceptTarget.TARGET_EDITOR or InterceptTarget.TARGET_RECEIVERS
+    }
+
+    /**
+     * Intercept the event for some targets
+     *
+     * @param targets Masks for target types
+     * @see InterceptTarget
+     */
+    fun intercept(targets: Int) {
+        if (!canIntercept()) {
+            throw UnsupportedOperationException("intercept() not supported")
+        }
+        interceptTargets = targets
+    }
+
+    /**
+     * Check whether this event is intercepted for some types of targets
+     *
+     * @see #getInterceptTargets()
+     */
+    fun isIntercepted(): Boolean {
+        return interceptTargets != 0
+    }
+}

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

@@ -0,0 +1,267 @@
+package io.github.abc15018045126.sora.event
+
+import java.util.ArrayList
+import java.util.Arrays
+import java.util.HashMap
+import java.util.LinkedList
+import java.util.Vector
+import java.util.concurrent.locks.ReadWriteLock
+import java.util.concurrent.locks.ReentrantReadWriteLock
+
+/**
+ * This class manages event dispatching in editor.
+ * Users can either register their event receivers here or dispatch event to
+ * the receivers in this manager.
+ * <p>
+ * There may be several EventManagers in one editor instance. For example, each plugin
+ * will have it own EventManager and the editor also has a root event manager for external
+ * listeners.
+ * <p>
+ * Note that the event type must be exact. That's to say, you need to use a terminal class instead
+ * of using its parent classes. For instance, if you register a receiver with the event type {@link Event},
+ * no event will be sent to your receiver.
+ *
+ * @author abc15018045126
+ */
+class EventManager @JvmOverloads constructor(private val parent: EventManager? = null) {
+
+    private val receiversMap: MutableMap<Class<*>, Receivers<*>> = HashMap()
+    private val lock: ReadWriteLock = ReentrantReadWriteLock()
+    private val children: MutableList<EventManager> = Vector()
+    private val caches: Array<Array<EventReceiver<*>>?> = arrayOfNulls(5)
+
+    var isEnabled: Boolean = true
+        /**
+         * Set enabled.
+         * Disabled EventManager will not deliver event to its subscribers or children.
+         * Root EventManager can not be disabled.
+         */
+        set(value) {
+            if (parent == null && !value) {
+                throw IllegalStateException("The event manager is set to be root, and can not be disabled")
+            }
+            field = value
+        }
+
+    private var detached: Boolean = false
+
+    init {
+        parent?.children?.add(this)
+    }
+
+    /**
+     * Get root node
+     */
+    val rootManager: EventManager
+        get() {
+            checkDetached()
+            return parent?.rootManager ?: this
+        }
+
+    /**
+     * Get root manager and dispatch the given event
+     *
+     * @see #dispatchEvent(Event)
+     */
+    fun <T : Event> dispatchEventFromRoot(event: T): Int {
+        return rootManager.dispatchEvent(event)
+    }
+
+    /**
+     * Detached from parent.
+     * This manager will not receive future events from parent
+     */
+    fun detach() {
+        if (parent == null) {
+            throw IllegalStateException("root manager can not be detached")
+        }
+        checkDetached()
+        detached = true
+        parent.children.remove(this)
+    }
+
+    private fun checkDetached() {
+        if (detached) {
+            throw IllegalStateException("already detached")
+        }
+    }
+
+    /**
+     * Get receivers container of a given event type safely
+     */
+    @Suppress("UNCHECKED_CAST")
+    internal fun <T : Event> getReceivers(type: Class<T>): Receivers<T> {
+        lock.readLock().lock()
+        var result: Receivers<T>?
+        try {
+            result = receiversMap[type] as Receivers<T>?
+        } finally {
+            lock.readLock().unlock()
+        }
+        if (result == null) {
+            lock.writeLock().lock()
+            try {
+                result = receiversMap[type] as Receivers<T>?
+                if (result == null) {
+                    result = Receivers()
+                    receiversMap[type] = result
+                }
+            } finally {
+                lock.writeLock().unlock()
+            }
+        }
+        return result!!
+    }
+
+    /**
+     * @see #subscribeEvent(Class, EventReceiver)
+     */
+    fun <T : Event> subscribe(eventType: Class<T>, receiver: EventReceiver<T>): SubscriptionReceipt<T> {
+        return subscribeEvent(eventType, receiver)
+    }
+
+    /**
+     * Subscribe a event and never unsubscribe from event receiver
+     */
+    fun <T : Event> subscribeAlways(
+        eventType: Class<T>,
+        receiver: NoUnsubscribeReceiver<T>
+    ): SubscriptionReceipt<T> {
+        return subscribeEvent(eventType) { event, _ -> receiver.onEvent(event) }
+    }
+
+    /**
+     * Register a receiver of the given event.
+     *
+     * @param eventType Event type to be received
+     * @param receiver  Receiver of event
+     * @param <T>       Event type
+     */
+    fun <T : Event> subscribeEvent(
+        eventType: Class<T>,
+        receiver: EventReceiver<T>
+    ): SubscriptionReceipt<T> {
+        val receivers = getReceivers(eventType)
+        receivers.lock.writeLock().lock()
+        try {
+            val list = receivers.receivers
+            if (!list.contains(receiver)) {
+                list.add(receiver)
+            }
+        } finally {
+            receivers.lock.writeLock().unlock()
+        }
+        return SubscriptionReceipt(this, eventType, receiver)
+    }
+
+    /**
+     * Dispatch the given event to its receivers registered in this manager.
+     *
+     * @param event Event to dispatch
+     * @param <T>   Event type
+     * @return The event's intercept targets
+     */
+    @Suppress("UNCHECKED_CAST")
+    fun <T : Event> dispatchEvent(event: T): Int {
+        if (!isEnabled) {
+            return event.interceptTargets
+        }
+        // Safe cast
+        val receivers = getReceivers(event.javaClass as Class<T>)
+        receivers.lock.readLock().lock()
+        var receiverArr: Array<EventReceiver<T>>
+        var count: Int
+        try {
+            count = receivers.receivers.size
+            receiverArr = obtainBuffer(count)
+            (receivers.receivers as ArrayList<EventReceiver<T>>).toArray(receiverArr)
+        } finally {
+            receivers.lock.readLock().unlock()
+        }
+        var unsubscribedReceivers: MutableList<EventReceiver<T>>? = null
+        try {
+            val unsubscribe = Unsubscribe()
+            var i = 0
+            while (i < count && (event.interceptTargets and InterceptTarget.TARGET_RECEIVERS) == 0) {
+                val receiver = receiverArr[i]
+                receiver.onReceive(event, unsubscribe)
+                if (unsubscribe.isUnsubscribed) {
+                    if (unsubscribedReceivers == null) {
+                        unsubscribedReceivers = LinkedList()
+                    }
+                    unsubscribedReceivers.add(receiver)
+                }
+                unsubscribe.reset()
+                i++
+            }
+        } finally {
+            if (unsubscribedReceivers != null) {
+                receivers.lock.writeLock().lock()
+                try {
+                    receivers.receivers.removeAll(unsubscribedReceivers!!)
+                } finally {
+                    receivers.lock.writeLock().unlock()
+                }
+            }
+            recycleBuffer(receiverArr)
+        }
+        var j = 0
+        while (j < children.size && (event.interceptTargets and InterceptTarget.TARGET_RECEIVERS) == 0) {
+            var sub: EventManager? = null
+            try {
+                sub = children[j]
+            } catch (e: IndexOutOfBoundsException) {
+                // concurrent mod ignored
+            }
+            sub?.dispatchEvent(event)
+            j++
+        }
+        return event.interceptTargets
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun <V : Event> obtainBuffer(size: Int): Array<EventReceiver<V>> {
+        var res: Array<EventReceiver<V>>? = null
+        synchronized(this) {
+            for (i in caches.indices) {
+                if (caches[i] != null && caches[i]!!.size >= size) {
+                    res = caches[i] as Array<EventReceiver<V>>?
+                    caches[i] = null
+                    break
+                }
+            }
+        }
+        if (res == null) {
+            res = java.lang.reflect.Array.newInstance(EventReceiver::class.java, size) as Array<EventReceiver<V>>
+        }
+        return res!!
+    }
+
+    @Synchronized
+    private fun recycleBuffer(array: Array<out EventReceiver<*>>?) {
+        if (array == null) {
+            return
+        }
+        for (i in caches.indices) {
+            if (caches[i] == null) {
+                Arrays.fill(array, null)
+                caches[i] = array as Array<EventReceiver<*>>
+                break
+            }
+        }
+    }
+
+    /**
+     * Internal class for saving receivers of each type
+     *
+     * @param <T> Event type
+     */
+    internal class Receivers<T : Event> {
+        val lock: ReadWriteLock = ReentrantReadWriteLock()
+        val receivers: MutableList<EventReceiver<T>> = ArrayList()
+    }
+
+    fun interface NoUnsubscribeReceiver<T : Event> {
+        fun onEvent(event: T)
+    }
+}

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

@@ -0,0 +1,5 @@
+package io.github.abc15018045126.sora.event
+
+fun interface EventReceiver<T : Event> {
+    fun onReceive(event: T, unsubscribe: Unsubscribe)
+}

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

@@ -0,0 +1,21 @@
+package io.github.abc15018045126.sora.event
+
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Notifies a selection handle's touch state has changed
+ *
+ * @author abc15018045126
+ */
+class HandleStateChangeEvent(
+    editor: CodeEditor,
+    val handleType: Int,
+    val isHeld: Boolean
+) : Event(editor) {
+
+    companion object {
+        const val HANDLE_TYPE_INSERT = 0
+        const val HANDLE_TYPE_LEFT = 1
+        const val HANDLE_TYPE_RIGHT = 2
+    }
+}

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

@@ -0,0 +1,18 @@
+package io.github.abc15018045126.sora.event
+
+/**
+ * Define available intercept targets. You may intercept one or more targets of the given event.
+ *
+ * @author abc15018045126
+ */
+object InterceptTarget {
+    /**
+     * Registered receivers in the event dispatching graph
+     */
+    const val TARGET_RECEIVERS = 1
+
+    /**
+     * Editor built-in behavior
+     */
+    const val TARGET_EDITOR = 1 shl 1
+}

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

@@ -0,0 +1,34 @@
+package io.github.abc15018045126.sora.event
+
+import android.view.KeyEvent
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Keybinding event in editor.
+ *
+ * <p> This is different from {@link EditorKeyEvent}.
+ * An {@code EditorKeyEvent} is dispatched by the editor whenever there is a key event.
+ * However, a {@code KeyBindingEvent} is dispatched only for keybindings i.e.
+ * when multiple keys are pressed at once.
+ * For example, <b>Ctrl + X, Ctrl + D, Ctrl + Alt + O, etc.</b>
+ * </p>
+ *
+ * <p>
+ * This event is dispatched <strong>after</strong> the {@link EditorKeyEvent}.
+ * So, if any {@code EditorKeyEvent} consumes the event (sets the {@link InterceptTarget#TARGET_EDITOR} flag),
+ * {@code KeyBindingEvent} will not be called.
+ * </p>
+ *
+ * @author Akash Yadav
+ */
+class KeyBindingEvent(
+    editor: CodeEditor,
+    src: KeyEvent,
+    type: Type,
+    /**
+     * Is the editor capable of handling this key binding event?
+     *
+     * @return <code>true</code> if the editor can handle this event. <code>false</code> otherwise.
+     */
+    val canEditorHandle: Boolean
+) : EditorKeyEvent(editor, src, type)

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

@@ -0,0 +1,25 @@
+package io.github.abc15018045126.sora.event
+
+import android.view.MotionEvent
+import io.github.abc15018045126.sora.lang.styling.Span
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.TextRange
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Long press event.
+ * <p>
+ * This event can be intercepted so that the editor framework will do nothing (such as selecting a word). You can take over the
+ * procedure. Note that after intercepting an event, it will not be sent to other listeners, either.
+ *
+ * @author abc15018045126
+ */
+class LongPressEvent(
+    editor: CodeEditor,
+    position: CharPosition,
+    event: MotionEvent,
+    span: Span?,
+    spanRange: TextRange?,
+    motionRegion: Int,
+    motionBound: Int
+) : EditorMotionEvent(editor, position, event, span, spanRange, motionRegion, motionBound)

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

@@ -0,0 +1,21 @@
+package io.github.abc15018045126.sora.event
+
+import io.github.abc15018045126.sora.widget.CodeEditor
+
+/**
+ * Event with a result
+ *
+ * @param <T> Result type
+ */
+abstract class ResultedEvent<T>(editor: CodeEditor) : Event(editor) {
+
+    var result: T? = null
+
+    fun interceptAndSetResult(result: T?) {
+        this.result = result
+        intercept()
+    }
+
+    val isResultSet: Boolean
+        get() = result != null
+}