62159
Sy
symb / files
symb / internal / tui / editor / view.go
12.7 KB
1package editor 2 3import ( 4 "fmt" 5 "strings" 6 7 "charm.land/lipgloss/v2" 8 "github.com/charmbracelet/x/ansi" 9 "github.com/xonecas/symb/internal/highlight" 10) 11 12// --------------------------------------------------------------------------- 13// View 14// --------------------------------------------------------------------------- 15 16// visualRow is a single screen row derived from a buffer line. 17type visualRow struct { 18 bufRow int // buffer line index 19 subRow int // 0 = first wrap segment, 1 = second, etc. 20 text string // plain text (expanded tabs) for this segment 21 fullHL string // full-line highlighted ANSI (shared across sub-rows) 22 segStart int // rune offset of this segment in the full line 23 segEnd int // rune end offset 24} 25 26// selRange holds pre-computed selection bounds in expanded-tab space. 27type selRange struct { 28 startRow, startExp int 29 endRow, endExp int 30} 31 32func (m Model) View() string { 33 if m.width == 0 || m.height == 0 { 34 return "" 35 } 36 if len(m.lines) == 1 && len(m.lines[0]) == 0 && m.Placeholder != "" { 37 return m.placeholderView() 38 } 39 40 tw := m.textWidth() 41 bg := m.bgForRender() 42 rows := m.buildVisualRows(tw) 43 44 cursorExpandedCol := m.cursorExpanded() 45 46 var sr *selRange 47 if m.HasSelection() { 48 ss, se := m.sel.ordered() 49 sr = &selRange{ 50 startRow: ss.row, startExp: m.bufferColToExpandedCol(ss.row, ss.col), 51 endRow: se.row, endExp: m.bufferColToExpandedCol(se.row, se.col), 52 } 53 } 54 55 lineNumSty := m.LineNumStyle.Background(bg.GetBackground()) 56 57 var b strings.Builder 58 for vi := 0; vi < m.height; vi++ { 59 if vi > 0 { 60 b.WriteByte('\n') 61 } 62 if vi >= len(rows) { 63 b.WriteString(bg.Render(strings.Repeat(" ", m.width))) 64 continue 65 } 66 vr := rows[vi] 67 68 if m.ShowLineNumbers { 69 m.renderGutter(&b, vr, lineNumSty) 70 } 71 72 rendered := m.renderSegment(vr, tw, cursorExpandedCol, sr, bg) 73 rw := lipgloss.Width(rendered) 74 if rw > tw { 75 rendered = ansi.Truncate(rendered, tw, "") 76 rw = lipgloss.Width(rendered) 77 } 78 b.WriteString(rendered) 79 if rw < tw { 80 b.WriteString(bg.Render(strings.Repeat(" ", tw-rw))) 81 } 82 } 83 return b.String() 84} 85 86// buildVisualRows computes all visible visual rows from the scroll position. 87// All visible buffer lines are highlighted as a single block so Chroma 88// maintains cross-line state (important for markdown fenced blocks, but 89// harmless and slightly fewer calls for other languages too). 90func (m Model) buildVisualRows(tw int) []visualRow { 91 hasSyntax := m.Language != "" && m.SyntaxTheme != "" 92 startBuf, startRuneOff := m.visualToBuffer(m.scroll) 93 startSubRow := 0 94 if startRuneOff > 0 && tw > 0 { 95 startSubRow = startRuneOff / tw 96 } 97 98 // First pass: collect visible buffer lines and their segments. 99 type bufLine struct { 100 idx int 101 text string 102 segments []string 103 } 104 var visible []bufLine 105 rowCount := 0 106 for bufIdx := startBuf; bufIdx < len(m.lines) && rowCount < m.height; bufIdx++ { 107 lineStr := expandTabs(string(m.lines[bufIdx])) 108 segments := wrapPlain(lineStr, tw) 109 first := 0 110 if bufIdx == startBuf { 111 first = startSubRow 112 } 113 visible = append(visible, bufLine{idx: bufIdx, text: lineStr, segments: segments}) 114 rowCount += len(segments) - first 115 } 116 117 // Highlight all visible lines as one block. 118 var hlLines []string 119 if hasSyntax && len(visible) > 0 { 120 block := make([]string, len(visible)) 121 for i, vl := range visible { 122 block[i] = vl.text 123 } 124 joined := strings.Join(block, "\n") 125 hlBlock := highlight.Highlight(joined, m.Language, m.SyntaxTheme, m.bgHexForHighlight()) 126 hlLines = highlight.SplitLines(hlBlock) 127 } 128 129 // Second pass: build visual rows with per-line HL from the block result. 130 var rows []visualRow 131 for li, vl := range visible { 132 var fullHL string 133 if li < len(hlLines) { 134 fullHL = hlLines[li] 135 } 136 137 firstSub := 0 138 if vl.idx == startBuf { 139 firstSub = startSubRow 140 } 141 runeOff := firstSub * tw 142 for subIdx := firstSub; subIdx < len(vl.segments) && len(rows) < m.height; subIdx++ { 143 segLen := len([]rune(vl.segments[subIdx])) 144 rows = append(rows, visualRow{ 145 bufRow: vl.idx, subRow: subIdx, text: vl.segments[subIdx], 146 fullHL: fullHL, segStart: runeOff, segEnd: runeOff + segLen, 147 }) 148 runeOff += segLen 149 } 150 } 151 return rows 152} 153 154// cursorExpanded returns the cursor column in expanded-tab rune space, or -1 if unfocused. 155func (m Model) cursorExpanded() int { 156 if !m.focus || m.row < 0 || m.row >= len(m.lines) { 157 return -1 158 } 159 return len([]rune(expandTabs(string(m.lines[m.row][:m.col])))) 160} 161 162// renderGutter writes the gutter (line number + marker) for one visual row. 163func (m Model) renderGutter(b *strings.Builder, vr visualRow, lineNumSty lipgloss.Style) { 164 gutSty := lineNumSty 165 digits := m.gutterWidth - 2 166 if vr.subRow == 0 { 167 numSty := gutSty 168 if sev, ok := m.DiagnosticLines[vr.bufRow]; ok { 169 switch sev { 170 case 1: 171 numSty = m.DiagErrStyle.Background(gutSty.GetBackground()) 172 case 2: 173 numSty = m.DiagWarnStyle.Background(gutSty.GetBackground()) 174 } 175 } 176 b.WriteString(numSty.Render(fmt.Sprintf("%*d ", digits, vr.bufRow+1))) 177 b.WriteString(m.renderGutterMark(vr.bufRow, gutSty)) 178 } else { 179 b.WriteString(gutSty.Render(strings.Repeat(" ", m.gutterWidth))) 180 } 181} 182 183// renderSegment produces the rendered ANSI string for one visual row's text. 184func (m Model) renderSegment(vr visualRow, tw, cursorExpandedCol int, sr *selRange, bg lipgloss.Style) string { 185 segRuneOff := vr.subRow * tw 186 segLen := len([]rune(vr.text)) 187 hasSyntax := m.Language != "" && m.SyntaxTheme != "" 188 189 // Selection intersection 190 rowHasSel, selColStart, selColEnd := m.segmentSelection(vr.bufRow, segRuneOff, segLen, sr) 191 192 isCursorHere := m.isCursorOnSegment(vr.bufRow, segRuneOff, segLen, tw, cursorExpandedCol) 193 194 if rowHasSel { 195 return m.renderSelectedSegment(vr.text, vr.fullHL, vr.segStart, segLen, 196 selColStart, selColEnd, m.SelectionStyle, bg, isCursorHere, cursorExpandedCol-segRuneOff) 197 } 198 if isCursorHere { 199 return m.renderCursorSegment(vr.text, vr.fullHL, vr.segStart, cursorExpandedCol-segRuneOff) 200 } 201 if hasSyntax && vr.fullHL != "" { 202 return ansi.Cut(vr.fullHL, vr.segStart, vr.segEnd) 203 } 204 return bg.Render(vr.text) 205} 206 207// segmentSelection computes selection column bounds for a segment. Returns (hasSel, start, end). 208func (m Model) segmentSelection(bufRow, segRuneOff, segLen int, sr *selRange) (bool, int, int) { 209 if sr == nil || bufRow < sr.startRow || bufRow > sr.endRow { 210 return false, 0, 0 211 } 212 absSelStart := 0 213 if bufRow == sr.startRow { 214 absSelStart = sr.startExp 215 } 216 absSelEnd := segRuneOff + segLen 217 if bufRow == sr.endRow { 218 absSelEnd = sr.endExp 219 } 220 localStart := absSelStart - segRuneOff 221 localEnd := absSelEnd - segRuneOff 222 if localStart < 0 { 223 localStart = 0 224 } 225 if localEnd > segLen { 226 localEnd = segLen 227 } 228 if localStart < localEnd { 229 return true, localStart, localEnd 230 } 231 return false, 0, 0 232} 233 234// isCursorOnSegment returns true if the cursor falls within this segment. 235func (m Model) isCursorOnSegment(bufRow, segRuneOff, segLen, tw, cursorExpandedCol int) bool { 236 if !m.focus || bufRow != m.row || cursorExpandedCol < 0 { 237 return false 238 } 239 if cursorExpandedCol >= segRuneOff && cursorExpandedCol < segRuneOff+tw { 240 return true 241 } 242 return cursorExpandedCol == segRuneOff+segLen && segLen < tw 243} 244 245// renderCursorSegment renders a text segment with the cursor at localCol. 246// localCol is a rune index within the segment's plain text. 247// fullHL is the full-line highlighted ANSI string; segStart is the rune offset 248// of this segment within it. Uses ansi.Cut to extract correctly-highlighted 249// before/after portions so syntax coloring is never broken. 250func (m Model) renderCursorSegment(segText, fullHL string, segStart, localCol int) string { 251 bg := m.bgForRender() 252 runes := []rune(segText) 253 254 col := localCol 255 if col > len(runes) { 256 col = len(runes) 257 } 258 259 // Extract the cursor character from the plain text. 260 cursorChar := " " 261 if col < len(runes) { 262 cursorChar = string(runes[col]) 263 } 264 265 hasSyntax := m.Language != "" && m.SyntaxTheme != "" 266 var before, after string 267 268 if hasSyntax && fullHL != "" { 269 // Cut from the full-line highlight at absolute positions. 270 absCursorCol := segStart + col 271 before = ansi.Cut(fullHL, segStart, absCursorCol) 272 after = ansi.Cut(fullHL, absCursorCol+1, segStart+len(runes)) 273 } else { 274 highlighted := bg.Render(segText) 275 before = ansi.Truncate(highlighted, col, "") 276 after = ansi.TruncateLeft(highlighted, col+1, "") 277 } 278 279 // Render cursor character 280 m.cursor.SetChar(cursorChar) 281 m.cursor.TextStyle = bg 282 m.cursor.Style = m.CursorStyle 283 cursorView := m.cursor.View() 284 285 return before + cursorView + after 286} 287 288// segRenderer holds rendering helpers for a single segment. 289type segRenderer struct { 290 runes []rune 291 fullHL string 292 segStart int 293 hasSyntax bool 294 bg lipgloss.Style 295} 296 297func (sr segRenderer) renderRange(from, to int, sty lipgloss.Style) string { 298 if from >= to { 299 return "" 300 } 301 if sr.hasSyntax && sr.fullHL != "" { 302 cut := ansi.Cut(sr.fullHL, sr.segStart+from, sr.segStart+to) 303 return sty.Render(ansi.Strip(cut)) 304 } 305 return sty.Render(string(sr.runes[from:to])) 306} 307 308func (sr segRenderer) renderNormal(from, to int) string { 309 if from >= to { 310 return "" 311 } 312 if sr.hasSyntax && sr.fullHL != "" { 313 return ansi.Cut(sr.fullHL, sr.segStart+from, sr.segStart+to) 314 } 315 return sr.bg.Render(string(sr.runes[from:to])) 316} 317 318// renderSelectedSegment renders a text segment with a selection highlight 319// (and optionally a cursor). selStart/selEnd are segment-local rune offsets. 320func (m Model) renderSelectedSegment( 321 segText, fullHL string, segStart, segLen, selStart, selEnd int, 322 selSty, bg lipgloss.Style, hasCursor bool, cursorLocalCol int, 323) string { 324 sr := segRenderer{ 325 runes: []rune(segText), fullHL: fullHL, segStart: segStart, 326 hasSyntax: m.Language != "" && m.SyntaxTheme != "", bg: bg, 327 } 328 329 if hasCursor && cursorLocalCol >= 0 && cursorLocalCol <= len(sr.runes) { 330 return m.renderSelWithCursor(sr, selStart, selEnd, selSty, cursorLocalCol) 331 } 332 333 // No cursor: simple before/selected/after 334 var sb strings.Builder 335 sb.WriteString(sr.renderNormal(0, selStart)) 336 sb.WriteString(sr.renderRange(selStart, selEnd, selSty)) 337 sb.WriteString(sr.renderNormal(selEnd, segLen)) 338 return sb.String() 339} 340 341// renderSelWithCursor handles the cursor-in-selection case. 342func (m Model) renderSelWithCursor(sr segRenderer, selStart, selEnd int, selSty lipgloss.Style, cc int) string { 343 nRunes := len(sr.runes) 344 cursorChar := " " 345 if cc < nRunes { 346 cursorChar = string(sr.runes[cc]) 347 } 348 m.cursor.SetChar(cursorChar) 349 if cc >= selStart && cc < selEnd { 350 m.cursor.TextStyle = selSty 351 } else { 352 m.cursor.TextStyle = sr.bg 353 } 354 cv := m.cursor.View() 355 356 var sb strings.Builder 357 switch { 358 case cc < selStart: 359 sb.WriteString(sr.renderNormal(0, cc)) 360 sb.WriteString(cv) 361 sb.WriteString(sr.renderNormal(cc+1, selStart)) 362 sb.WriteString(sr.renderRange(selStart, selEnd, selSty)) 363 sb.WriteString(sr.renderNormal(selEnd, nRunes)) 364 case cc >= selEnd: 365 sb.WriteString(sr.renderNormal(0, selStart)) 366 sb.WriteString(sr.renderRange(selStart, selEnd, selSty)) 367 sb.WriteString(sr.renderNormal(selEnd, cc)) 368 sb.WriteString(cv) 369 if cc+1 <= nRunes { 370 sb.WriteString(sr.renderNormal(cc+1, nRunes)) 371 } 372 default: 373 sb.WriteString(sr.renderNormal(0, selStart)) 374 if cc > selStart { 375 sb.WriteString(sr.renderRange(selStart, cc, selSty)) 376 } 377 sb.WriteString(cv) 378 if cc+1 < selEnd { 379 sb.WriteString(sr.renderRange(cc+1, selEnd, selSty)) 380 } 381 sb.WriteString(sr.renderNormal(selEnd, nRunes)) 382 } 383 return sb.String() 384} 385 386// --------------------------------------------------------------------------- 387// Placeholder view (shown when empty + unfocused) 388// --------------------------------------------------------------------------- 389 390func (m Model) placeholderView() string { 391 if m.Placeholder == "" { 392 return "" 393 } 394 bg := m.bgForRender() 395 tw := m.textWidth() 396 397 var b strings.Builder 398 // Gutter 399 if m.ShowLineNumbers { 400 lineNumSty := m.LineNumStyle.Background(bg.GetBackground()) 401 digits := m.gutterWidth - 2 // gutter = digits + space + marker 402 num := fmt.Sprintf("%*d ", digits, 1) 403 b.WriteString(lineNumSty.Render(num)) 404 b.WriteString(m.renderGutterMark(0, lineNumSty)) 405 } 406 407 // First line: cursor (if focused) then placeholder text 408 if m.focus { 409 // Render cursor on first character of placeholder 410 phRunes := []rune(m.Placeholder) 411 m.cursor.SetChar(string(phRunes[0])) 412 m.cursor.TextStyle = m.PlaceholderSty 413 m.cursor.Style = m.CursorStyle 414 b.WriteString(m.cursor.View()) 415 rest := m.PlaceholderSty.Render(string(phRunes[1:])) 416 rw := lipgloss.Width(m.cursor.View()) + lipgloss.Width(rest) 417 b.WriteString(rest) 418 if rw < tw { 419 b.WriteString(bg.Render(strings.Repeat(" ", tw-rw))) 420 } 421 } else { 422 ph := m.PlaceholderSty.Render(m.Placeholder) 423 pw := lipgloss.Width(ph) 424 b.WriteString(ph) 425 if pw < tw { 426 b.WriteString(bg.Render(strings.Repeat(" ", tw-pw))) 427 } 428 } 429 430 // Remaining rows: empty with bg 431 for vi := 1; vi < m.height; vi++ { 432 b.WriteByte('\n') 433 b.WriteString(bg.Render(strings.Repeat(" ", m.width))) 434 } 435 436 return b.String() 437}