Use the new cellview for displaying

Syntax highlighting is still not supported when using the new cellview.
This commit is contained in:
Zachary Yedidia
2017-02-13 21:29:50 -05:00
parent 94175d1aa6
commit 712b383e2c
4 changed files with 357 additions and 322 deletions

View File

@@ -40,8 +40,8 @@ type CellView struct {
lines [][]*Char lines [][]*Char
} }
func (c *CellView) Draw(buf *Buffer, start, top, height, left, width int) { func (c *CellView) Draw(buf *Buffer, top, height, left, width int) {
tabsize := buf.Settings["tabsize"].(int) tabsize := int(buf.Settings["tabsize"].(float64))
softwrap := buf.Settings["softwrap"].(bool) softwrap := buf.Settings["softwrap"].(bool)
indentchar := []rune(buf.Settings["indentchar"].(string))[0] indentchar := []rune(buf.Settings["indentchar"].(string))[0]
@@ -61,23 +61,25 @@ func (c *CellView) Draw(buf *Buffer, start, top, height, left, width int) {
// We'll either draw the length of the line, or the width of the screen // We'll either draw the length of the line, or the width of the screen
// whichever is smaller // whichever is smaller
lineLength := min(len(line), width) lineLength := min(StringWidth(lineStr, tabsize), width)
if len(c.lines[viewLine]) != lineLength { if len(c.lines[viewLine]) != lineLength {
c.lines[viewLine] = make([]*Char, lineLength) c.lines[viewLine] = make([]*Char, lineLength)
} }
wrap := false wrap := false
// We only need to wrap if the length of the line is greater than the width of the terminal screen // We only need to wrap if the length of the line is greater than the width of the terminal screen
if softwrap && len(line) > width { if softwrap && StringWidth(lineStr, tabsize) > width {
wrap = true wrap = true
// We're going to draw the entire line now // We're going to draw the entire line now
lineLength = len(line) lineLength = StringWidth(lineStr, tabsize)
} }
for viewCol < lineLength { for viewCol < lineLength {
if colN >= len(line) {
break
}
char := line[colN] char := line[colN]
colN++
if char == '\t' { if char == '\t' {
c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, indentchar, tcell.StyleDefault} c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, indentchar, tcell.StyleDefault}
// TODO: this always adds 4 spaces but it should really add just the remainder to the next tab location // TODO: this always adds 4 spaces but it should really add just the remainder to the next tab location
@@ -89,9 +91,17 @@ func (c *CellView) Draw(buf *Buffer, start, top, height, left, width int) {
c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, tcell.StyleDefault} c.lines[viewLine][viewCol] = &Char{Loc{viewCol, viewLine}, Loc{colN, lineN}, char, tcell.StyleDefault}
viewCol++ viewCol++
} }
colN++
if wrap && viewCol > width { if wrap && viewCol >= width {
viewLine++ viewLine++
nextLine := line[colN:]
lineLength := min(StringWidth(string(nextLine), tabsize), width)
if len(c.lines[viewLine]) != lineLength {
c.lines[viewLine] = make([]*Char, lineLength)
}
viewCol = 0 viewCol = 0
// If we go too far soft wrapping we have to cut off // If we go too far soft wrapping we have to cut off

View File

@@ -201,6 +201,7 @@ func InitScreen() {
// RedrawAll redraws everything -- all the views and the messenger // RedrawAll redraws everything -- all the views and the messenger
func RedrawAll() { func RedrawAll() {
messenger.Clear() messenger.Clear()
screen.Clear()
for _, v := range tabs[curTab].views { for _, v := range tabs[curTab].views {
v.Display() v.Display()
} }

View File

@@ -2,11 +2,9 @@ package main
import ( import (
"os" "os"
"strconv"
"strings" "strings"
"time" "time"
"github.com/mattn/go-runewidth"
"github.com/mitchellh/go-homedir" "github.com/mitchellh/go-homedir"
"github.com/zyedidia/tcell" "github.com/zyedidia/tcell"
) )
@@ -91,6 +89,8 @@ type View struct {
// Syntax highlighting matches // Syntax highlighting matches
matches SyntaxMatches matches SyntaxMatches
cellview *CellView
splitNode *LeafNode splitNode *LeafNode
} }
@@ -109,6 +109,7 @@ func NewViewWidthHeight(buf *Buffer, w, h int) *View {
v.Width = w v.Width = w
v.Height = h v.Height = h
v.cellview = new(CellView)
v.ToggleTabbar() v.ToggleTabbar()
@@ -658,319 +659,319 @@ func (v *View) drawCell(x, y int, ch rune, combc []rune, style tcell.Style) {
} }
// DisplayView renders the view to the screen // DisplayView renders the view to the screen
func (v *View) DisplayView() { // func (v *View) DisplayView() {
if v.Type == vtLog { // if v.Type == vtLog {
// Log views should always follow the cursor... // // Log views should always follow the cursor...
v.Relocate() // v.Relocate()
} // }
//
if v.Buf.Settings["syntax"].(bool) { // if v.Buf.Settings["syntax"].(bool) {
v.matches = Match(v) // v.matches = Match(v)
} // }
//
// The charNum we are currently displaying // // The charNum we are currently displaying
// starts at the start of the viewport // // starts at the start of the viewport
charNum := Loc{0, v.Topline} // charNum := Loc{0, v.Topline}
//
// Convert the length of buffer to a string, and get the length of the string // // Convert the length of buffer to a string, and get the length of the string
// We are going to have to offset by that amount // // We are going to have to offset by that amount
maxLineLength := len(strconv.Itoa(v.Buf.NumLines)) // maxLineLength := len(strconv.Itoa(v.Buf.NumLines))
//
if v.Buf.Settings["ruler"] == true { // if v.Buf.Settings["ruler"] == true {
// + 1 for the little space after the line number // // + 1 for the little space after the line number
v.lineNumOffset = maxLineLength + 1 // v.lineNumOffset = maxLineLength + 1
} else { // } else {
v.lineNumOffset = 0 // v.lineNumOffset = 0
} // }
//
// We need to add to the line offset if there are gutter messages // // We need to add to the line offset if there are gutter messages
var hasGutterMessages bool // var hasGutterMessages bool
for _, v := range v.messages { // for _, v := range v.messages {
if len(v) > 0 { // if len(v) > 0 {
hasGutterMessages = true // hasGutterMessages = true
} // }
} // }
if hasGutterMessages { // if hasGutterMessages {
v.lineNumOffset += 2 // v.lineNumOffset += 2
} // }
//
if v.x != 0 { // if v.x != 0 {
// One space for the extra split divider // // One space for the extra split divider
v.lineNumOffset++ // v.lineNumOffset++
} // }
//
// These represent the current screen coordinates // // These represent the current screen coordinates
screenX, screenY := v.x, v.y-1 // screenX, screenY := v.x, v.y-1
//
highlightStyle := defStyle // highlightStyle := defStyle
curLineN := 0 // curLineN := 0
//
// ViewLine is the current line from the top of the viewport // // ViewLine is the current line from the top of the viewport
for viewLine := 0; viewLine < v.Height; viewLine++ { // for viewLine := 0; viewLine < v.Height; viewLine++ {
screenY++ // screenY++
screenX = v.x // screenX = v.x
//
// This is the current line number of the buffer that we are drawing // // This is the current line number of the buffer that we are drawing
curLineN = viewLine + v.Topline // curLineN = viewLine + v.Topline
//
if screenY-v.y >= v.Height { // if screenY-v.y >= v.Height {
break // break
} // }
//
if v.x != 0 { // if v.x != 0 {
// Draw the split divider // // Draw the split divider
v.drawCell(screenX, screenY, '|', nil, defStyle.Reverse(true)) // v.drawCell(screenX, screenY, '|', nil, defStyle.Reverse(true))
screenX++ // screenX++
} // }
//
// If the buffer is smaller than the view height we have to clear all this space // // If the buffer is smaller than the view height we have to clear all this space
if curLineN >= v.Buf.NumLines { // if curLineN >= v.Buf.NumLines {
for i := screenX; i < v.x+v.Width; i++ { // for i := screenX; i < v.x+v.Width; i++ {
v.drawCell(i, screenY, ' ', nil, defStyle) // v.drawCell(i, screenY, ' ', nil, defStyle)
} // }
//
continue // continue
} // }
line := v.Buf.Line(curLineN) // line := v.Buf.Line(curLineN)
//
// If there are gutter messages we need to display the '>>' symbol here // // If there are gutter messages we need to display the '>>' symbol here
if hasGutterMessages { // if hasGutterMessages {
// msgOnLine stores whether or not there is a gutter message on this line in particular // // msgOnLine stores whether or not there is a gutter message on this line in particular
msgOnLine := false // msgOnLine := false
for k := range v.messages { // for k := range v.messages {
for _, msg := range v.messages[k] { // for _, msg := range v.messages[k] {
if msg.lineNum == curLineN { // if msg.lineNum == curLineN {
msgOnLine = true // msgOnLine = true
gutterStyle := defStyle // gutterStyle := defStyle
switch msg.kind { // switch msg.kind {
case GutterInfo: // case GutterInfo:
if style, ok := colorscheme["gutter-info"]; ok { // if style, ok := colorscheme["gutter-info"]; ok {
gutterStyle = style // gutterStyle = style
} // }
case GutterWarning: // case GutterWarning:
if style, ok := colorscheme["gutter-warning"]; ok { // if style, ok := colorscheme["gutter-warning"]; ok {
gutterStyle = style // gutterStyle = style
} // }
case GutterError: // case GutterError:
if style, ok := colorscheme["gutter-error"]; ok { // if style, ok := colorscheme["gutter-error"]; ok {
gutterStyle = style // gutterStyle = style
} // }
} // }
v.drawCell(screenX, screenY, '>', nil, gutterStyle) // v.drawCell(screenX, screenY, '>', nil, gutterStyle)
screenX++ // screenX++
v.drawCell(screenX, screenY, '>', nil, gutterStyle) // v.drawCell(screenX, screenY, '>', nil, gutterStyle)
screenX++ // screenX++
if v.Cursor.Y == curLineN && !messenger.hasPrompt { // if v.Cursor.Y == curLineN && !messenger.hasPrompt {
messenger.Message(msg.msg) // messenger.Message(msg.msg)
messenger.gutterMessage = true // messenger.gutterMessage = true
} // }
} // }
} // }
} // }
// If there is no message on this line we just display an empty offset // // If there is no message on this line we just display an empty offset
if !msgOnLine { // if !msgOnLine {
v.drawCell(screenX, screenY, ' ', nil, defStyle) // v.drawCell(screenX, screenY, ' ', nil, defStyle)
screenX++ // screenX++
v.drawCell(screenX, screenY, ' ', nil, defStyle) // v.drawCell(screenX, screenY, ' ', nil, defStyle)
screenX++ // screenX++
if v.Cursor.Y == curLineN && messenger.gutterMessage { // if v.Cursor.Y == curLineN && messenger.gutterMessage {
messenger.Reset() // messenger.Reset()
messenger.gutterMessage = false // messenger.gutterMessage = false
} // }
} // }
} // }
//
lineNumStyle := defStyle // lineNumStyle := defStyle
if v.Buf.Settings["ruler"] == true { // if v.Buf.Settings["ruler"] == true {
// Write the line number // // Write the line number
if style, ok := colorscheme["line-number"]; ok { // if style, ok := colorscheme["line-number"]; ok {
lineNumStyle = style // lineNumStyle = style
} // }
if style, ok := colorscheme["current-line-number"]; ok { // if style, ok := colorscheme["current-line-number"]; ok {
if curLineN == v.Cursor.Y && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() { // if curLineN == v.Cursor.Y && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() {
lineNumStyle = style // lineNumStyle = style
} // }
} // }
//
lineNum := strconv.Itoa(curLineN + 1) // lineNum := strconv.Itoa(curLineN + 1)
//
// Write the spaces before the line number if necessary // // Write the spaces before the line number if necessary
for i := 0; i < maxLineLength-len(lineNum); i++ { // for i := 0; i < maxLineLength-len(lineNum); i++ {
v.drawCell(screenX, screenY, ' ', nil, lineNumStyle) // v.drawCell(screenX, screenY, ' ', nil, lineNumStyle)
screenX++ // screenX++
} // }
// Write the actual line number // // Write the actual line number
for _, ch := range lineNum { // for _, ch := range lineNum {
v.drawCell(screenX, screenY, ch, nil, lineNumStyle) // v.drawCell(screenX, screenY, ch, nil, lineNumStyle)
screenX++ // screenX++
} // }
//
// Write the extra space // // Write the extra space
v.drawCell(screenX, screenY, ' ', nil, lineNumStyle) // v.drawCell(screenX, screenY, ' ', nil, lineNumStyle)
screenX++ // screenX++
} // }
//
// Now we actually draw the line // // Now we actually draw the line
colN := 0 // colN := 0
strWidth := 0 // strWidth := 0
tabSize := int(v.Buf.Settings["tabsize"].(float64)) // tabSize := int(v.Buf.Settings["tabsize"].(float64))
for _, ch := range line { // for _, ch := range line {
if v.Buf.Settings["softwrap"].(bool) { // if v.Buf.Settings["softwrap"].(bool) {
if screenX-v.x >= v.Width { // if screenX-v.x >= v.Width {
screenY++ // screenY++
//
x := 0 // x := 0
if hasGutterMessages { // if hasGutterMessages {
v.drawCell(v.x+x, screenY, ' ', nil, defStyle) // v.drawCell(v.x+x, screenY, ' ', nil, defStyle)
x++ // x++
v.drawCell(v.x+x, screenY, ' ', nil, defStyle) // v.drawCell(v.x+x, screenY, ' ', nil, defStyle)
x++ // x++
} // }
for i := 0; i < v.lineNumOffset; i++ { // for i := 0; i < v.lineNumOffset; i++ {
screen.SetContent(v.x+i+x, screenY, ' ', nil, lineNumStyle) // screen.SetContent(v.x+i+x, screenY, ' ', nil, lineNumStyle)
} // }
screenX = v.x + v.lineNumOffset // screenX = v.x + v.lineNumOffset
} // }
} // }
//
if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN && colN == v.Cursor.X { // if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN && colN == v.Cursor.X {
v.DisplayCursor(screenX-v.leftCol, screenY) // v.DisplayCursor(screenX-v.leftCol, screenY)
} // }
//
lineStyle := defStyle // lineStyle := defStyle
//
if v.Buf.Settings["syntax"].(bool) { // if v.Buf.Settings["syntax"].(bool) {
// Syntax highlighting is enabled // // Syntax highlighting is enabled
highlightStyle = v.matches[viewLine][colN] // highlightStyle = v.matches[viewLine][colN]
} // }
//
if v.Cursor.HasSelection() && // if v.Cursor.HasSelection() &&
(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) || // (charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) { // charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
// The current character is selected // // The current character is selected
lineStyle = defStyle.Reverse(true) // lineStyle = defStyle.Reverse(true)
//
if style, ok := colorscheme["selection"]; ok { // if style, ok := colorscheme["selection"]; ok {
lineStyle = style // lineStyle = style
} // }
} else { // } else {
lineStyle = highlightStyle // lineStyle = highlightStyle
} // }
//
// We need to display the background of the linestyle with the correct color if cursorline is enabled // // We need to display the background of the linestyle with the correct color if cursorline is enabled
// and this is the current view and there is no selection on this line and the cursor is on this line // // and this is the current view and there is no selection on this line and the cursor is on this line
if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN { // if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
if style, ok := colorscheme["cursor-line"]; ok { // if style, ok := colorscheme["cursor-line"]; ok {
fg, _, _ := style.Decompose() // fg, _, _ := style.Decompose()
lineStyle = lineStyle.Background(fg) // lineStyle = lineStyle.Background(fg)
} // }
} // }
//
if ch == '\t' { // if ch == '\t' {
// If the character we are displaying is a tab, we need to do a bunch of special things // // If the character we are displaying is a tab, we need to do a bunch of special things
//
// First the user may have configured an `indent-char` to be displayed to show that this // // First the user may have configured an `indent-char` to be displayed to show that this
// is a tab character // // is a tab character
lineIndentStyle := defStyle // lineIndentStyle := defStyle
if style, ok := colorscheme["indent-char"]; ok && v.Buf.Settings["indentchar"].(string) != " " { // if style, ok := colorscheme["indent-char"]; ok && v.Buf.Settings["indentchar"].(string) != " " {
lineIndentStyle = style // lineIndentStyle = style
} // }
if v.Cursor.HasSelection() && // if v.Cursor.HasSelection() &&
(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) || // (charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) { // charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
//
lineIndentStyle = defStyle.Reverse(true) // lineIndentStyle = defStyle.Reverse(true)
//
if style, ok := colorscheme["selection"]; ok { // if style, ok := colorscheme["selection"]; ok {
lineIndentStyle = style // lineIndentStyle = style
} // }
} // }
if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN { // if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
if style, ok := colorscheme["cursor-line"]; ok { // if style, ok := colorscheme["cursor-line"]; ok {
fg, _, _ := style.Decompose() // fg, _, _ := style.Decompose()
lineIndentStyle = lineIndentStyle.Background(fg) // lineIndentStyle = lineIndentStyle.Background(fg)
} // }
} // }
// Here we get the indent char // // Here we get the indent char
indentChar := []rune(v.Buf.Settings["indentchar"].(string)) // indentChar := []rune(v.Buf.Settings["indentchar"].(string))
if screenX-v.x-v.leftCol >= v.lineNumOffset { // if screenX-v.x-v.leftCol >= v.lineNumOffset {
v.drawCell(screenX-v.leftCol, screenY, indentChar[0], nil, lineIndentStyle) // v.drawCell(screenX-v.leftCol, screenY, indentChar[0], nil, lineIndentStyle)
} // }
// Now the tab has to be displayed as a bunch of spaces // // Now the tab has to be displayed as a bunch of spaces
visLoc := strWidth // visLoc := strWidth
remainder := tabSize - (visLoc % tabSize) // remainder := tabSize - (visLoc % tabSize)
for i := 0; i < remainder-1; i++ { // for i := 0; i < remainder-1; i++ {
screenX++ // screenX++
if screenX-v.x-v.leftCol >= v.lineNumOffset { // if screenX-v.x-v.leftCol >= v.lineNumOffset {
v.drawCell(screenX-v.leftCol, screenY, ' ', nil, lineStyle) // v.drawCell(screenX-v.leftCol, screenY, ' ', nil, lineStyle)
} // }
} // }
strWidth += remainder // strWidth += remainder
} else if runewidth.RuneWidth(ch) > 1 { // } else if runewidth.RuneWidth(ch) > 1 {
if screenX-v.x-v.leftCol >= v.lineNumOffset { // if screenX-v.x-v.leftCol >= v.lineNumOffset {
v.drawCell(screenX, screenY, ch, nil, lineStyle) // v.drawCell(screenX, screenY, ch, nil, lineStyle)
} // }
for i := 0; i < runewidth.RuneWidth(ch)-1; i++ { // for i := 0; i < runewidth.RuneWidth(ch)-1; i++ {
screenX++ // screenX++
if screenX-v.x-v.leftCol >= v.lineNumOffset { // if screenX-v.x-v.leftCol >= v.lineNumOffset {
v.drawCell(screenX-v.leftCol, screenY, '<', nil, lineStyle) // v.drawCell(screenX-v.leftCol, screenY, '<', nil, lineStyle)
} // }
} // }
strWidth += StringWidth(string(ch), tabSize) // strWidth += StringWidth(string(ch), tabSize)
} else { // } else {
if screenX-v.x-v.leftCol >= v.lineNumOffset { // if screenX-v.x-v.leftCol >= v.lineNumOffset {
v.drawCell(screenX-v.leftCol, screenY, ch, nil, lineStyle) // v.drawCell(screenX-v.leftCol, screenY, ch, nil, lineStyle)
} // }
strWidth += StringWidth(string(ch), tabSize) // strWidth += StringWidth(string(ch), tabSize)
} // }
charNum = charNum.Move(1, v.Buf) // charNum = charNum.Move(1, v.Buf)
screenX++ // screenX++
colN++ // colN++
} // }
// Here we are at a newline // // Here we are at a newline
//
if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN && colN == v.Cursor.X { // if tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN && colN == v.Cursor.X {
v.DisplayCursor(screenX-v.leftCol, screenY) // v.DisplayCursor(screenX-v.leftCol, screenY)
} // }
//
// The newline may be selected, in which case we should draw the selection style // // The newline may be selected, in which case we should draw the selection style
// with a space to represent it // // with a space to represent it
if v.Cursor.HasSelection() && // if v.Cursor.HasSelection() &&
(charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) || // (charNum.GreaterEqual(v.Cursor.CurSelection[0]) && charNum.LessThan(v.Cursor.CurSelection[1]) ||
charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) { // charNum.LessThan(v.Cursor.CurSelection[0]) && charNum.GreaterEqual(v.Cursor.CurSelection[1])) {
//
selectStyle := defStyle.Reverse(true) // selectStyle := defStyle.Reverse(true)
//
if style, ok := colorscheme["selection"]; ok { // if style, ok := colorscheme["selection"]; ok {
selectStyle = style // selectStyle = style
} // }
v.drawCell(screenX, screenY, ' ', nil, selectStyle) // v.drawCell(screenX, screenY, ' ', nil, selectStyle)
screenX++ // screenX++
} // }
//
charNum = charNum.Move(1, v.Buf) // charNum = charNum.Move(1, v.Buf)
//
for i := 0; i < v.Width; i++ { // for i := 0; i < v.Width; i++ {
lineStyle := defStyle // lineStyle := defStyle
if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN { // if v.Buf.Settings["cursorline"].(bool) && tabs[curTab].CurView == v.Num && !v.Cursor.HasSelection() && v.Cursor.Y == curLineN {
if style, ok := colorscheme["cursor-line"]; ok { // if style, ok := colorscheme["cursor-line"]; ok {
fg, _, _ := style.Decompose() // fg, _, _ := style.Decompose()
lineStyle = lineStyle.Background(fg) // lineStyle = lineStyle.Background(fg)
} // }
} // }
if screenX-v.x-v.leftCol+i >= v.lineNumOffset { // if screenX-v.x-v.leftCol+i >= v.lineNumOffset {
colorcolumn := int(v.Buf.Settings["colorcolumn"].(float64)) // colorcolumn := int(v.Buf.Settings["colorcolumn"].(float64))
if colorcolumn != 0 && screenX-v.lineNumOffset+i == colorcolumn-1 { // if colorcolumn != 0 && screenX-v.lineNumOffset+i == colorcolumn-1 {
if style, ok := colorscheme["color-column"]; ok { // if style, ok := colorscheme["color-column"]; ok {
fg, _, _ := style.Decompose() // fg, _, _ := style.Decompose()
lineStyle = lineStyle.Background(fg) // lineStyle = lineStyle.Background(fg)
} // }
} // }
v.drawCell(screenX-v.leftCol+i, screenY, ' ', nil, lineStyle) // v.drawCell(screenX-v.leftCol+i, screenY, ' ', nil, lineStyle)
} // }
} // }
} // }
} // }
// DisplayCursor draws the current buffer's cursor to the screen // DisplayCursor draws the current buffer's cursor to the screen
func (v *View) DisplayCursor(x, y int) { func (v *View) DisplayCursor(x, y int) {

23
cmd/micro/view2.go Normal file
View File

@@ -0,0 +1,23 @@
package main
func (v *View) DisplayView() {
if v.Type == vtLog {
// Log views should always follow the cursor...
v.Relocate()
}
height := v.Height
width := v.Width
left := v.leftCol
top := v.Topline
v.cellview.Draw(v.Buf, top, height, left, width)
for _, line := range v.cellview.lines {
for _, char := range line {
if char != nil {
screen.SetContent(char.visualLoc.X, char.visualLoc.Y, char.char, nil, char.style)
}
}
}
}