xonecas.io
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}