@apollohg/react-native-rich-text-editor 2.0.0

package/android/src/main/java/com/apollohg/editor/EditorStyleSheetSpans.kt

@@ -0,0 +1,253 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.os.Build
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.LineHeightSpan
+import android.text.style.MetricAffectingSpan
+
+internal class EditorResolvedTextSpan(val style: EditorTextStyle, private val density: Float) :
+    MetricAffectingSpan() {
+    val lineHeightPx: Int? get() = style.lineHeight?.times(density)?.toInt()
+
+    override fun updateMeasureState(paint: TextPaint) {
+        style.fontSize?.let { paint.textSize = it * density }
+        val family =
+            style.fontFamily?.let { Typeface.create(it, Typeface.NORMAL) } ?: paint.typeface
+                ?: Typeface.DEFAULT
+        paint.typeface = if (Build.VERSION.SDK_INT >= 28) {
+            Typeface.create(
+                family,
+                style.fontWeight?.toIntOrNull() ?: if (style.fontWeight ==
+                    "bold"
+                ) {
+                    700
+                } else {
+                    400
+                },
+                style.fontStyle == "italic"
+            )
+        } else {
+            Typeface.create(family, style.typefaceStyle())
+        }
+        style.letterSpacing?.let { paint.letterSpacing = it * density / paint.textSize }
+    }
+
+    override fun updateDrawState(paint: TextPaint) {
+        updateMeasureState(paint)
+        style.color?.let { paint.color = it }
+        style.backgroundColor?.let { paint.bgColor = it }
+        style.textDecorationLine?.let {
+            paint.isUnderlineText = it.contains("underline") && !style.hasCustomDecoration()
+            paint.isStrikeThruText = it.contains("line-through") && !style.hasCustomDecoration()
+        }
+    }
+}
+
+internal class EditorBlockBoxSpan(
+    val box: EditorBoxStyle,
+    val ancestorInset: EditorEdges,
+    val depth: Int,
+    val nodeType: String? = null,
+    val marginForCollapsing: EditorEdges = box.margin
+) : LeadingMarginSpan {
+    override fun getLeadingMargin(first: Boolean): Int = box.outerInset.left.toInt()
+    override fun drawLeadingMargin(
+        canvas: Canvas,
+        paint: Paint,
+        x: Int,
+        dir: Int,
+        top: Int,
+        baseline: Int,
+        bottom: Int,
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        first: Boolean,
+        layout: Layout?
+    ) = Unit
+    fun chooseHeight(
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        spanstartv: Int,
+        v: Int,
+        fm: Paint.FontMetricsInt
+    ) {
+        val spanned = text as? Spanned ?: return
+        if (start <= spanned.getSpanStart(this)) {
+            fm.ascent -= box.outerInset.top.toInt()
+            fm.top = fm.ascent
+        }
+        if (end >= spanned.getSpanEnd(this)) {
+            fm.descent += box.outerInset.bottom.toInt()
+            fm.bottom = fm.descent
+        }
+    }
+
+    fun bounds(layout: Layout, text: Spanned): RectF? {
+        if (layout is EditorDocumentLayout) return layout.boxBounds(this)
+        val start = text.getSpanStart(this)
+        val end = text.getSpanEnd(this)
+        if (start < 0 || end <= start) return null
+        val first = layout.getLineForOffset(start)
+        val last = layout.getLineForOffset((end - 1).coerceAtMost(text.length - 1))
+        val ancestors = text.getSpans(start, end, EditorBlockBoxSpan::class.java).filter {
+            it.depth <
+                depth &&
+                text.getSpanStart(it) <= start &&
+                text.getSpanEnd(it) >= end
+        }
+        val topInset = ancestors.filter {
+            layout.getLineForOffset(text.getSpanStart(it)) == first
+        }.sumOf { it.box.outerInset.top.toDouble() }.toFloat()
+        val bottomInset = ancestors.filter {
+            layout.getLineForOffset(text.getSpanEnd(it) - 1) ==
+                last
+        }.sumOf { it.box.outerInset.bottom.toDouble() }.toFloat()
+        return RectF(
+            ancestorInset.left + box.margin.left,
+            layout.getLineTop(first) + topInset + box.margin.top,
+            layout.width - ancestorInset.right - box.margin.right,
+            layout.getLineBottom(last) - bottomInset - box.margin.bottom
+        )
+    }
+}
+
+internal class EditorStyledLineMetricsSpan : LineHeightSpan.WithDensity {
+    override fun chooseHeight(
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        spanstartv: Int,
+        v: Int,
+        fm: Paint.FontMetricsInt
+    ) = Unit
+
+    override fun chooseHeight(
+        text: CharSequence,
+        start: Int,
+        end: Int,
+        spanstartv: Int,
+        v: Int,
+        fm: Paint.FontMetricsInt,
+        paint: TextPaint
+    ) {
+        val content = text as? Spanned ?: return
+        var cursor = start
+        var ascent = 0
+        var descent = 0
+        var targetHeight = 0
+        while (cursor < end) {
+            val runEnd = content.nextSpanTransition(cursor, end, MetricAffectingSpan::class.java)
+            val runPaint = TextPaint(paint)
+            val spans = content.getSpans(cursor, runEnd, MetricAffectingSpan::class.java)
+            spans.forEach { it.updateMeasureState(runPaint) }
+            val metrics = runPaint.fontMetricsInt
+            spans.filterIsInstance<android.text.style.ReplacementSpan>().lastOrNull()?.getSize(
+                runPaint,
+                text,
+                cursor,
+                runEnd,
+                metrics
+            )
+            ascent = minOf(ascent, metrics.ascent)
+            descent = maxOf(descent, metrics.descent)
+            spans.filterIsInstance<EditorResolvedTextSpan>().forEach {
+                targetHeight =
+                    maxOf(targetHeight, it.lineHeightPx ?: 0)
+            }
+            cursor = runEnd
+        }
+        if (ascent == 0 && descent == 0) return
+        val extra = (targetHeight - (descent - ascent)).coerceAtLeast(0)
+        fm.ascent = ascent - extra / 2
+        fm.descent = descent + extra - extra / 2
+        fm.top = fm.ascent
+        fm.bottom = fm.descent
+        content.getSpans(start, end, EditorBlockBoxSpan::class.java).forEach {
+            it.chooseHeight(text, start, end, spanstartv, v, fm)
+        }
+    }
+}
+
+internal fun android.text.SpannableStringBuilder.applyStyleSheetLineMetrics() {
+    getSpans(0, length, Any::class.java).filter {
+        (
+            it is EditorBlockBoxSpan || it is EditorResolvedTextSpan ||
+                it is EditorParagraphAlignmentSpan
+            ) &&
+            getSpanStart(it) == getSpanEnd(it)
+    }.forEach { setSpan(it, getSpanStart(it), getSpanEnd(it), Spanned.SPAN_INCLUSIVE_INCLUSIVE) }
+    getSpans(0, length, FixedLineHeightSpan::class.java).forEach(::removeSpan)
+    setSpan(
+        EditorStyledLineMetricsSpan(),
+        0,
+        length,
+        if (isEmpty()) Spanned.SPAN_INCLUSIVE_INCLUSIVE else Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+    )
+}
+
+internal fun android.text.Spannable.applyPhysicalTextAlignment(
+    alignment: String,
+    start: Int = 0,
+    end: Int = length
+) {
+    setSpan(
+        EditorParagraphAlignmentSpan(alignment),
+        start,
+        end,
+        if (start ==
+            end
+        ) {
+            Spanned.SPAN_MARK_MARK
+        } else {
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        }
+    )
+    var paragraphStart = start
+    while (paragraphStart < end) {
+        val nextBreak = android.text.TextUtils.indexOf(this, '\n', paragraphStart, end)
+        val paragraphEnd = if (nextBreak < 0) end else nextBreak + 1
+        val rtl = android.text.TextDirectionHeuristics.FIRSTSTRONG_LTR.isRtl(
+            this,
+            paragraphStart,
+            paragraphEnd - paragraphStart
+        )
+        val resolved = when (alignment) {
+            "center" -> Layout.Alignment.ALIGN_CENTER
+            "left" -> if (rtl) Layout.Alignment.ALIGN_OPPOSITE else Layout.Alignment.ALIGN_NORMAL
+            "right" -> if (rtl) Layout.Alignment.ALIGN_NORMAL else Layout.Alignment.ALIGN_OPPOSITE
+            else -> Layout.Alignment.ALIGN_NORMAL
+        }
+        setSpan(
+            android.text.style.AlignmentSpan.Standard(resolved),
+            paragraphStart,
+            paragraphEnd,
+            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE
+        )
+        paragraphStart = paragraphEnd
+    }
+}
+
+internal fun EditorEditText.drawStyleSheetBoxes(canvas: Canvas) {
+    val content = text as? Spanned ?: return
+    val textLayout = layout ?: return
+    if (textLayout is EditorDocumentLayout) return
+    val saved = canvas.save()
+    canvas.translate(compoundPaddingLeft.toFloat(), extendedPaddingTop.toFloat())
+    content.getSpans(0, content.length, EditorBlockBoxSpan::class.java).sortedBy {
+        it.depth
+    }.forEach {
+        it.bounds(textLayout, content)?.let { bounds ->
+            EditorBoxDrawing.draw(canvas, bounds, it.box)
+        }
+    }
+    canvas.restoreToCount(saved)
+}

