Merge

[micro.git] / internal / display / bufwindow.go

diff --git a/internal/display/bufwindow.go b/internal/display/bufwindow.go
index ea57541617e4033cbe2aedd493d66665c0fcb330..afc2663db81db005153a32c11395ad0cc3afdce5 100644 (file)
--- a/internal/display/bufwindow.go
+++ b/internal/display/bufwindow.go
@@ -4,12 +4,12 @@ import (
        "strconv"
        "unicode/utf8"
 
-       "github.com/zyedidia/tcell"
        runewidth "github.com/mattn/go-runewidth"
        "github.com/zyedidia/micro/internal/buffer"
        "github.com/zyedidia/micro/internal/config"
        "github.com/zyedidia/micro/internal/screen"
        "github.com/zyedidia/micro/internal/util"
+       "github.com/zyedidia/tcell"
 )
 
 // The BufWindow provides a way of displaying a certain section
@@ -102,7 +102,7 @@ func (w *BufWindow) getStartInfo(n, lineN int) ([]byte, int, int, *tcell.Style)
 func (w *BufWindow) Clear() {
        for y := 0; y < w.Height; y++ {
                for x := 0; x < w.Width; x++ {
-                       screen.Screen.SetContent(w.X+x, w.Y+y, ' ', nil, config.DefStyle)
+                       screen.SetContent(w.X+x, w.Y+y, ' ', nil, config.DefStyle)
                }
        }
 }
@@ -188,6 +188,11 @@ func (w *BufWindow) LocFromVisual(svloc buffer.Loc) buffer.Loc {
                bufHeight--
        }
 
+       bufWidth := w.Width
+       if w.Buf.Settings["scrollbar"].(bool) && w.Buf.LinesNum() > w.Height {
+               bufWidth--
+       }
+
        // We need to know the string length of the largest line number
        // so we can pad appropriately when displaying line numbers
        maxLineNumLength := len(strconv.Itoa(b.LinesNum()))
@@ -259,7 +264,7 @@ func (w *BufWindow) LocFromVisual(svloc buffer.Loc) buffer.Loc {
                        totalwidth += width
 
                        // If we reach the end of the window then we either stop or we wrap for softwrap
-                       if vloc.X >= w.Width {
+                       if vloc.X >= bufWidth {
                                if !softwrap {
                                        break
                                } else {
@@ -269,7 +274,9 @@ func (w *BufWindow) LocFromVisual(svloc buffer.Loc) buffer.Loc {
                                        }
                                        vloc.X = 0
                                        // This will draw an empty line number because the current line is wrapped
-                                       vloc.X += maxLineNumLength + 1
+                                       if b.Settings["ruler"].(bool) {
+                                               vloc.X += maxLineNumLength + 1
+                                       }
                                }
                        }
                }
@@ -298,9 +305,9 @@ func (w *BufWindow) drawGutter(vloc *buffer.Loc, bloc *buffer.Loc) {
                        break
                }
        }
-       screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, char, nil, s)
+       screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, char, nil, s)
        vloc.X++
-       screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, char, nil, s)
+       screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, char, nil, s)
        vloc.X++
 }
 
@@ -309,21 +316,21 @@ func (w *BufWindow) drawLineNum(lineNumStyle tcell.Style, softwrapped bool, maxL
 
        // Write the spaces before the line number if necessary
        for i := 0; i < maxLineNumLength-len(lineNum); i++ {
-               screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
+               screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
                vloc.X++
        }
        // Write the actual line number
        for _, ch := range lineNum {
                if softwrapped {
-                       screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
+                       screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
                } else {
-                       screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ch, nil, lineNumStyle)
+                       screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ch, nil, lineNumStyle)
                }
                vloc.X++
        }
 
        // Write the extra space
-       screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
+       screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, ' ', nil, lineNumStyle)
        vloc.X++
 }
 
