capacitor-sora-editor 1.2.1 → 1.8.2

package/android/sora-editor/editor/src/main/java/io/github/abc15018045126/sora/widget/base/EditorPopupWindow.kt

@@ -0,0 +1,244 @@
+package io.github.abc15018045126.sora.widget.base
+
+import android.view.Gravity
+import android.view.View
+import android.widget.PopupWindow
+import io.github.abc15018045126.sora.event.EventReceiver
+import io.github.abc15018045126.sora.event.ScrollEvent
+import io.github.abc15018045126.sora.widget.CodeEditor
+import kotlin.math.abs
+
+/**
+ * Base class for all editor popup windows.
+ */
+open class EditorPopupWindow(open val editor: CodeEditor, val features: Int) {
+
+    companion object {
+        /**
+         * Update the position of this window when user scrolls the editor
+         */
+        const val FEATURE_SCROLL_AS_CONTENT = 1
+
+        /**
+         * Allow the window to be displayed outside the view's rectangle.
+         * Otherwise, the window's size will be adjusted to force it to display in the view.
+         * If the space can't display it, it will get hidden.
+         */
+        const val FEATURE_SHOW_OUTSIDE_VIEW_ALLOWED = 1 shl 1
+
+        /**
+         * Hide this window when the user scrolls fast. Such as the selection handle
+         * is currently near the edge of screen.
+         */
+        const val FEATURE_HIDE_WHEN_FAST_SCROLL = 1 shl 2
+
+        /**
+         * Dismiss the window if it covers the current caret.
+         */
+        const val FEATURE_DISMISS_WHEN_OBSCURING_CURSOR = 1 shl 3
+    }
+
+    val popup = PopupWindow()
+    private val locationBuffer = IntArray(2)
+    private val scrollListener: EventReceiver<ScrollEvent>
+    private val editorLayoutChangeListener: View.OnLayoutChangeListener
+    private var registerFlag = false
+    private var registered = false
+    private var layoutChangeListenerRegistered = false
+    private var parentView: View = editor
+    
+    private var offsetX = 0f
+    private var offsetY = 0f
+    private var windowX = 0f
+    private var windowY = 0f
+    
+    var width = 0
+        protected set
+    var height = 0
+        protected set
+
+    init {
+        popup.elevation = editor.dpUnit * 8
+        editorLayoutChangeListener = View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+            if (isShowing) {
+                applyWindowAttributes(false)
+            }
+        }
+        scrollListener = EventReceiver { event, unsubscribe ->
+            if (!registerFlag) {
+                unsubscribe.unsubscribe()
+                registered = false
+                return@EventReceiver
+            }
+            when (event.cause) {
+                ScrollEvent.CAUSE_MAKE_POSITION_VISIBLE,
+                ScrollEvent.CAUSE_TEXT_SELECTING,
+                ScrollEvent.CAUSE_USER_FLING,
+                ScrollEvent.CAUSE_SCALE_TEXT -> {
+                    if (isFeatureEnabled(FEATURE_HIDE_WHEN_FAST_SCROLL) &&
+                        (abs(event.endX - event.startX) > 80 || abs(event.endY - event.startY) > 80)
+                    ) {
+                        if (isShowing) {
+                            dismiss()
+                            return@EventReceiver
+                        }
+                    }
+                }
+            }
+            if (isFeatureEnabled(FEATURE_SCROLL_AS_CONTENT)) {
+                applyWindowAttributes(false)
+            }
+        }
+        register()
+    }
+
+    /**
+     * Checks whether a single feature is enabled
+     */
+    fun isFeatureEnabled(feature: Int): Boolean {
+        if (Integer.bitCount(feature) != 1) {
+            throw IllegalArgumentException("Not a valid feature integer")
+        }
+        return (features and feature) != 0
+    }
+
+    fun register() {
+        if (!registered) {
+            editor.subscribeEvent(ScrollEvent::class.java, scrollListener)
+            registered = true
+        }
+        if (isFeatureEnabled(FEATURE_DISMISS_WHEN_OBSCURING_CURSOR) && !layoutChangeListenerRegistered) {
+            editor.addOnLayoutChangeListener(editorLayoutChangeListener)
+            layoutChangeListenerRegistered = true
+        }
+        registerFlag = true
+    }
+
+    fun unregister() {
+        registerFlag = false
+        if (layoutChangeListenerRegistered) {
+            editor.removeOnLayoutChangeListener(editorLayoutChangeListener)
+            layoutChangeListenerRegistered = false
+        }
+    }
+
+    open val isShowing: Boolean
+        get() = popup.isShowing
+
+    /**
+     * @see [PopupWindow.setContentView]
+     */
+    open fun setContentView(view: View) {
+        popup.contentView = view
+    }
+
+    private fun wrapHorizontal(horizontal: Float): Float = 
+        horizontal.coerceIn(0f, editor.width.toFloat())
+
+    private fun wrapVertical(vertical: Float): Float = 
+        vertical.coerceIn(0f, editor.height.toFloat())
+
+    private fun applyWindowAttributes(show: Boolean) {
+        if (!show && !isShowing) {
+            return
+        }
+        val autoScroll = isFeatureEnabled(FEATURE_SCROLL_AS_CONTENT)
+        var left = if (autoScroll) (windowX - editor.offsetX) else (windowX - offsetX)
+        var top = if (autoScroll) (windowY - editor.offsetY) else (windowY - offsetY)
+        var right = left + width
+        var bottom = top + height
+        
+        if (!isFeatureEnabled(FEATURE_SHOW_OUTSIDE_VIEW_ALLOWED)) {
+            val finalLeft = wrapHorizontal(left)
+            val finalRight = wrapHorizontal(right)
+            val finalTop = wrapVertical(top)
+            val finalBottom = wrapVertical(bottom)
+            
+            if (finalTop >= finalBottom || finalLeft >= finalRight) {
+                dismiss()
+                return
+            }
+            left = finalLeft
+            right = finalRight
+            top = finalTop
+            bottom = finalBottom
+        }
+        
+        if (isCursorObscured(left, top, right, bottom)) {
+            dismiss()
+            return
+        }
+        
+        editor.getLocationInWindow(locationBuffer)
+        val w = (right - left).toInt()
+        val h = (bottom - top).toInt()
+        val finalX = (left + locationBuffer[0]).toInt()
+        val finalY = (top + locationBuffer[1]).toInt()
+        
+        if (popup.isShowing) {
+            popup.update(finalX, finalY, w, h)
+        } else if (show) {
+            popup.width = w
+            popup.height = h
+            popup.showAtLocation(parentView, Gravity.START or Gravity.TOP, finalX, finalY)
+        }
+    }
+
+    open fun setSize(width: Int, height: Int) {
+        this.width = width
+        this.height = height
+        applyWindowAttributes(false)
+    }
+
+    open fun setLocation(x: Float, y: Float) {
+        windowX = x
+        windowY = y
+        offsetY = editor.offsetY.toFloat()
+        offsetX = editor.offsetX.toFloat()
+        applyWindowAttributes(false)
+    }
+
+    open fun setLocationAbsolutely(x: Float, y: Float) {
+        setLocation(x + editor.offsetX, y + editor.offsetY)
+    }
+
+    private fun isCursorObscured(left: Float, top: Float, right: Float, bottom: Float): Boolean {
+        if (!isFeatureEnabled(FEATURE_DISMISS_WHEN_OBSCURING_CURSOR)) {
+            return false
+        }
+        return try {
+            val cursor = editor.cursor ?: return false
+            val line = cursor.leftLine
+            val column = cursor.leftColumn
+            val cursorLeft = editor.getCharOffsetX(line, column)
+            val cursorTop = editor.getCharOffsetY(line, column)
+            if (cursorLeft.isNaN() || cursorTop.isNaN()) {
+                return false
+            }
+            val cursorRight = cursorLeft + Math.max(1f, editor.insertSelectionWidth)
+            val cursorBottom = cursorTop + editor.rowHeight
+            cursorLeft < right && cursorRight > left && cursorTop < bottom && cursorBottom > top
+        } catch (ignored: Throwable) {
+            false
+        }
+    }
+
+    open fun show() {
+        if (isShowing) {
+            return
+        }
+        applyWindowAttributes(true)
+    }
+
+    open fun dismiss() {
+        if (isShowing) {
+            popup.dismiss()
+        }
+    }
+
+    fun getParentView(): View = parentView
+
+    fun setParentView(view: View) {
+        parentView = view
+    }
+}

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

