@mathers101/react-native-render-rich-text 0.0.0-stage → 0.1.9

package/android/src/main/java/com/renderrichtext/spans/BlockquoteSpan.kt

@@ -0,0 +1,302 @@
+package com.renderrichtext.spans
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.graphics.Typeface
+import android.text.Layout
+import android.text.Spanned
+import android.text.TextPaint
+import android.text.style.LeadingMarginSpan
+import android.text.style.LineBackgroundSpan
+import android.text.style.MetricAffectingSpan
+import androidx.core.graphics.withSave
+import com.renderrichtext.renderer.BlockStyle
+import com.renderrichtext.renderer.SpanStyleCache
+import com.renderrichtext.styles.BlockquoteStyle
+import com.renderrichtext.utils.text.extensions.applyBlockStyleFont
+import com.renderrichtext.utils.text.extensions.applyColorPreserving
+
+class BlockquoteSpan(
+  private val blockquoteStyle: BlockquoteStyle,
+  val depth: Int,
+  private val context: Context,
+  private val styleCache: SpanStyleCache,
+) : MetricAffectingSpan(),
+  LeadingMarginSpan,
+  LineBackgroundSpan {
+  private val levelSpacing: Float = blockquoteStyle.borderWidth + blockquoteStyle.gapWidth
+  private val blockStyle =
+    BlockStyle(
+      fontSize = blockquoteStyle.fontSize,
+      fontFamily = blockquoteStyle.fontFamily,
+      fontWeight = blockquoteStyle.fontWeight,
+      color = blockquoteStyle.color,
+    )
+
+  // Cache for shouldSkipDrawing to avoid repeated getSpans() calls during draw passes
+  private var cachedText: CharSequence? = null
+  private var cachedSpansByPosition = mutableMapOf<Int, Array<BlockquoteSpan>>()
+  private var boxLeft = 0f
+  private var boxRight = 0f
+
+  private val path = Path()
+  private val rect = RectF()
+  private val radiiArray = FloatArray(8)
+
+  override fun updateMeasureState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun updateDrawState(tp: TextPaint) = applyTextStyle(tp)
+
+  override fun getLeadingMargin(first: Boolean): Int = levelSpacing.toInt()
+
+  override fun drawLeadingMargin(
+    c: Canvas,
+    p: Paint,
+    x: Int,
+    dir: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence?,
+    start: Int,
+    end: Int,
+    first: Boolean,
+    layout: Layout?,
+  ) {
+    // Essential check from original: only the deepest span draws to prevent over-rendering background
+    if (shouldSkipDrawing(text, start)) return
+
+    val borderPaint = configureBorderPaint()
+    val radius = blockquoteStyle.borderRadius
+    val spanned = text as? Spanned
+
+    if (spanned == null) {
+      drawBorders(c, x, dir, top, bottom, borderPaint)
+      return
+    }
+
+    val rootSpan = spanAtMinDepth(spanned, start)
+    val clipToRoot =
+      radius > 0f && boxRight > boxLeft && rootSpan != null && isBoundaryLine(spanned, start, end, rootSpan)
+
+    val padding = blockquoteStyle.padding
+    var topInset = 0f
+    var bottomInset = 0f
+
+    for (level in 0..depth) {
+      val borderX = x + (levelSpacing * level * dir)
+      val borderRight = borderX + (blockquoteStyle.borderWidth * dir)
+      val stripeLeft = minOf(borderX, borderRight)
+      val stripeRight = maxOf(borderX, borderRight)
+      val stripeTop = top.toFloat() + topInset
+      val stripeBottom = bottom.toFloat() - bottomInset
+
+      val levelSpan = if (level == 0) rootSpan else spanAtDepth(spanned, start, level)
+      val clipToOwn =
+        radius > 0f && level > 0 && levelSpan != null && isBoundaryLine(spanned, start, end, levelSpan)
+
+      if (!clipToRoot && !clipToOwn) {
+        c.drawRect(stripeLeft, stripeTop, stripeRight, stripeBottom, borderPaint)
+      } else {
+        c.withSave {
+          if (clipToRoot) {
+            buildBoundaryPath(spanned, start, end, rootSpan!!, boxLeft, top.toFloat(), boxRight, bottom.toFloat())
+            clipPath(path)
+          }
+          if (clipToOwn) {
+            val clipLeft = if (dir >= 0) stripeLeft else boxLeft
+            val clipRight = if (dir >= 0) boxRight else stripeRight
+            buildBoundaryPath(spanned, start, end, levelSpan!!, clipLeft, stripeTop, clipRight, stripeBottom)
+            clipPath(path)
+          }
+          drawRect(stripeLeft, stripeTop, stripeRight, stripeBottom, borderPaint)
+        }
+      }
+
+      if (padding > 0 && levelSpan != null) {
+        if (start == spanned.getSpanStart(levelSpan)) topInset += padding
+        if (isLastLineOf(spanned, end, levelSpan)) bottomInset += padding
+      }
+    }
+  }
+
+  override fun drawBackground(
+    canvas: Canvas,
+    paint: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (shouldSkipDrawing(text, start)) return
+
+    boxLeft = left.toFloat()
+    boxRight = right.toFloat()
+
+    val bgColor = blockquoteStyle.backgroundColor?.takeIf { it != Color.TRANSPARENT } ?: return
+    val backgroundPaint = configureBackgroundPaint(bgColor)
+    val radius = blockquoteStyle.borderRadius
+    val rootSpan = (text as? Spanned)?.let { spanAtMinDepth(it, start) }
+
+    if (radius <= 0f || rootSpan == null) {
+      canvas.drawRect(left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat(), backgroundPaint)
+      return
+    }
+
+    buildBoundaryPath(text as Spanned, start, end, rootSpan, left.toFloat(), top.toFloat(), right.toFloat(), bottom.toFloat())
+    canvas.drawPath(path, backgroundPaint)
+  }
+
+  private fun drawBorders(
+    c: Canvas,
+    x: Int,
+    dir: Int,
+    top: Int,
+    bottom: Int,
+    borderPaint: Paint,
+  ) {
+    val borderTop = top.toFloat()
+    val borderBottom = bottom.toFloat()
+
+    for (level in 0..depth) {
+      val borderX = x + (levelSpacing * level * dir)
+      val borderRight = borderX + (blockquoteStyle.borderWidth * dir)
+      c.drawRect(minOf(borderX, borderRight), borderTop, maxOf(borderX, borderRight), borderBottom, borderPaint)
+    }
+  }
+
+  @SuppressLint("WrongConstant") // Result of mask is always valid: 0, 1, 2, or 3
+  private fun applyTextStyle(tp: TextPaint) {
+    tp.textSize = blockStyle.fontSize
+    val preserved = (tp.typeface?.style ?: 0) and BOLD_ITALIC_MASK
+    tp.applyBlockStyleFont(blockStyle, context)
+    if (preserved != 0) {
+      tp.typeface = Typeface.create(tp.typeface ?: Typeface.DEFAULT, preserved)
+    }
+    tp.applyColorPreserving(blockStyle.color, *styleCache.colorsToPreserve)
+  }
+
+  companion object {
+    private const val BOLD_ITALIC_MASK = Typeface.BOLD or Typeface.ITALIC
+
+    private val sharedBorderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+    private val sharedBackgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+  }
+
+  private fun configureBorderPaint(): Paint =
+    sharedBorderPaint.apply {
+      color = blockquoteStyle.borderColor
+    }
+
+  private fun configureBackgroundPaint(bgColor: Int): Paint =
+    sharedBackgroundPaint.apply {
+      color = bgColor
+    }
+
+  private fun spansAt(
+    text: Spanned,
+    start: Int,
+  ): Array<BlockquoteSpan> {
+    if (cachedText !== text) {
+      cachedText = text
+      cachedSpansByPosition.clear()
+    }
+    return cachedSpansByPosition.getOrPut(start) {
+      text.getSpans(start, start + 1, BlockquoteSpan::class.java)
+    }
+  }
+
+  private fun shouldSkipDrawing(
+    text: CharSequence?,
+    start: Int,
+  ): Boolean {
+    if (text !is Spanned) return false
+    val maxDepth = spansAt(text, start).maxOfOrNull { it.depth } ?: -1
+    return maxDepth > depth
+  }
+
+  private fun spanAtMinDepth(
+    text: Spanned,
+    start: Int,
+  ): BlockquoteSpan? = spansAt(text, start).minByOrNull { it.depth }
+
+  private fun spanAtDepth(
+    text: Spanned,
+    start: Int,
+    level: Int,
+  ): BlockquoteSpan? = spansAt(text, start).firstOrNull { it.depth == level }
+
+  /**
+   * The span range can include trailing '\n'(s) that form no visible line (e.g. a
+   * paragraph break closing the quote), so the last drawn line ends before getSpanEnd;
+   * this compares against the end of visible content instead.
+   */
+  private fun isLastLineOf(
+    text: Spanned,
+    lineEnd: Int,
+    box: BlockquoteSpan,
+  ): Boolean {
+    var boxEnd = text.getSpanEnd(box)
+    while (boxEnd > 0 && text[boxEnd - 1] == '\n') {
+      boxEnd--
+    }
+    return lineEnd >= boxEnd
+  }
+
+  private fun isBoundaryLine(
+    text: Spanned,
+    lineStart: Int,
+    lineEnd: Int,
+    box: BlockquoteSpan,
+  ): Boolean {
+    val boxStart = text.getSpanStart(box)
+    val boxEnd = text.getSpanEnd(box)
+    if (boxStart !in 0 until boxEnd) return false
+    return lineStart == boxStart || isLastLineOf(text, lineEnd, box)
+  }
+
+  private fun buildBoundaryPath(
+    text: Spanned,
+    lineStart: Int,
+    lineEnd: Int,
+    box: BlockquoteSpan,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+  ) {
+    val boxStart = text.getSpanStart(box)
+
+    val isFirstLine = lineStart == boxStart
+    val isLastLine = isLastLineOf(text, lineEnd, box)
+
+    val radius = blockquoteStyle.borderRadius
+    radiiArray.fill(0f)
+    if (isFirstLine) {
+      radiiArray[0] = radius
+      radiiArray[1] = radius // Top-Left
+      radiiArray[2] = radius
+      radiiArray[3] = radius // Top-Right
+    }
+    if (isLastLine) {
+      radiiArray[4] = radius
+      radiiArray[5] = radius // Bottom-Right
+      radiiArray[6] = radius
+      radiiArray[7] = radius // Bottom-Left
+    }
+
+    rect.set(left, top, right, bottom)
+    path.reset()
+    path.addRoundRect(rect, radiiArray, Path.Direction.CW)
+  }
+}