@@ -340,10 +347,9 @@ func (w *BufWindow) getStyle(style tcell.Style, bloc buffer.Loc, r rune) (tcell.
 func (w *BufWindow) showCursor(x, y int, main bool) {
        if w.active {
                if main {
-                       screen.Screen.ShowCursor(x, y)
+                       screen.ShowCursor(x, y)
                } else {
-                       r, _, _, _ := screen.Screen.GetContent(x, y)
-                       screen.Screen.SetContent(x, y, r, nil, config.DefStyle.Reverse(true))
+                       screen.ShowFakeCursorMulti(x, y)
                }
        }
 }
@@ -352,6 +358,10 @@ func (w *BufWindow) showCursor(x, y int, main bool) {
 func (w *BufWindow) displayBuffer() {
        b := w.Buf
 
+       if w.Height <= 0 || w.Width <= 0 {
+               return
+       }
+
        hasMessage := len(b.Messages) > 0
        bufHeight := w.Height
        if w.drawStatus {
@@ -364,17 +374,14 @@ func (w *BufWindow) displayBuffer() {
        }
 
        if b.Settings["syntax"].(bool) && b.SyntaxDef != nil {
-               for _, c := range b.GetCursors() {
-                       // rehighlight starting from where the cursor is
-                       start := c.Y
-                       if start > 0 && b.Rehighlight(start-1) {
-                               b.Highlighter.ReHighlightLine(b, start-1)
-                               b.SetRehighlight(start-1, false)
+               for _, r := range b.Modifications {
+                       final := -1
+                       for i := r.X; i <= r.Y; i++ {
+                               final = util.Max(b.Highlighter.ReHighlightStates(b, i), final)
                        }
-
-                       b.Highlighter.ReHighlightStates(b, start)
-                       b.Highlighter.HighlightMatches(b, w.StartLine, w.StartLine+bufHeight)
+                       b.Highlighter.HighlightMatches(b, r.X, final+1)
                }
+               b.ClearModifications()
        }
 
        var matchingBraces []buffer.Loc
@@ -409,7 +416,11 @@ func (w *BufWindow) displayBuffer() {
        }
        curNumStyle := config.DefStyle
        if style, ok := config.Colorscheme["current-line-number"]; ok {
-               curNumStyle = style
+               if !b.Settings["cursorline"].(bool) {
+                       curNumStyle = lineNumStyle
+               } else {
+                       curNumStyle = style
+               }
        }
 
        // We need to know the string length of the largest line number
@@ -514,7 +525,7 @@ func (w *BufWindow) displayBuffer() {
                                        }
                                }
 
-                               screen.Screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, nil, style)
+                               screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, nil, style)
 
                                if showcursor {
                                        for _, c := range cursors {
@@ -569,7 +580,9 @@ func (w *BufWindow) displayBuffer() {
                                        }
                                        vloc.X = 0
                                        // This will draw an empty line number because the current line is wrapped
-                                       w.drawLineNum(lineNumStyle, true, maxLineNumLength, &vloc, &bloc)
+                                       if b.Settings["ruler"].(bool) {
+                                               w.drawLineNum(lineNumStyle, true, maxLineNumLength, &vloc, &bloc)
+                                       }
                                }
                        }
                }
@@ -592,17 +605,13 @@ func (w *BufWindow) displayBuffer() {
                                        curStyle = style.Background(fg)
                                }
                        }
-                       screen.Screen.SetContent(i+w.X, vloc.Y+w.Y, ' ', nil, curStyle)
+                       screen.SetContent(i+w.X, vloc.Y+w.Y, ' ', nil, curStyle)
                }
 
-               for _, c := range cursors {
-                       if c.X == bloc.X && c.Y == bloc.Y && !c.HasSelection() {
-                               w.showCursor(w.X+vloc.X, w.Y+vloc.Y, c.Num == 0)
-                       }
+               if vloc.X != bufWidth {
+                       draw(' ', curStyle, true)
                }
 
-               draw(' ', curStyle, false)
-
                bloc.X = w.StartCol
                bloc.Y++
                if bloc.Y >= b.LinesNum() {
@@ -624,7 +633,7 @@ func (w *BufWindow) displayStatusLine() {
        } else if w.Y+w.Height != infoY {
                w.drawStatus = true
                for x := w.X; x < w.X+w.Width; x++ {
-                       screen.Screen.SetContent(x, w.Y+w.Height-1, '-', nil, config.DefStyle.Reverse(true))
+                       screen.SetContent(x, w.Y+w.Height-1, '-', nil, config.DefStyle.Reverse(true))
                }
        } else {
                w.drawStatus = false
@@ -644,7 +653,7 @@ func (w *BufWindow) displayScrollBar() {
                }
                barstart := w.Y + int(float64(w.StartLine)/float64(w.Buf.LinesNum())*float64(w.Height))
                for y := barstart; y < util.Min(barstart+barsize, w.Y+bufHeight); y++ {
-                       screen.Screen.SetContent(scrollX, y, '|', nil, config.DefStyle.Reverse(true))
+                       screen.SetContent(scrollX, y, '|', nil, config.DefStyle.Reverse(true))
                }
        }
 }