capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/component/EditorAutoCompletion.kt

@@ -0,0 +1,300 @@
+package io.github.abc15018045126.sora.widget.component
+
+import android.annotation.SuppressLint
+import android.graphics.drawable.GradientDrawable
+import android.os.Bundle
+import android.view.View
+import android.widget.AdapterView
+import android.widget.ListAdapter
+import io.github.abc15018045126.sora.R
+import io.github.abc15018045126.sora.event.*
+import io.github.abc15018045126.sora.lang.Language
+import io.github.abc15018045126.sora.lang.completion.CompletionItem
+import io.github.abc15018045126.sora.lang.completion.CompletionPublisher
+import io.github.abc15018045126.sora.lang.completion.highlightMatchLabel
+import io.github.abc15018045126.sora.text.CharPosition
+import io.github.abc15018045126.sora.text.Content
+import io.github.abc15018045126.sora.text.ContentReference
+import io.github.abc15018045126.sora.widget.CodeEditor
+import io.github.abc15018045126.sora.widget.base.EditorPopupWindow
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+import io.github.abc15018045126.sora.widget.snippet.SnippetController
+
+/**
+ * Auto-completion component for CodeEditor.
+ *
+ * This window is displayed when the user types text and the language can provide completions.
+ */
+class EditorAutoCompletion(editor: CodeEditor) :
+    EditorPopupWindow(editor, FEATURE_SCROLL_AS_CONTENT or FEATURE_SHOW_OUTSIDE_VIEW_ALLOWED),
+    EditorBuiltinComponent {
+
+    private val eventManager = editor.createSubEventManager()
+    private var thread: CompletionThread? = null
+
+    override var isEnabled = true
+        set(value) {
+            field = value
+            eventManager.isEnabled = value
+            if (!value) {
+                dismiss()
+            }
+        }
+
+    var maxHeight: Int = (editor.dpUnit * 200).toInt()
+        set(value) {
+            field = value
+            if (isShowing) {
+                updateCompletionWindowPosition()
+            }
+        }
+
+    var adapter: EditorCompletionAdapter? = null
+        set(value) {
+            val newAdapter = value ?: DefaultCompletionItemAdapter()
+            field = newAdapter
+            newAdapter.attachValues(this, emptyList())
+            val currentLayout = layout
+            if (currentLayout != null) {
+                @Suppress("UNCHECKED_CAST")
+                (currentLayout.getCompletionList() as AdapterView<ListAdapter>).adapter = newAdapter
+            }
+        }
+
+    var layout: CompletionLayout? = null
+        set(value) {
+            val newLayout = value ?: DefaultCompletionLayout()
+            field = newLayout
+            newLayout.setEditorCompletion(this)
+            setContentView(newLayout.inflate(editor.context))
+            applyColorScheme()
+            val currentAdapter = adapter
+            if (currentAdapter != null) {
+                @Suppress("UNCHECKED_CAST")
+                (newLayout.getCompletionList() as AdapterView<ListAdapter>).adapter = currentAdapter
+            }
+        }
+
+    var currentPosition: Int = -1
+        private set
+
+    val isCompletionInProgress: Boolean
+        get() = thread != null
+
+    init {
+        adapter = DefaultCompletionItemAdapter()
+        layout = DefaultCompletionLayout()
+        popup.animationStyle = 0
+        applyColorScheme()
+        subscribeEvents()
+    }
+
+    private fun subscribeEvents() {
+        eventManager.subscribeAlways(ContentChangeEvent::class.java, this::onContentChange)
+        eventManager.subscribeAlways(ScrollEvent::class.java, this::onEditorScroll)
+        eventManager.subscribeAlways(SelectionChangeEvent::class.java, this::onSelectionChange)
+        eventManager.subscribeAlways(EditorFocusChangeEvent::class.java, this::onEditorFocusChange)
+        eventManager.subscribeAlways(EditorReleaseEvent::class.java, this::onEditorRelease)
+        eventManager.subscribeAlways(ColorSchemeUpdateEvent::class.java, this::onEditorColorChange)
+    }
+
+    private fun onEditorColorChange(event: ColorSchemeUpdateEvent) {
+        applyColorScheme()
+    }
+
+    private fun onEditorRelease(event: EditorReleaseEvent) {
+        isEnabled = false
+    }
+
+    private fun onEditorFocusChange(event: EditorFocusChangeEvent) {
+        if (!event.isGainFocus) {
+            dismiss()
+        }
+    }
+
+    private fun onEditorScroll(event: ScrollEvent) {
+        if (isShowing) {
+            updateCompletionWindowPosition()
+        }
+    }
+
+    private fun onSelectionChange(event: SelectionChangeEvent) {
+        if (isShowing && event.cause != SelectionChangeEvent.CAUSE_IME) {
+            dismiss()
+        }
+    }
+
+    private fun onContentChange(event: ContentChangeEvent) {
+        val snippetController: io.github.abc15018045126.sora.widget.snippet.SnippetController? = editor.snippetController
+        if (editor.text.isInBatchEdit || !isEnabled || snippetController?.isInSnippet() == true) {
+            return
+        }
+        val text = editor.text
+        val cursor = editor.cursor!!
+
+        if (cursor.isSelected()) {
+            dismiss()
+            return
+        }
+        
+        if (event.action == ContentChangeEvent.ACTION_DELETE) {
+            if (isShowing) {
+                updateCompletions()
+            }
+            return
+        }
+
+        if (event.action == ContentChangeEvent.ACTION_INSERT) {
+            requireCompletion()
+            return
+        }
+        
+        if (isShowing) {
+            updateCompletions()
+        }
+    }
+
+    fun requireCompletion() {
+        val cursor = editor.cursor
+        val line = cursor.leftLine
+        val col = cursor.leftColumn
+        val text = editor.text
+        
+        thread?.cancel()
+        
+        val lang = editor.editorLanguage!!
+        val publisher = CompletionPublisher(editor.handler, {
+            io.github.abc15018045126.sora.util.EditorHandler.post {
+                if (editor.isReleased) return@post
+                val currentThread = thread
+                if (currentThread != null && !currentThread.isCancelled) {
+                    onCompletionsProvided(currentThread.publisher.getItems(), false)
+                }
+            }
+
+        }, lang.interruptionLevel)
+
+        val t = CompletionThread(publisher, text, cursor.left(), lang)
+
+        thread = t
+        t.start()
+    }
+
+    @SuppressLint("NotifyDataSetChanged")
+    private fun onCompletionsProvided(items: List<CompletionItem>, results: Boolean) {
+        if (items.isEmpty()) {
+            if (results) {
+                dismiss()
+            }
+            return
+        }
+        val sorted = items.highlightMatchLabel(editor.colorScheme)
+        adapter?.attachValues(this, sorted)
+        adapter?.notifyDataSetChanged()
+        
+        if (!isShowing) {
+            show()
+        }
+        updateCompletionWindowPosition()
+    }
+
+    private fun updateCompletions() {
+        requireCompletion()
+    }
+
+    private fun applyColorScheme() {
+        val scheme = editor.colorScheme
+        val gd = GradientDrawable()
+        gd.cornerRadius = 4 * editor.dpUnit
+        gd.setColor(scheme.getColor(EditorColorScheme.COMPLETION_WND_BACKGROUND))
+        gd.setStroke((editor.dpUnit * 1).toInt(), scheme.getColor(EditorColorScheme.COMPLETION_WND_CORNER))
+        layout?.getCompletionList()?.background = gd
+    }
+
+    private fun updateCompletionWindowPosition() {
+        if (!isShowing) return
+        
+        val cursor = editor.cursor
+        val line = cursor.leftLine
+        val col = cursor.leftColumn
+        
+        val charX = editor.getCharOffsetX(line, col)
+        val charY = editor.getCharOffsetY(line, col)
+        
+        val dp = editor.dpUnit
+        val rowHeight = editor.rowHeight
+        
+        val panelX = charX
+        var panelY = charY + rowHeight
+        
+        val adapterCount = adapter?.count ?: 0
+        val itemHeight = (dp * 40).toInt()
+        val totalHeight = Math.min(maxHeight, adapterCount * itemHeight)
+        
+        if (panelY + totalHeight > editor.height) {
+            panelY = charY - totalHeight
+        }
+        
+        setSize(Math.min(editor.width, (dp * 250).toInt()), totalHeight)
+        setLocationAbsolutely(panelX, panelY)
+    }
+
+    override fun show() {
+        val snippetController: io.github.abc15018045126.sora.widget.snippet.SnippetController? = editor.snippetController
+        if (!isEnabled || snippetController?.isInSnippet() == true || !editor.hasFocus() || editor.isInMouseMode) {
+
+            return
+        }
+        super.show()
+    }
+
+    override fun dismiss() {
+        super.dismiss()
+        cancelCompletion()
+    }
+
+    fun cancelCompletion() {
+        thread?.cancel()
+        thread = null
+    }
+
+    fun hide() {
+        dismiss()
+    }
+
+    fun selectCompletion(position: Int) {
+        val item = adapter?.getItem(position) ?: return
+        selectCompletion(item)
+    }
+
+    fun selectCompletion(item: CompletionItem) {
+        val cursor = editor.cursor!!
+        item.performCompletion(editor, editor.text, cursor.left())
+        dismiss()
+    }
+
+
+    class CompletionThread(
+        val publisher: CompletionPublisher,
+        val text: Content,
+        val position: CharPosition,
+        val language: Language
+    ) : Thread() {
+        var isCancelled: Boolean = false
+            private set
+
+        fun cancel() {
+            isCancelled = true
+            publisher.cancel()
+            interrupt()
+        }
+
+        override fun run() {
+            try {
+                language.requireAutoComplete(ContentReference(text), position, publisher, Bundle.EMPTY)
+            } catch (e: Exception) {
+                // Ignore
+            }
+        }
+    }
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/component/EditorBuiltinComponent.kt

@@ -0,0 +1,15 @@
+package io.github.abc15018045126.sora.widget.component
+
+/**
+ * Builtin editor component.
+ *
+ * @author abc15018045126
+ */
+interface EditorBuiltinComponent {
+
+    /**
+     * Check/set whether this component is enabled
+     */
+    var isEnabled: Boolean
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/component/EditorCompletionAdapter.kt

@@ -0,0 +1,87 @@
+package io.github.abc15018045126.sora.widget.component
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.BaseAdapter
+import io.github.abc15018045126.sora.lang.completion.CompletionItem
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+/**
+ * A class to make custom adapter for auto-completion window
+ *
+ * @see EditorCompletionAdapter.getItemHeight
+ * @see EditorCompletionAdapter.getView
+ */
+abstract class EditorCompletionAdapter : BaseAdapter() {
+
+    protected var window: EditorAutoCompletion? = null
+    var items: List<CompletionItem>? = null
+
+    /**
+     * Called by [EditorAutoCompletion] to attach some arguments
+     */
+    fun attachValues(window: EditorAutoCompletion, items: List<CompletionItem>) {
+        this.window = window
+        this.items = items
+    }
+
+    override fun getItem(position: Int): CompletionItem {
+        return items!![position]
+    }
+
+    override fun getItemId(position: Int): Long {
+        return getItem(position).hashCode().toLong()
+    }
+
+    override fun getCount(): Int {
+        return items?.size ?: 0
+    }
+
+    override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
+        return getView(position, convertView, parent, position == window?.currentPosition)
+    }
+
+    /**
+     * Get color scheme in editor
+     */
+    protected fun getColorScheme(): EditorColorScheme {
+        return window!!.editor.colorScheme
+    }
+
+    /**
+     * Get theme color from current color scheme
+     *
+     * @param type Type of color. Refer to [EditorColorScheme]
+     * @see EditorColorScheme.getColor
+     */
+    protected fun getThemeColor(type: Int): Int {
+        return getColorScheme().getColor(type)
+    }
+
+    /**
+     * Get context from editor
+     */
+    protected fun getContext(): Context {
+        return window!!.editor.context
+    }
+
+    /**
+     * Implementation of this class should provide exact height of its item
+     *
+     * The value will be used to calculate the height of completion window
+     */
+    abstract fun getItemHeight(): Int
+
+    /**
+     * @param isCurrentCursorPosition Is the [position] currently selected
+     * @see BaseAdapter.getView
+     */
+    protected abstract fun getView(
+        position: Int,
+        convertView: View?,
+        parent: ViewGroup,
+        isCurrentCursorPosition: Boolean
+    ): View
+
+}

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/component/EditorContextMenuCreator.kt

@@ -1,26 +1,4 @@
-/*
- *    sora-editor - the awesome code editor for Android
- *    https://github.com/abc15018045126/sora-editor
- *    Copyright (C) 2020-2024  abc15018045126
- *
- *     This library is free software; you can redistribute it and/or
- *     modify it under the terms of the GNU Lesser General Public
- *     License as published by the Free Software Foundation; either
- *     version 2.1 of the License, or (at your option) any later version.
- *
- *     This library is distributed in the hope that it will be useful,
- *     but WITHOUT ANY WARRANTY; without even the implied warranty of
- *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *     Lesser General Public License for more details.
- *
- *     You should have received a copy of the GNU Lesser General Public
- *     License along with this library; if not, write to the Free Software
- *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
- *     USA
- *
- *     Please contact abc15018045126 by email 2073412493@qq.com if you need
- *     additional information or have any questions
- */
+
 package io.github.abc15018045126.sora.widget.component
 
 import android.content.Context
@@ -88,11 +66,11 @@ open class EditorContextMenuCreator(val editor: CodeEditor) : EditorBuiltinCompo
         }
     }
 