@@ -0,0 +1,59 @@
+package io.github.abc15018045126.sora.widget.component
+
+import android.content.Context
+import android.view.View
+import android.widget.AdapterView
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+/**
+ * Manages layout of [EditorAutoCompletion]
+ * Can be set by [EditorAutoCompletion.setLayout]
+ *
+ * The implementation of this class must call [EditorAutoCompletion.select] to select the
+ * item in completion list when the user clicks one.
+ */
+interface CompletionLayout {
+
+    /**
+     * Color scheme changed
+     */
+    fun onApplyColorScheme(colorScheme: EditorColorScheme)
+
+    /**
+     * Attach the [EditorAutoCompletion].
+     * This is called first before other methods are called.
+     */
+    fun setEditorCompletion(completion: EditorAutoCompletion)
+
+    /**
+     * Inflate the layout, return the view root.
+     */
+    fun inflate(context: Context): View
+
+    /**
+     * Get the [AdapterView] to display completion items
+     */
+    fun getCompletionList(): AdapterView<*>
+
+    /**
+     * Set loading state.
+     * You may update your layout to show other contents
+     */
+    fun setLoading(loading: Boolean)
+
+    /**
+     * Make the given position visible
+     *
+     * @param position        Item index
+     * @param incrementPixels If you scroll the layout, this is a recommended value of each scroll. [EditorCompletionAdapter.getItemHeight]
+     */
+    fun ensureListPositionVisible(position: Int, incrementPixels: Int)
+
+    /**
+     * Some layout may support to display more animations,
+     * this method provides control over the animation of the layout.
+     */
+    fun setEnabledAnimation(enabledAnimation: Boolean) {
+        //ignore
+    }
+}

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