package/android/src/main/java/com/apollohg/editor/EditorSurfaceInputConnection.kt

@@ -0,0 +1,67 @@
+package com.apollohg.editor
+
+import android.os.Handler
+import android.text.Editable
+import android.view.KeyEvent
+import android.view.inputmethod.BaseInputConnection
+import android.view.inputmethod.CorrectionInfo
+import android.view.inputmethod.InputConnection
+
+internal class EditorSurfaceInputConnection(private val surface: EditorTextSurface) :
+    BaseInputConnection(surface, true) {
+    private var closed = false
+    private var batchDepth = 0
+
+    override fun getEditable(): Editable? = if (closed) null else surface.editableText
+
+    override fun beginBatchEdit(): Boolean {
+        if (closed) return false
+        batchDepth++
+        return surface.beginBatchEdit()
+    }
+
+    override fun endBatchEdit(): Boolean {
+        if (batchDepth == 0) return false
+        batchDepth--
+        surface.endBatchEdit()
+        return batchDepth > 0
+    }
+
+    override fun sendKeyEvent(event: KeyEvent): Boolean = !closed && surface.dispatchKeyEvent(event)
+
+    override fun performContextMenuAction(id: Int): Boolean =
+        !closed && surface.onTextContextMenuItem(id)
+
+    override fun commitCorrection(correctionInfo: CorrectionInfo?): Boolean = !closed
+
+    override fun requestCursorUpdates(cursorUpdateMode: Int): Boolean {
+        val modes = InputConnection.CURSOR_UPDATE_IMMEDIATE or InputConnection.CURSOR_UPDATE_MONITOR
+        return requestSurfaceCursorUpdates(
+            cursorUpdateMode and modes,
+            cursorUpdateMode and modes.inv()
+        )
+    }
+
+    override fun requestCursorUpdates(cursorUpdateMode: Int, cursorUpdateFilter: Int): Boolean =
+        requestSurfaceCursorUpdates(cursorUpdateMode, cursorUpdateFilter)
+
+    private fun requestSurfaceCursorUpdates(
+        cursorUpdateMode: Int,
+        cursorUpdateFilter: Int
+    ): Boolean {
+        val supported =
+            InputConnection.CURSOR_UPDATE_FILTER_INSERTION_MARKER or
+                InputConnection.CURSOR_UPDATE_FILTER_CHARACTER_BOUNDS
+        if (closed || cursorUpdateFilter and supported.inv() != 0) return false
+        return surface.requestSurfaceCursorUpdates(cursorUpdateMode)
+    }
+
+    override fun getHandler(): Handler? = surface.handler
+
+    override fun closeConnection() {
+        if (closed) return
+        closed = true
+        while (batchDepth > 0) endBatchEdit()
+        super.closeConnection()
+    }
+}

