From e6d82ac482e4681581425bed0208e251cca3da3d Mon Sep 17 00:00:00 2001 From: Oliver <480930+rivo@users.noreply.github.com> Date: Fri, 5 Aug 2022 20:32:17 +0200 Subject: [PATCH] Trying to wrap up basic navigation. --- textarea.go | 268 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 248 insertions(+), 20 deletions(-) diff --git a/textarea.go b/textarea.go index e9f7f06..9a88409 100644 --- a/textarea.go +++ b/textarea.go @@ -17,6 +17,12 @@ const ( // The maximum number of bytes making up a grapheme cluster. In theory, this // could be longer but it would be highly unusual. maxGraphemeClusterSize = 40 + + // The minimum width of text (if available) to be shown left of the cursor. + minCursorPrefix = 5 + + // The minimum width of text (if available) to be shown right of the cursor. + minCursorSuffix = 3 ) var ( @@ -192,8 +198,12 @@ type TextArea struct { // The number of cells to be skipped on each line (not used in wrap mode). columnOffset int - // The inner width of the text area the last time it was drawn. - lastWidth int + // The inner height and width of the text area the last time it was drawn. + lastHeight, lastWidth int + + // The width of the currently known widest line, as determined by + // [extendLines]. + widestLine int // Text positions and states of the start of lines. Each element is a span // position (see textAreaSpan) and a state as returned by uniseg.Step(). Not @@ -214,6 +224,10 @@ type TextArea struct { // The textAreaSpan position with state for the actual next character. pos [3]int + + // If set to true, [Draw] will attempt to keep the cursor in the + // viewport. + clamp bool } } @@ -244,6 +258,7 @@ func NewTextArea(text string) *TextArea { t.spans[1].previous = 2 t.length = len(text) t.cursor.row = -1 + t.cursor.clamp = true } return t } @@ -496,10 +511,9 @@ func (t *TextArea) Draw(screen tcell.Screen) { // Make sure the visible lines are broken over. if t.lastWidth != width && t.lineStarts != nil { - t.lineStarts = t.lineStarts[:0] - t.lastWidth = width - t.cursor.row = -1 + t.resetLines() } + t.lastHeight, t.lastWidth = height, width t.extendLines(width, t.rowOffset+height) if len(t.lineStarts) <= t.rowOffset { return // It's scrolled out of view. @@ -512,7 +526,7 @@ func (t *TextArea) Draw(screen tcell.Screen) { columnOffset = 0 } updateCursor := func(row, column int, pos [3]int) { - if t.cursor.row < 0 && t.cursor.pos[0] == pos[0] && t.cursor.pos[1] == pos[1] { + if t.cursor.row < 0 && t.cursor.pos == pos { // The screen location is unknown but we've hit the span position. t.cursor.row, t.cursor.column, t.cursor.actualColumn = row, column, column t.cursor.pos = pos @@ -554,6 +568,13 @@ func (t *TextArea) Draw(screen tcell.Screen) { if cursorVisible { screen.ShowCursor(x+t.cursor.actualColumn-columnOffset, y+t.cursor.row-t.rowOffset) } else { + // Are we required to make the cursor visible? + if t.cursor.clamp { + t.cursor.clamp = false // Just one more attempt. + t.clampToCursor() + t.Draw(screen) // Draw again. + return + } screen.HideCursor() } } @@ -608,6 +629,14 @@ func (t *TextArea) drawPlaceholder(screen tcell.Screen, x, y, width, height int) }) } +// resetLines resets the [lineStarts] array so [extendLines] has to be called +// again to access text information. +func (t *TextArea) resetLines() { + t.lineStarts = t.lineStarts[:0] + t.cursor.row = -1 + t.widestLine = 0 +} + // extendLines traverses the current text and extends t.lineStarts such that it // describes at least maxLines+1 lines (or less if the text is shorter). Text is // laid out for the given width while respecting the wrapping settings. It is @@ -646,9 +675,12 @@ func (t *TextArea) extendLines(width, maxLines int) { // Any line breaks? if !t.wrap || lineWidth <= width { - if pos[0] != 1 && boundaries&uniseg.MaskLine == uniseg.LineMustBreak { + if text != "" && boundaries&uniseg.MaskLine == uniseg.LineMustBreak { // We must break over. t.lineStarts = append(t.lineStarts, pos) + if lineWidth > t.widestLine { + t.widestLine = lineWidth + } lineWidth = 0 lastGraphemeBreak = [3]int{} lastLineBreak = [3]int{} @@ -663,12 +695,18 @@ func (t *TextArea) extendLines(width, maxLines int) { if lastGraphemeBreak != [3]int{} { // We have at least one character on each line. // Break after last grapheme. t.lineStarts = append(t.lineStarts, lastGraphemeBreak) + if lineWidth > t.widestLine { + t.widestLine = lineWidth + } lineWidth = clusterWidth lastLineBreak = [3]int{} } } else { // t.wordWrap && lastLineBreak != [3]int{} // Break after last line break opportunity. t.lineStarts = append(t.lineStarts, lastLineBreak) + if lineWidth > t.widestLine { + t.widestLine = lineWidth + } lineWidth = widthSinceLineBreak lastLineBreak = [3]int{} } @@ -688,6 +726,126 @@ func (t *TextArea) extendLines(width, maxLines int) { } } +// clampToCursor ensures that the cursor is visible in the text area. +func (t *TextArea) clampToCursor() { + if t.cursor.row >= 0 { + // This is the simple case because the current cursor position is known. + if t.cursor.row < t.rowOffset { + // We're above the viewport. + t.rowOffset = t.cursor.row + } else if t.cursor.row >= t.rowOffset+t.lastHeight { + // We're below the viewport. + t.rowOffset = t.cursor.row - t.lastHeight + 1 + if t.rowOffset >= len(t.lineStarts) { + t.extendLines(t.lastWidth, t.rowOffset) + if t.rowOffset >= len(t.lineStarts) { + t.rowOffset = len(t.lineStarts) - 1 + if t.rowOffset < 0 { + t.rowOffset = 0 + } + } + } + } + if !t.wrap { + if t.cursor.actualColumn < t.columnOffset+minCursorPrefix { + // We're left of the viewport. + t.columnOffset = t.cursor.actualColumn - minCursorPrefix + if t.columnOffset < 0 { + t.columnOffset = 0 + } + } else if t.cursor.actualColumn >= t.columnOffset+t.lastWidth-minCursorSuffix { + // We're right of the viewport. + t.columnOffset = t.cursor.actualColumn - t.lastWidth + minCursorSuffix + if t.columnOffset >= t.widestLine { + t.columnOffset = t.widestLine - 1 + if t.columnOffset < 0 { + t.columnOffset = 0 + } + } + } + } + return + } + + // The screen position of the cursor is unknown. Find it. This is expensive. + // First, find the row. + row := 0 +RowLoop: + for { + // Examine the current row. + if row+1 >= len(t.lineStarts) { + t.extendLines(t.lastWidth, row+1) + } + if row >= len(t.lineStarts) { + t.cursor.row, t.cursor.actualColumn, t.cursor.pos = row, 0, [3]int{1, 0, -11} + break // It's the end of the text. + } + + // Check this row's spans to see if the cursor is in this row. + pos := t.lineStarts[row] + for pos[0] != 1 { + if row+1 >= len(t.lineStarts) { + break // It's the last row so the cursor must be in this row. + } + if t.cursor.pos[0] == pos[0] { + // The cursor is in this span. + if t.lineStarts[row+1][0] == pos[0] { + // The next row starts with the same span. + if t.cursor.pos[1] >= t.lineStarts[row+1][1] { + // The cursor is not in this row. + row++ + continue RowLoop + } else { + // The cursor is in this row. + break + } + } else { + // The next row starts with a different span. The cursor + // must be in this row. + break + } + } else { + // The cursor is in a different span. + if t.lineStarts[row+1][0] == pos[0] { + // The next row starts with the same span. This row is + // irrelevant. + row++ + continue RowLoop + } else { + // The next row starts with a different span. Move towards it. + pos = [3]int{t.spans[pos[0]].next, 0, -1} + } + } + } + + // Try to find the screen position in this row. + pos = t.lineStarts[row] + endPos := pos + column := 0 + var cluster, text string + for { + if pos[0] == 1 || t.cursor.pos[0] == pos[0] && t.cursor.pos[1] == pos[1] { + // We found the position. We're done. + t.cursor.row, t.cursor.actualColumn, t.cursor.pos = row, column, pos + break RowLoop + } + cluster, text, _, pos, endPos = t.step(text, pos, endPos) + if row+1 < len(t.lineStarts) && t.lineStarts[row+1] == pos { + // We reached the end of the line. Go to the next one. + row++ + continue RowLoop + } + clusterWidth := stringWidth(cluster) + column += clusterWidth + } + } + + if t.cursor.row >= 0 { + // We know the position now. Adapt offsets. + t.clampToCursor() + } +} + // step is similar to uniseg.StepString() but it iterates over the piece chain, // starting with "pos", a span position plus state (which may be -1 for the // start of the text). The returned "boundaries" value is same value returned by @@ -756,6 +914,7 @@ func (t *TextArea) step(text string, pos, endPos [3]int) (cluster, rest string, // row and column which are screen space coordinates relative to the top-left // corner of the text area's full text (visible or not). The column value may be // negative, in which case, the cursor will be placed at the end of the line. +// The next call to [Draw] will attempt to keep the cursor in the viewport. func (t *TextArea) moveCursor(row, column int) { // Are we within the range of rows? if len(t.lineStarts) <= row { @@ -773,7 +932,7 @@ func (t *TextArea) moveCursor(row, column int) { } // Iterate through this row until we find the position. - t.cursor.row, t.cursor.actualColumn = row, t.columnOffset + t.cursor.row, t.cursor.actualColumn = row, 0 if t.wrap { t.cursor.actualColumn = 0 } @@ -798,6 +957,7 @@ func (t *TextArea) moveCursor(row, column int) { t.cursor.column = column } t.cursor.pos = pos + t.cursor.clamp = true } // InputHandler returns the handler for this primitive. @@ -805,24 +965,92 @@ func (t *TextArea) InputHandler() func(event *tcell.EventKey, setFocus func(p Pr return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p Primitive)) { switch key := event.Key(); key { case tcell.KeyLeft: // Move one grapheme cluster to the left. - if t.cursor.actualColumn == 0 { - // Move to the end of the previous row. - if t.cursor.row > 0 { - t.moveCursor(t.cursor.row-1, -1) + if event.Modifiers()&tcell.ModAlt == 0 { + // Regular movement. + if t.cursor.actualColumn == 0 { + // Move to the end of the previous row. + if t.cursor.row > 0 { + t.moveCursor(t.cursor.row-1, -1) + } + } else { + // Move one grapheme cluster to the left. + t.moveCursor(t.cursor.row, t.cursor.actualColumn-1) + } + } else if !t.wrap { + //TODO: Maybe this should be a word jump? + // Just scroll. + t.columnOffset-- + if t.columnOffset < 0 { + t.columnOffset = 0 } - } else { - // Move one grapheme cluster to the left. - t.moveCursor(t.cursor.row, t.cursor.actualColumn-1) } case tcell.KeyRight: // Move one grapheme cluster to the right. - if t.cursor.pos[0] != 1 { - _, _, _, t.cursor.pos, _ = t.step("", t.cursor.pos, t.cursor.pos) - t.cursor.row = -1 + if event.Modifiers()&tcell.ModAlt == 0 { + // Regular movement. + if t.cursor.pos[0] != 1 { + var cluster string + cluster, _, _, t.cursor.pos, _ = t.step("", t.cursor.pos, t.cursor.pos) + if len(t.lineStarts) <= t.cursor.row+1 { + t.extendLines(t.lastWidth, t.cursor.row+1) + } + if t.cursor.row+1 < len(t.lineStarts) && t.lineStarts[t.cursor.row+1] == t.cursor.pos { + // We've reached the end of the line. + t.cursor.row++ + t.cursor.actualColumn = 0 + t.cursor.column = 0 + t.cursor.clamp = true + } else { + // Move one character to the right. + t.moveCursor(t.cursor.row, t.cursor.actualColumn+stringWidth(cluster)) + } + } + } else if !t.wrap { + //TODO: Maybe this should be a word jump? + // Just scroll. + t.columnOffset++ + if t.columnOffset >= t.widestLine { + t.columnOffset = t.widestLine - 1 + if t.columnOffset < 0 { + t.columnOffset = 0 + } + } } case tcell.KeyDown: // Move one row down. - t.moveCursor(t.cursor.row+1, t.cursor.column) + if event.Modifiers()&tcell.ModAlt == 0 { + // Regular movement. + t.moveCursor(t.cursor.row+1, t.cursor.column) + } else { + // Just scroll. + t.rowOffset++ + if t.rowOffset >= len(t.lineStarts) { + t.extendLines(t.lastWidth, t.rowOffset) + if t.rowOffset >= len(t.lineStarts) { + t.rowOffset = len(t.lineStarts) - 1 + if t.rowOffset < 0 { + t.rowOffset = 0 + } + } + } + } case tcell.KeyUp: // Move one row up. - t.moveCursor(t.cursor.row-1, t.cursor.column) + if event.Modifiers()&tcell.ModAlt == 0 { + // Regular movement. + t.moveCursor(t.cursor.row-1, t.cursor.column) + } else { + // Just scroll. + t.rowOffset-- + if t.rowOffset < 0 { + t.rowOffset = 0 + } + } + case tcell.KeyHome, tcell.KeyCtrlA: // Move to the start of the line. + t.moveCursor(t.cursor.row, 0) + case tcell.KeyEnd, tcell.KeyCtrlE: // Move to the end of the line. + t.moveCursor(t.cursor.row, -1) + case tcell.KeyPgDn, tcell.KeyCtrlF: // Move one page down. + t.moveCursor(t.cursor.row+t.lastHeight, t.cursor.column) + case tcell.KeyPgUp, tcell.KeyCtrlB: // Move one page up. + t.moveCursor(t.cursor.row-t.lastHeight, t.cursor.column) } }) }