@@ -0,0 +1,60 @@
+package io.github.abc15018045126.sora.widget.component
+
+import android.util.TypedValue
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ImageView
+import android.widget.TextView
+import io.github.abc15018045126.sora.R
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+/**
+ * Default adapter to display results
+ *
+ * @author Rose
+ */
+class DefaultCompletionItemAdapter : EditorCompletionAdapter() {
+
+    override fun getItemHeight(): Int {
+        // 45 dp
+        return TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            45f,
+            getContext().resources.displayMetrics
+        ).toInt()
+    }
+
+    override fun getView(
+        pos: Int,
+        view: View?,
+        parent: ViewGroup,
+        isCurrentCursorPosition: Boolean
+    ): View {
+        var convertView = view
+        if (convertView == null) {
+            convertView = LayoutInflater.from(getContext())
+                .inflate(R.layout.default_completion_result_item, parent, false)
+        }
+        val item = getItem(pos)
+
+        val tvLabel = convertView!!.findViewById<TextView>(R.id.result_item_label)
+        tvLabel.text = item.label
+        tvLabel.setTextColor(getThemeColor(EditorColorScheme.COMPLETION_WND_TEXT_PRIMARY))
+
+        val tvDesc = convertView.findViewById<TextView>(R.id.result_item_desc)
+        tvDesc.text = item.desc
+        tvDesc.setTextColor(getThemeColor(EditorColorScheme.COMPLETION_WND_TEXT_SECONDARY))
+
+        convertView.tag = pos
+        if (isCurrentCursorPosition) {
+            convertView.setBackgroundColor(getThemeColor(EditorColorScheme.COMPLETION_WND_ITEM_CURRENT))
+        } else {
+            convertView.setBackgroundColor(0)
+        }
+        val iv = convertView.findViewById<ImageView>(R.id.result_item_image)
+        iv.setImageDrawable(item.icon)
+        return convertView
+    }
+
+}

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

