maxrave-dev Expandable text, and tappable spans inside it
Two features that read as one and share no parts: clamping to N lines with a more/less affordance is
maxLines plus onTextLayout { hasVisualOverflow }; tappable substrings are buildAnnotatedString
plus pushStringAnnotation, hit-tested by character offset. They compete for the same tap, so
decide what a tap on the body means before writing either.
Clamping on measured overflow
Only the layout pass knows whether the text overflows — the same string wraps differently per width, font, text scale and translation. Ask it, and re-clamp by hand so the affordance is not itself truncated:
// adapted: names shortened; the source's runCatching if/else (which re-called getLineEnd on the
// success branch) folded into getOrDefault, and its Character.isWhitespace(it) into it.isWhitespace()
var isExpanded by remember { mutableStateOf(false) }
var clickable by remember { mutableStateOf(false) }
var lastCharIndex by remember { mutableIntStateOf(0) }
Box(Modifier.clickable { isExpanded = !isExpanded }) { // the only write to isExpanded
Text(
text = buildAnnotatedString {
if (clickable) {
if (isExpanded) {
append(text)
withStyle(showLessStyle) { append(showLessText) }
} else {
val adjusted = text.substring(startIndex = 0, endIndex = lastCharIndex)
.dropLast(showMoreText.length)
.dropLastWhile { it.isWhitespace() || it == '.' }
append(adjusted)
withStyle(showMoreStyle) { append(showMoreText) }
}
} else {
append(text) // no overflow: no affordance at all
}
},
maxLines = if (isExpanded) Int.MAX_VALUE else collapsedMaxLine,
result ->
if (!isExpanded && result.hasVisualOverflow) {
clickable = true
lastCharIndex = runCatching { result.getLineEnd(collapsedMaxLine - 1) }
.getOrDefault(text.length - 1)
}
},
)
}
maxLines does the visual clamp on the first frame; the string surgery only exists so the "more"
label fits inside those lines instead of being cut off with them.
Tappable spans
Tag the matches while building the string, then resolve a tap to a character offset and ask the string what is annotated there:
// adapted: tag constants named, the two per-kind branches folded into one append
val timeRegex = Regex("""(\d+):(\d+)(?::(\d+))?""")
val urlRegex = Regex("""https?://\S+""")
val combined = Regex("${timeRegex.pattern}|${urlRegex.pattern}")
// walk combined.findAll(text): append the gap before each match, then the match itself
val tag = if (timeRegex.matches(match.value)) TAG_TIME else TAG_URL
builder.withStyle(linkStyle) {
pushStringAnnotation(tag, match.value); append(match.value); pop()
}
Modifier.pointerInput(Unit) {
detectTapGestures { offset ->
val position = layoutResult?.getOffsetForPosition(offset) ?: return@detectTapGestures
annotated.getStringAnnotations(start = position, end = position)
.firstOrNull { it.tag.startsWith(TAG_PREFIX) }
?.let { onSpanClick(it.tag, it.item) }
}
}
A timestamp span carries its own raw text ("1:02:33"), so the click handler — not the text
component — decides what it means: parse it and seek, or ignore it on a screen with no player.
Traps
Overflow is a measurement, not a length. A "longer than 120 characters" heuristic is wrong at
every width but the one you tested, and again at a larger text scale. hasVisualOverflow arrives in
a layout callback: the clamp is right on frame one, the "more" label appears on the next.
The affordance has to be cut out of the string. getLineEnd(lastVisibleLine) gives the last
character that fits; appending "… more" pushes the line over and the label is what gets truncated.
Drop as many characters as the label costs, then trim trailing spaces and stops.
Latched flags outlive their text. remember { mutableStateOf(false) } with no key keeps
clickable and lastCharIndex from the previous string when the composable is reused for another
item — a short description then shows "more" and clamps at an index from a longer one. Key on text.
A line index past the last laid-out line is not valid. The callback fires for every layout the
text goes through, including ones with fewer lines than the clamp, so getLineEnd(n) needs a
guard and a fallback rather than an optimistic call.
One tap, two handlers, and the outer one loses. The container clickable in the first excerpt
is the entire expand affordance — the "more" label is painted text, not a button — so adding the
second excerpt's detectTapGestures to the same component means the text consumes the tap first:
tapping the body silently stops expanding, and only over the text. Pick one shape per component —
the whole block toggles and carries no spans, or the body owns the spans and a separate label toggles.
Hit-testing snaps to the nearest character. getOffsetForPosition returns the closest offset,
not "inside a glyph", so a tap in the blank space past the end of a line resolves onto the span that
ends it.
Build the annotated string inside remember(text). Otherwise the regex scan runs on every
recomposition — and since findAll is a lazy sequence, calling count() on it inside the loop over
its own matches re-scans the whole text once per match.
JDK character helpers are not multiplatform. Character.isWhitespace(c) compiles in shared code
only while every target is JVM-family; c.isWhitespace() is the Kotlin one and always works.
Verifying it
# every overflow-driven clamp in the codebase (a component with none is guessing at lengths)
grep -rn "hasVisualOverflow" --include="*.kt" .
# annotations written but never read, or read but never written, is a dead affordance
grep -rln "pushStringAnnotation" --include="*.kt" .
grep -rln "getStringAnnotations" --include="*.kt" .
# JDK-only character helpers sitting in shared source
find . -path "*/commonMain/*" -name "*.kt" -exec grep -ln "Character\." {} +
Then, by hand: shrink the window until a two-line string wraps to four and check that "more" appears and that the text before it still ends mid-sentence rather than mid-label; expand and collapse twice (a latched flag shows up on the second collapse); tap a link and confirm the block did not also expand.