package/android/src/main/java/com/apollohg/editor/EditorTextDecorationDrawing.kt

@@ -0,0 +1,143 @@
+package com.apollohg.editor
+
+import android.graphics.Canvas
+import android.graphics.DashPathEffect
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.PathMeasure
+import android.graphics.RectF
+import android.text.Layout
+import android.text.Spanned
+
+internal object EditorTextDecorationDrawing {
+    fun drawRun(
+        canvas: Canvas,
+        source: android.text.TextPaint,
+        style: EditorTextStyle,
+        left: Float,
+        right: Float,
+        baseline: Float
+    ) {
+        if (!style.hasCustomDecoration()) return
+        val paint = android.text.TextPaint(source).apply {
+            color = style.textDecorationColor ?: style.color ?: source.color
+            this.style = Paint.Style.STROKE
+            strokeWidth = maxOf(1f, textSize / 16f)
+            pathEffect = when (style.textDecorationStyle) {
+                "dotted" -> DashPathEffect(floatArrayOf(strokeWidth, strokeWidth * 1.5f), 0f)
+                "dashed" -> DashPathEffect(floatArrayOf(strokeWidth * 3f, strokeWidth * 2f), 0f)
+                else -> null
+            }
+        }
+        fun stroke(y: Float) {
+            canvas.drawLine(left, y, right, y, paint)
+            if (style.textDecorationStyle ==
+                "double"
+            ) {
+                canvas.drawLine(
+                    left,
+                    y + paint.strokeWidth * 2f,
+                    right,
+                    y + paint.strokeWidth * 2f,
+                    paint
+                )
+            }
+        }
+        if (style.textDecorationLine?.contains("underline") ==
+            true
+        ) {
+            stroke(baseline + maxOf(paint.strokeWidth, paint.fontMetrics.descent * .5f))
+        }
+        if (style.textDecorationLine?.contains("line-through") ==
+            true
+        ) {
+            stroke(baseline + paint.fontMetrics.ascent * .35f)
+        }
+    }
+
+    fun draw(canvas: Canvas, layout: Layout) {
+        val text = layout.text as? Spanned ?: return
+        text.getSpans(0, text.length, EditorResolvedTextSpan::class.java).forEach { span ->
+            val style = span.style
+            if (!style.hasCustomDecoration()) return@forEach
+            val start = text.getSpanStart(span).coerceAtLeast(0)
+            val end = text.getSpanEnd(span).coerceAtMost(text.length)
+            if (end <= start) return@forEach
+            val paint = android.text.TextPaint(layout.paint)
+            span.updateMeasureState(paint)
+            paint.color = style.textDecorationColor ?: style.color ?: layout.paint.color
+            paint.style = Paint.Style.STROKE
+            paint.strokeWidth = maxOf(1f, paint.textSize / 16f)
+            paint.pathEffect = when (style.textDecorationStyle) {
+                "dotted" -> DashPathEffect(
+                    floatArrayOf(paint.strokeWidth, paint.strokeWidth * 1.5f),
+                    0f
+                )
+
+                "dashed" -> DashPathEffect(
+                    floatArrayOf(
+                        paint.strokeWidth * 3f,
+                        paint.strokeWidth * 2f
+                    ),
+                    0f
+                )
+
+                else -> null
+            }
+            for (line in layout.getLineForOffset(start)..layout.getLineForOffset(end - 1)) {
+                val a = maxOf(start, layout.getLineStart(line))
+                var b = minOf(end, layout.getLineEnd(line))
+                if (b > a && text[b - 1] == '\n') b--
+                if (b <= a) continue
+                val selection = Path()
+                layout.getSelectionPath(a, b, selection)
+                val measure = PathMeasure(selection, false)
+                do {
+                    val contour = Path()
+                    measure.getSegment(0f, measure.length, contour, true)
+                    val bounds = RectF()
+                    contour.computeBounds(bounds, true)
+                    if (bounds.width() > 0) {
+                        val baseline = layout.getLineBaseline(line).toFloat()
+                        fun stroke(y: Float) {
+                            canvas.drawLine(bounds.left, y, bounds.right, y, paint)
+                            if (style.textDecorationStyle ==
+                                "double"
+                            ) {
+                                canvas.drawLine(
+                                    bounds.left,
+                                    y + paint.strokeWidth * 2f,
+                                    bounds.right,
+                                    y + paint.strokeWidth * 2f,
+                                    paint
+                                )
+                            }
+                        }
+                        if (style.textDecorationLine?.contains("underline") ==
+                            true
+                        ) {
+                            stroke(
+                                baseline + maxOf(
+                                    paint.strokeWidth,
+                                    paint.fontMetrics.descent * .5f
+                                )
+                            )
+                        }
+                        if (style.textDecorationLine?.contains("line-through") ==
+                            true
+                        ) {
+                            stroke(baseline + paint.fontMetrics.ascent * .35f)
+                        }
+                    }
+                } while (measure.nextContour())
+            }
+        }
+    }
+}
+
+internal fun EditorTextStyle.hasCustomDecoration(): Boolean =
+    textDecorationLine != null && textDecorationLine != "none" &&
+        (
+            textDecorationColor != null ||
+                (textDecorationStyle != null && textDecorationStyle != "solid")
+            )