@@ -0,0 +1,225 @@
+package io.github.abc15018045126.sora.widget.component
+
+import android.animation.LayoutTransition
+import android.content.Context
+import android.graphics.Outline
+import android.graphics.drawable.GradientDrawable
+import android.os.SystemClock
+import android.util.TypedValue
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewOutlineProvider
+import android.widget.LinearLayout
+import android.widget.ListView
+import android.widget.ProgressBar
+import android.widget.Toast
+import io.github.abc15018045126.sora.widget.schemes.EditorColorScheme
+
+class DefaultCompletionLayout : CompletionLayout {
+
+    private lateinit var listView: ListView
+    private lateinit var progressBar: ProgressBar
+    private lateinit var rootView: LinearLayout
+    private var editorAutoCompletion: EditorAutoCompletion? = null
+
+    override fun setEditorCompletion(completion: EditorAutoCompletion) {
+        editorAutoCompletion = completion
+    }
+
+    override fun setEnabledAnimation(enabledAnimation: Boolean) {
+        if (enabledAnimation) {
+            val transition = LayoutTransition()
+            transition.enableTransitionType(LayoutTransition.CHANGING)
+            transition.enableTransitionType(LayoutTransition.APPEARING)
+            transition.enableTransitionType(LayoutTransition.DISAPPEARING)
+            transition.enableTransitionType(LayoutTransition.CHANGE_APPEARING)
+            transition.enableTransitionType(LayoutTransition.CHANGE_DISAPPEARING)
+            transition.addTransitionListener(object : LayoutTransition.TransitionListener {
+                override fun startTransition(
+                    transition: LayoutTransition,
+                    container: ViewGroup,
+                    view: View,
+                    transitionType: Int
+                ) {
+                }
+
+                override fun endTransition(
+                    transition: LayoutTransition,
+                    container: ViewGroup,
+                    view: View,
+                    transitionType: Int
+                ) {
+                    if (view !== listView) {
+                        return
+                    }
+                    view.requestLayout()
+                }
+            })
+            rootView.layoutTransition = transition
+            listView.layoutTransition = transition
+        } else {
+            rootView.layoutTransition = null
+            listView.layoutTransition = null
+        }
+    }
+
+    override fun inflate(context: Context): View {
+        val rootLayout = LinearLayout(context)
+        rootView = rootLayout
+        listView = ListView(context)
+        progressBar = ProgressBar(context, null, android.R.attr.progressBarStyleHorizontal)
+
+        rootLayout.orientation = LinearLayout.VERTICAL
+
+        setEnabledAnimation(false)
+
+        rootLayout.addView(
+            progressBar,
+            LinearLayout.LayoutParams(
+                -1,
+                TypedValue.applyDimension(
+                    TypedValue.COMPLEX_UNIT_DIP,
+                    20f,
+                    context.resources.displayMetrics
+                ).toInt()
+            )
+        )
+        rootLayout.addView(listView, LinearLayout.LayoutParams(-1, -1))
+
+        progressBar.isIndeterminate = true
+        val progressBarLayoutParams = progressBar.layoutParams as LinearLayout.LayoutParams
+
+        progressBarLayoutParams.topMargin = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            -8f,
+            context.resources.displayMetrics
+        ).toInt()
+        progressBarLayoutParams.bottomMargin = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            -8f,
+            context.resources.displayMetrics
+        ).toInt()
+        progressBarLayoutParams.leftMargin = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            4f,
+            context.resources.displayMetrics
+        ).toInt()
+        progressBarLayoutParams.rightMargin = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            4f,
+            context.resources.displayMetrics
+        ).toInt()
+
+        val gd = GradientDrawable()
+        gd.cornerRadius = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            8f,
+            context.resources.displayMetrics
+        )
+
+        rootLayout.background = gd
+
+        setRootViewOutlineProvider(rootView)
+
+        listView.dividerHeight = 0
+        setLoading(true)
+
+        listView.setOnItemClickListener { _, _, position, _ ->
+            try {
+                editorAutoCompletion?.selectCompletion(position)
+            } catch (e: Exception) {
+                e.printStackTrace(System.err)
+                Toast.makeText(context, e.toString(), Toast.LENGTH_SHORT).show()
+            }
+        }
+
+
+        return rootLayout
+    }
+
+    override fun onApplyColorScheme(colorScheme: EditorColorScheme) {
+        val gd = GradientDrawable()
+        val context = editorAutoCompletion!!.editor.context
+        gd.cornerRadius = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            8f,
+            context.resources.displayMetrics
+        )
+        gd.setStroke(
+            TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP,
+                1f,
+                context.resources.displayMetrics
+            ).toInt(),
+            colorScheme.getColor(EditorColorScheme.COMPLETION_WND_CORNER)
+        )
+        gd.setColor(colorScheme.getColor(EditorColorScheme.COMPLETION_WND_BACKGROUND))
+        rootView.background = gd
+
+        setRootViewOutlineProvider(rootView)
+    }
+
+    override fun setLoading(loading: Boolean) {
+        progressBar.visibility = if (loading) View.VISIBLE else View.GONE
+    }
+
+    override fun getCompletionList(): ListView {
+        return listView
+    }
+
+    /**
+     * Perform motion events
+     */
+    private fun performScrollList(offset: Int) {
+        val adpView = getCompletionList()
+
+        val down = SystemClock.uptimeMillis()
+        var ev = MotionEvent.obtain(down, down, MotionEvent.ACTION_DOWN, 0f, 0f, 0)
+        adpView.onTouchEvent(ev)
+        ev.recycle()
+
+        ev = MotionEvent.obtain(down, down, MotionEvent.ACTION_MOVE, 0f, offset.toFloat(), 0)
+        adpView.onTouchEvent(ev)
+        ev.recycle()
+
+        ev = MotionEvent.obtain(down, down, MotionEvent.ACTION_CANCEL, 0f, offset.toFloat(), 0)
+        adpView.onTouchEvent(ev)
+        ev.recycle()
+    }
+
+    private fun setRootViewOutlineProvider(rootView: View) {
+        rootView.outlineProvider = object : ViewOutlineProvider() {
+            override fun getOutline(view: View, outline: Outline) {
+                outline.setRoundRect(
+                    0,
+                    0,
+                    view.width,
+                    view.height,
+                    TypedValue.applyDimension(
+                        TypedValue.COMPLEX_UNIT_DIP,
+                        8f,
+                        view.context.resources.displayMetrics
+                    )
+                )
+            }
+        }
+        rootView.clipToOutline = true
+    }
+
+    override fun ensureListPositionVisible(position: Int, increment: Int) {
+        listView.post {
+            // Used for reset scroll position
+            if (position == 0 && increment == 0) {
+                listView.setSelectionFromTop(0, 0)
+                return@post
+            }
+            while (listView.firstVisiblePosition + 1 > position && listView.canScrollList(-1)) {
+                performScrollList(increment / 2)
+            }
+            while (listView.lastVisiblePosition - 1 < position && listView.canScrollList(1)) {
+                performScrollList(-increment / 2)
+            }
+        }
+    }
+}