|
| 1 | +// SPDX-License-Identifier: GPL-3.0-or-later |
| 2 | +// SPDX-FileCopyrightText: Copyright (c) 2026 Shaan Narendran <shaannaren06@gmail.com> |
| 3 | +package com.ichi2.anki.widgets |
| 4 | + |
| 5 | +import android.content.Context |
| 6 | +import android.graphics.Canvas |
| 7 | +import android.graphics.Paint |
| 8 | +import android.graphics.Path |
| 9 | +import android.graphics.RectF |
| 10 | +import android.util.TypedValue |
| 11 | +import androidx.recyclerview.widget.RecyclerView |
| 12 | +import com.ichi2.anki.R |
| 13 | + |
| 14 | +class DeckHierarchyLinesDecoration( |
| 15 | + context: Context, |
| 16 | + private val adapter: DeckAdapter, |
| 17 | +) : RecyclerView.ItemDecoration() { |
| 18 | + private val paint = |
| 19 | + Paint(Paint.ANTI_ALIAS_FLAG).apply { |
| 20 | + style = Paint.Style.STROKE |
| 21 | + strokeCap = Paint.Cap.BUTT |
| 22 | + strokeWidth = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 2f, context.resources.displayMetrics) |
| 23 | + |
| 24 | + val typedValue = TypedValue() |
| 25 | + context.theme.resolveAttribute(com.google.android.material.R.attr.colorOnSurface, typedValue, true) |
| 26 | + color = typedValue.data |
| 27 | + alpha = 30 |
| 28 | + } |
| 29 | + |
| 30 | + private val nestedIndent = context.resources.getDimension(R.dimen.keyline_1) |
| 31 | + private val expanderCenterOffset = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 24f, context.resources.displayMetrics) |
| 32 | + private val cornerRadius = nestedIndent - TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 12f, context.resources.displayMetrics) |
| 33 | + private val reusablePath = Path() |
| 34 | + private val reusableRect = RectF() |
| 35 | + private var siblingCache = LongArray(50) |
| 36 | + |
| 37 | + override fun onDrawOver( |
| 38 | + c: Canvas, |
| 39 | + parent: RecyclerView, |
| 40 | + state: RecyclerView.State, |
| 41 | + ) { |
| 42 | + val childCount = parent.childCount |
| 43 | + if (childCount == 0) return |
| 44 | + |
| 45 | + val currentList = adapter.currentList |
| 46 | + if (currentList.isEmpty()) return |
| 47 | + |
| 48 | + if (siblingCache.size < childCount) { |
| 49 | + siblingCache = LongArray(childCount * 2) |
| 50 | + } |
| 51 | + // We use a 64-bit Long as a bitmask. Each bit index represents a depth level. |
| 52 | + // If bit 'd' is 1, it means there is a sibling further down the list at depth 'd' |
| 53 | + // so we must draw a vertical line |
| 54 | + var activeLines = 0L |
| 55 | + |
| 56 | + // Look ahead past the last visible item to find lines that continue below the screen |
| 57 | + val lastView = parent.getChildAt(childCount - 1) |
| 58 | + val maxPos = parent.getChildAdapterPosition(lastView) |
| 59 | + if (maxPos != RecyclerView.NO_POSITION && maxPos + 1 < currentList.size) { |
| 60 | + for (i in maxPos + 1 until currentList.size) { |
| 61 | + val d = currentList[i].depth |
| 62 | + if (d >= 64) continue |
| 63 | + // Mark this depth as having an active sibling by shifting a 1 into the appropriate bit |
| 64 | + activeLines = activeLines or (1L shl d) |
| 65 | + |
| 66 | + // Any node resets the active lines for all depths deeper than itself |
| 67 | + // For example, if we hit a depth 1 node, depths 2, 3, etc. are cleared |
| 68 | + // eg:- If we have a deck Math with Algebra as a subdeck and linear, abstract are below it |
| 69 | + // this ends at depth 2. If there's another child of Math say Geometry, this would be at depth 1 |
| 70 | + // If we can see this, then that means we have no more depth 2 children, using a mask allows us |
| 71 | + // to terminate the deeper sub-nodes of a parent that has no more children like in the example |
| 72 | + val mask = if (d >= 63) -1L else (1L shl (d + 1)) - 1L |
| 73 | + activeLines = activeLines and mask |
| 74 | + if (d == 0) break // Root node resets everything below it |
| 75 | + } |
| 76 | + } |
| 77 | + |
| 78 | + // Scan backwards over the visible items to record the active lines after each node |
| 79 | + for (i in childCount - 1 downTo 0) { |
| 80 | + val view = parent.getChildAt(i) |
| 81 | + val pos = parent.getChildAdapterPosition(view) |
| 82 | + if (pos == RecyclerView.NO_POSITION) { |
| 83 | + siblingCache[i] = 0L |
| 84 | + continue |
| 85 | + } |
| 86 | + |
| 87 | + // We store the bitmask we made earlier in the siblingcache for each row so that we can |
| 88 | + // know which lines need to pass through this row to reach the decks after it |
| 89 | + siblingCache[i] = activeLines |
| 90 | + |
| 91 | + // We look at the last deck that we can see and store it in d |
| 92 | + // eg:- if we have a child at the bottom of depth 2 our bits look like 0100 |
| 93 | + val d = currentList[pos].depth |
| 94 | + if (d < 64) { |
| 95 | + // We do an or with the activeLines (activelines stores the number of lines passing through |
| 96 | + // the current row) and this will give us the number of lines to draw |
| 97 | + activeLines = activeLines or (1L shl d) |
| 98 | + // We use a mask to mask off the bits for a deeper depth than what we calculated above |
| 99 | + val mask = if (d >= 63) -1L else (1L shl (d + 1)) - 1L |
| 100 | + activeLines = activeLines and mask |
| 101 | + } |
| 102 | + } |
| 103 | + |
| 104 | + // Loop to draw the lines |
| 105 | + for (i in 0 until childCount) { |
| 106 | + val view = parent.getChildAt(i) |
| 107 | + val position = parent.getChildAdapterPosition(view) |
| 108 | + if (position == RecyclerView.NO_POSITION) continue |
| 109 | + |
| 110 | + val node = currentList[position] |
| 111 | + val depth = node.depth |
| 112 | + |
| 113 | + val top = view.y |
| 114 | + val bottom = view.y + view.height |
| 115 | + val centerY = top + view.height / 2f |
| 116 | + |
| 117 | + // Helper to check the precomputed bitmask |
| 118 | + val hasSibling = { targetDepth: Int -> |
| 119 | + targetDepth < 64 && (siblingCache[i] and (1L shl targetDepth)) != 0L |
| 120 | + } |
| 121 | + |
| 122 | + for (level in 0 until depth - 1) { |
| 123 | + if (hasSibling(level + 1)) { |
| 124 | + val x = getLineX(level) |
| 125 | + c.drawLine(x, top, x, bottom, paint) |
| 126 | + } |
| 127 | + } |
| 128 | + |
| 129 | + if (depth > 0) { |
| 130 | + val level = depth - 1 |
| 131 | + val x = getLineX(level) |
| 132 | + val endX = x + cornerRadius |
| 133 | + |
| 134 | + if (hasSibling(depth)) { |
| 135 | + c.drawLine(x, top, x, bottom, paint) |
| 136 | + c.drawLine(x, centerY, endX, centerY, paint) |
| 137 | + } else { |
| 138 | + reusablePath.reset() |
| 139 | + reusablePath.moveTo(x, top) |
| 140 | + reusablePath.lineTo(x, centerY - cornerRadius) |
| 141 | + reusableRect.set(x, centerY - 2 * cornerRadius, x + 2 * cornerRadius, centerY) |
| 142 | + reusablePath.arcTo(reusableRect, 180f, -90f, false) |
| 143 | + c.drawPath(reusablePath, paint) |
| 144 | + } |
| 145 | + } |
| 146 | + |
| 147 | + if (position + 1 < currentList.size && currentList[position + 1].depth == depth + 1) { |
| 148 | + val x = getLineX(depth) |
| 149 | + val iconOffset = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 12f, view.resources.displayMetrics) |
| 150 | + c.drawLine(x, centerY + iconOffset, x, bottom, paint) |
| 151 | + } |
| 152 | + } |
| 153 | + } |
| 154 | + |
| 155 | + private fun getLineX(depth: Int): Float = depth * nestedIndent + expanderCenterOffset |
| 156 | +} |
0 commit comments