package/android/src/main/java/com/renderrichtext/spans/CodeBackgroundSpan.kt

@@ -0,0 +1,205 @@
+package com.renderrichtext.spans
+
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.RectF
+import android.text.Spanned
+import android.text.style.LineBackgroundSpan
+import com.renderrichtext.spoiler.isConcealedBySpoiler
+import com.renderrichtext.styles.StyleConfig
+import kotlin.math.max
+import kotlin.math.min
+
+class CodeBackgroundSpan(
+  private val styleConfig: StyleConfig,
+) : LineBackgroundSpan {
+  companion object {
+    private const val CORNER_RADIUS = 10.0f
+    private const val BORDER_WIDTH = 1.0f
+
+    private val sharedBackgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply { style = Paint.Style.FILL }
+    private val sharedBorderPaint =
+      Paint(Paint.ANTI_ALIAS_FLAG).apply {
+        style = Paint.Style.STROKE
+        strokeWidth = BORDER_WIDTH
+        strokeJoin = Paint.Join.ROUND
+        strokeCap = Paint.Cap.ROUND
+      }
+  }
+
+  // Reusable drawing objects per instance
+  private val rect = RectF()
+  private val path = Path()
+
+  override fun drawBackground(
+    canvas: Canvas,
+    p: Paint,
+    left: Int,
+    right: Int,
+    top: Int,
+    baseline: Int,
+    bottom: Int,
+    text: CharSequence,
+    start: Int,
+    end: Int,
+    lineNum: Int,
+  ) {
+    if (text !is Spanned) return
+
+    val spanStart = text.getSpanStart(this)
+    val spanEnd = text.getSpanEnd(this)
+    if (spanStart !in 0 until spanEnd) return
+
+    // The spoiler overlay only covers the text's glyph box, so a background drawn to the line's bounds
+    // would outline the hidden code around it.
+    if (text.isConcealedBySpoiler(maxOf(spanStart, start), minOf(spanEnd, end))) return
+
+    // Keep CodeSpan and this background span intact for semantic extraction. Draw only
+    // portions outside replacement pills, including code surrounding a partially covered run.
+    fun drawUncoveredRange(
+      rangeStart: Int,
+      rangeEnd: Int,
+    ) {
+      if (max(rangeStart, start) >= min(rangeEnd, end)) return
+      // 1. Determine relative positioning
+      val isFirst = rangeStart >= start
+      val isLast = rangeEnd <= end
+
+      // 2. Calculate coordinates
+      val finalBottom = adjustBottomForMargin(text, end, bottom)
+      val leadingMargin = InlineBackgroundGeometry.leadingMarginAt(text, start)
+      val startX =
+        if (isFirst) {
+          InlineBackgroundGeometry.horizontalOffset(text, start, end, rangeStart, p, leadingMargin) + left
+        } else {
+          left.toFloat() + leadingMargin
+        }
+      val endX =
+        if (isLast) {
+          InlineBackgroundGeometry.horizontalOffset(text, start, end, rangeEnd, p, leadingMargin) + left
+        } else {
+          right.toFloat()
+        }
+
+      rect.set(min(startX, endX), top.toFloat(), max(startX, endX), finalBottom.toFloat())
+
+      // 3. Apply Style
+      val codeStyle = styleConfig.codeStyle
+      sharedBackgroundPaint.color = codeStyle.backgroundColor
+      sharedBorderPaint.color = codeStyle.borderColor
+
+      drawShapes(canvas, isFirst, isLast)
+    }
+
+    // Runs per code span, per line, per draw: only query for pills if the style can produce any.
+    val pills = if (styleConfig.hasLinkPills) text.getSpans(spanStart, spanEnd, LinkPillSpan::class.java) else emptyArray()
+    if (pills.isEmpty()) {
+      drawUncoveredRange(spanStart, spanEnd)
+      return
+    }
+    if (pills.size > 1) pills.sortBy { text.getSpanStart(it) }
+    var cursor = spanStart
+    for (pill in pills) {
+      val coveredStart = max(spanStart, text.getSpanStart(pill))
+      val coveredEnd = min(spanEnd, text.getSpanEnd(pill))
+      if (coveredStart >= coveredEnd) continue
+      if (cursor < coveredStart) drawUncoveredRange(cursor, coveredStart)
+      cursor = max(cursor, coveredEnd)
+    }
+    drawUncoveredRange(cursor, spanEnd)
+  }
+
+  private fun drawShapes(
+    canvas: Canvas,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val radii = createRadii(isFirst, isLast)
+
+    path.reset()
+    path.addRoundRect(rect, radii, Path.Direction.CW)
+    canvas.drawPath(path, sharedBackgroundPaint)
+
+    if (isFirst && isLast) {
+      canvas.drawPath(path, sharedBorderPaint)
+    } else {
+      drawOpenBorders(canvas, isFirst, isLast)
+    }
+  }
+
+  private fun drawOpenBorders(
+    canvas: Canvas,
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) {
+    val r = CORNER_RADIUS
+    path.reset()
+
+    if (isFirst) {
+      path.moveTo(rect.right, rect.top)
+      path.lineTo(rect.left + r, rect.top)
+      path.quadTo(rect.left, rect.top, rect.left, rect.top + r)
+      path.lineTo(rect.left, rect.bottom - r)
+      path.quadTo(rect.left, rect.bottom, rect.left + r, rect.bottom)
+      path.lineTo(rect.right, rect.bottom)
+    } else if (isLast) {
+      path.moveTo(rect.left, rect.top)
+      path.lineTo(rect.right - r, rect.top)
+      path.quadTo(rect.right, rect.top, rect.right, rect.top + r)
+      path.lineTo(rect.right, rect.bottom - r)
+      path.quadTo(rect.right, rect.bottom, rect.right - r, rect.bottom)
+      path.lineTo(rect.left, rect.bottom)
+    } else {
+      path.moveTo(rect.left, rect.top)
+      path.lineTo(rect.right, rect.top)
+      path.moveTo(rect.left, rect.bottom)
+      path.lineTo(rect.right, rect.bottom)
+    }
+    canvas.drawPath(path, sharedBorderPaint)
+  }
+
+  private fun createRadii(
+    isFirst: Boolean,
+    isLast: Boolean,
+  ) = when {
+    isFirst && isLast -> {
+      floatArrayOf(
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+        CORNER_RADIUS,
+      )
+    }
+
+    isFirst -> {
+      floatArrayOf(CORNER_RADIUS, CORNER_RADIUS, 0f, 0f, 0f, 0f, CORNER_RADIUS, CORNER_RADIUS)
+    }
+
+    isLast -> {
+      floatArrayOf(0f, 0f, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, CORNER_RADIUS, 0f, 0f)
+    }
+
+    else -> {
+      floatArrayOf(0f, 0f, 0f, 0f, 0f, 0f, 0f, 0f)
+    }
+  }
+
+  private fun adjustBottomForMargin(
+    text: Spanned,
+    lineEnd: Int,
+    bottom: Int,
+  ): Int {
+    if (lineEnd <= 0 || lineEnd > text.length || text[lineEnd - 1] != '\n') return bottom
+    val marginSpans = text.getSpans(lineEnd - 1, lineEnd, MarginBottomSpan::class.java)
+    var adjusted = bottom
+    for (span in marginSpans) {
+      if (text.getSpanEnd(span) == lineEnd) adjusted -= span.marginBottom.toInt()
+    }
+    return adjusted
+  }
+}