-    override fun setEnabled(enabled: Boolean) {
-        eventManager.isEnabled = enabled
-    }
-
-    override fun isEnabled() = eventManager.isEnabled
+    override var isEnabled: Boolean
+        get() = eventManager.isEnabled
+        set(value) {
+            eventManager.isEnabled = value
+        }
 
     @DslMarker
     annotation class MenuDslMarker

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/component/EditorDiagnosticTooltipWindow.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
  ******************************************************************************/
 
@@ -86,14 +86,14 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
             }
         }
 
-    override fun isEnabled() = eventManager.isEnabled
-
-    override fun setEnabled(enabled: Boolean) {
-        eventManager.isEnabled = enabled
-        if (!enabled) {
-            dismiss()
+    override var isEnabled: Boolean
+        get() = eventManager.isEnabled
+        set(value) {
+            eventManager.isEnabled = value
+            if (!value) {
+                dismiss()
+            }
         }
-    }
 
     init {
         layout = layoutImpl
@@ -143,8 +143,12 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
 
         fun postUpdate(delay: Long = ViewUtils.HOVER_TOOLTIP_SHOW_TIMEOUT) {
             editor.removeCallbacks(callback)
-            editor.postDelayedInLifecycle(callback, delay)
+            io.github.abc15018045126.sora.util.EditorHandler.postDelayed({
+                if (editor.isReleased) return@postDelayed
+                callback.run()
+            }, delay)
         }
+
         eventManager.subscribeAlways<HoverEvent> { e ->
             if (editor.isInMouseMode) {
                 fun updateLastHover() {
@@ -174,10 +178,9 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
                                 ) {
                                     updateLastHover()
                                     val pos = editor.getPointPositionOnScreen(e.x, e.y)
-                                    hoverPosition = editor.text.indexer.getCharPosition(
-                                        IntPair.getFirst(pos),
-                                        IntPair.getSecond(pos)
-                                    )
+                                    val first = IntPair.getFirst(pos)
+                                    val second = IntPair.getSecond(pos)
+                                    hoverPosition = editor.text.indexer.getCharPosition(first, second)
                                     postUpdate()
                                 }
                             } else {
@@ -239,7 +242,8 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
                     }
                 }
                 updateDiagnostic(diagnosticList[minIndex].detail, diagnosticList[minIndex], pos)
-                if (!editor.getComponent<EditorAutoCompletion>().isCompletionInProgress)
+                val completion = editor.getComponent<EditorAutoCompletion>()
+                if (completion != null && !completion.isCompletionInProgress)
                     show()
             } else {
                 updateDiagnostic(null, null, null)
@@ -255,18 +259,21 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
     }
 
     protected open fun isSelectionVisible(): Boolean {
-        val selection = editor.cursor.left()
-        editor.layout.getCharLayoutOffset(selection.line, selection.column, buffer)
+        val selection = editor.cursor!!.left()
+        val layout: io.github.abc15018045126.sora.widget.layout.Layout = editor.layout!!
+        layout.getCharLayoutOffset(selection.line, selection.column, buffer)
         return buffer[0] >= editor.offsetY && buffer[0] - editor.rowHeight <= editor.offsetY + editor.height && buffer[1] >= editor.offsetX && buffer[1] - 100f /* larger than a single character */ <= editor.offsetX + editor.width
     }
 
+
     protected open fun updateDiagnostic(diagnostic: DiagnosticDetail?, region: DiagnosticRegion?, position: CharPosition?) {
         if (!isEnabled) {
             return
         }
 
         // dismiss if completion windows is showing
-        if (editor.getComponent<EditorAutoCompletion>().isShowing) {
+        val completion = editor.getComponent<EditorAutoCompletion>()
+        if (completion != null && completion.isShowing) {
             dismiss()
             return
         }
@@ -314,7 +321,8 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
         editor.getLocationInWindow(locationBuffer)
         val restAbove = charY + locationBuffer[1]
         val restBottom = editor.height - charY - editor.rowHeight
-        val completionShowing = editor.getComponent<EditorAutoCompletion>().isShowing
+        val completion = editor.getComponent<EditorAutoCompletion>()
+        val completionShowing = completion != null && completion.isShowing
         val windowY = if (restAbove > restBottom || completionShowing) {
             charY - height
         } else {
@@ -325,8 +333,7 @@ open class EditorDiagnosticTooltipWindow(editor: CodeEditor) : EditorPopupWindow
             return
         }
         val windowX = (charX - width / 2).coerceAtLeast(0f)
-        setLocationAbsolutely(windowX.toInt(), windowY.toInt())
+        setLocationAbsolutely(windowX, windowY)
     }
 
 }
-