Merge branch 'MoreCharOptions' into dev

Author: Neko-Box-Coder

internal/display/bufwindow.go

@@ -453,28 +453,26 @@ func (w *BufWindow) displayBuffer() {
 
 	curStyle := config.DefStyle
 
-	// Parse showchars which is in the format of option1=val1,option2=val2,...
+	// Parse showchars which is in the format of key1=val1,key2=val2,...
 	spacechars := " "
 	tabchars := b.Settings["indentchar"].(string)
-	indentspacechars := " "
-	indenttabchars := b.Settings["indentchar"].(string)
-
-	charsentries := strings.Split(b.Settings["showchars"].(string), ",")
-	for _, entry := range charsentries {
-		if !strings.Contains(entry, "=") {
+	var indentspacechars string
+	var indenttabchars string
+	for _, entry := range strings.Split(b.Settings["showchars"].(string), ",") {
+		split := strings.SplitN(entry, "=", 2)
+		if len(split) < 2 {
 			continue
 		}
-		entrykey := strings.Split(entry, "=")[0]
-		entryval := strings.Split(entry, "=")[1]
-		switch entrykey {
+		key, val := split[0], split[1]
+		switch key {
 		case "space":
-			spacechars = entryval
+			spacechars = val
 		case "tab":
-			tabchars = entryval
+			tabchars = val
 		case "ispace":
-			indentspacechars = entryval
+			indentspacechars = val
 		case "itab":
-			indenttabchars = entryval
+			indenttabchars = val
 		}
 	}
 
@@ -522,149 +520,171 @@ func (w *BufWindow) displayBuffer() {
 		}
 		bloc.X = bslice
 
-		draw := func(r rune, showoffset int, combc []rune, isplaceholder bool, style tcell.Style, highlight bool, showcursor bool) {
-			if nColsBeforeStart <= 0 && vloc.Y >= 0 {
-				if highlight {
-					if w.Buf.HighlightSearch && w.Buf.SearchMatch(bloc) {
-						style = config.DefStyle.Reverse(true)
-						if s, ok := config.Colorscheme["hlsearch"]; ok {
-							style = s
+		// returns the rune to be drawn, style of it and if the bg should be preserved
+		getRuneStyle := func(r rune, style tcell.Style, showoffset int, linex int, isplaceholder bool) (rune, tcell.Style, bool) {
+			if nColsBeforeStart > 0 || vloc.Y < 0 || isplaceholder {
+				return r, style, false
+			}
+
+			for _, mb := range matchingBraces {
+				if mb.X == bloc.X && mb.Y == bloc.Y {
+					if b.Settings["matchbracestyle"].(string) == "highlight" {
+						if s, ok := config.Colorscheme["match-brace"]; ok {
+							return r, s, false
+						} else {
+							return r, style.Reverse(true), false
 						}
+					} else {
+						return r, style.Underline(true), false
 					}
+				}
+			}
 
-					_, origBg, _ := style.Decompose()
-					_, defBg, _ := config.DefStyle.Decompose()
-
-					// syntax or hlsearch highlighting with non-default background takes precedence
-					// over cursor-line and color-column
-					dontOverrideBackground := origBg != defBg
-
-					if b.Settings["hltaberrors"].(bool) {
-						if s, ok := config.Colorscheme["tab-error"]; ok {
-							isTab := (r == '\t') || (r == ' ' && !showcursor)
-							if (b.Settings["tabstospaces"].(bool) && isTab) ||
-								(!b.Settings["tabstospaces"].(bool) && bloc.X < leadingwsEnd && r == ' ' && !isTab) {
-								fg, _, _ := s.Decompose()
-								style = style.Background(fg)
-								dontOverrideBackground = true
-							}
-						}
+			if r != '\t' && r != ' ' {
+				return r, style, false
+			}
+
+			var indentrunes []rune
+			switch r {
+			case '\t':
+				if bloc.X < leadingwsEnd && indenttabchars != "" {
+					indentrunes = []rune(indenttabchars)
+				} else {
+					indentrunes = []rune(tabchars)
+				}
+			case ' ':
+				if linex%tabsize == 0 && bloc.X < leadingwsEnd && indentspacechars != "" {
+					indentrunes = []rune(indentspacechars)
+				} else {
+					indentrunes = []rune(spacechars)
+				}
+			}
+
+			var drawrune rune
+			if showoffset < len(indentrunes) {
+				drawrune = indentrunes[showoffset]
+			} else {
+				// use space if no showchars or after we showed showchars
+				drawrune = ' '
+			}
+
+			if s, ok := config.Colorscheme["indent-char"]; ok {
+				fg, _, _ := s.Decompose()
+				style = style.Foreground(fg)
+			}
+
+			preservebg := false
+			if b.Settings["hltaberrors"].(bool) && bloc.X < leadingwsEnd {
+				if s, ok := config.Colorscheme["tab-error"]; ok {
+					if b.Settings["tabstospaces"].(bool) && r == '\t' {
+						fg, _, _ := s.Decompose()
+						style = style.Background(fg)
+						preservebg = true
+					} else if !b.Settings["tabstospaces"].(bool) && r == ' ' {
+						fg, _, _ := s.Decompose()
+						style = style.Background(fg)
+						preservebg = true
 					}
+				}
+			}
 
-					if b.Settings["hltrailingws"].(bool) {
-						if s, ok := config.Colorscheme["trailingws"]; ok {
-							if bloc.X >= trailingwsStart && bloc.X < blineLen {
-								hl := true
-								for _, c := range cursors {
-									if c.NewTrailingWsY == bloc.Y {
-										hl = false
-										break
-									}
-								}
-								if hl {
-									fg, _, _ := s.Decompose()
-									style = style.Background(fg)
-									dontOverrideBackground = true
-								}
+			if b.Settings["hltrailingws"].(bool) {
+				if s, ok := config.Colorscheme["trailingws"]; ok {
+					if bloc.X >= trailingwsStart && bloc.X < blineLen {
+						hl := true
+						for _, c := range cursors {
+							if c.NewTrailingWsY == bloc.Y {
+								hl = false
+								break
 							}
 						}
+						if hl {
+							fg, _, _ := s.Decompose()
+							style = style.Background(fg)
+							preservebg = true
+						}
 					}
+				}
+			}
 
-					for _, c := range cursors {
-						if c.HasSelection() &&
-							(bloc.GreaterEqual(c.CurSelection[0]) && bloc.LessThan(c.CurSelection[1]) ||
-								bloc.LessThan(c.CurSelection[0]) && bloc.GreaterEqual(c.CurSelection[1])) {
-							// The current character is selected
-							style = config.DefStyle.Reverse(true)
+			return drawrune, style, preservebg
+		}
 
-							if s, ok := config.Colorscheme["selection"]; ok {
-								style = s
-							}
-						}
+		draw := func(r rune, combc []rune, style tcell.Style, highlight bool, showcursor bool, preservebg bool) {
+			defer func() {
+				if nColsBeforeStart <= 0 {
+					vloc.X++
+				}
+				nColsBeforeStart--
+			}()
 
-						if b.Settings["cursorline"].(bool) && w.active && !dontOverrideBackground &&
-							!c.HasSelection() && c.Y == bloc.Y {
-							if s, ok := config.Colorscheme["cursor-line"]; ok {
-								fg, _, _ := s.Decompose()
-								style = style.Background(fg)
-							}
-						}
-					}
+			if nColsBeforeStart > 0 || vloc.Y < 0 {
+				return
+			}
 
-					for _, m := range b.Messages {
-						if bloc.GreaterEqual(m.Start) && bloc.LessThan(m.End) ||
-							bloc.LessThan(m.End) && bloc.GreaterEqual(m.Start) {
-							style = style.Underline(true)
-							break
-						}
+			if highlight {
+				if w.Buf.HighlightSearch && w.Buf.SearchMatch(bloc) {
+					style = config.DefStyle.Reverse(true)
+					if s, ok := config.Colorscheme["hlsearch"]; ok {
+						style = s
 					}
+				}
 
-					if (r == '\t' || r == ' ') && !isplaceholder {
-						var indentrunes []rune
-						switch r {
-						case '\t':
-							if bloc.X < leadingwsEnd && !b.Settings["tabstospaces"].(bool) {
-								indentrunes = []rune(indenttabchars)
-							} else {
-								indentrunes = []rune(tabchars)
-							}
-						case ' ':
-							if bloc.X%tabsize == 0 && bloc.X < leadingwsEnd && b.Settings["tabstospaces"].(bool) {
-								indentrunes = []rune(indentspacechars)
-							} else {
-								indentrunes = []rune(spacechars)
-							}
-						}
+				_, origBg, _ := style.Decompose()
+				_, defBg, _ := config.DefStyle.Decompose()
 
-						if showoffset < len(indentrunes) {
-							r = indentrunes[showoffset]
-						} else {
-							// use space if no showchars or after we showed showchars
-							r = ' '
-						}
+				// syntax or hlsearch highlighting with non-default background takes precedence
+				// over cursor-line and color-column
+				if !preservebg && origBg != defBg {
+					preservebg = true
+				}
 
-						if s, ok := config.Colorscheme["indent-char"]; ok && r != ' ' {
-							fg, _, _ := s.Decompose()
-							style = style.Foreground(fg)
+				for _, c := range cursors {
+					if c.HasSelection() &&
+						(bloc.GreaterEqual(c.CurSelection[0]) && bloc.LessThan(c.CurSelection[1]) ||
+							bloc.LessThan(c.CurSelection[0]) && bloc.GreaterEqual(c.CurSelection[1])) {
+						// The current character is selected
+						style = config.DefStyle.Reverse(true)
+
+						if s, ok := config.Colorscheme["selection"]; ok {
+							style = s
 						}
 					}
 
-					if s, ok := config.Colorscheme["color-column"]; ok {
-						if colorcolumn != 0 && vloc.X-w.gutterOffset+w.StartCol == colorcolumn && !dontOverrideBackground {
+					if b.Settings["cursorline"].(bool) && w.active && !preservebg &&
+						!c.HasSelection() && c.Y == bloc.Y {
+						if s, ok := config.Colorscheme["cursor-line"]; ok {
 							fg, _, _ := s.Decompose()
 							style = style.Background(fg)
 						}
 					}
+				}
 
-					for _, mb := range matchingBraces {
-						if mb.X == bloc.X && mb.Y == bloc.Y {
-							if b.Settings["matchbracestyle"].(string) == "highlight" {
-								if s, ok := config.Colorscheme["match-brace"]; ok {
-									style = s
-								} else {
-									style = style.Reverse(true)
-								}
-							} else {
-								style = style.Underline(true)
-							}
-						}
+				for _, m := range b.Messages {
+					if bloc.GreaterEqual(m.Start) && bloc.LessThan(m.End) ||
+						bloc.LessThan(m.End) && bloc.GreaterEqual(m.Start) {
+						style = style.Underline(true)
+						break
 					}
 				}
 
-				screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, combc, style)
-
-				if showcursor {
-					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 s, ok := config.Colorscheme["color-column"]; ok {
+					if colorcolumn != 0 && vloc.X-w.gutterOffset+w.StartCol == colorcolumn && !preservebg {
+						fg, _, _ := s.Decompose()
+						style = style.Background(fg)
 					}
 				}
 			}
-			if nColsBeforeStart <= 0 {
-				vloc.X++
+
+			screen.SetContent(w.X+vloc.X, w.Y+vloc.Y, r, combc, style)
+
+			if showcursor {
+				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)
+					}
+				}
 			}
-			nColsBeforeStart--
 		}
 
 		wrap := func() {
@@ -712,6 +732,7 @@ func (w *BufWindow) displayBuffer() {
 
 			width := 0
 
+			linex := totalwidth
 			switch r {
 			case '\t':
 				ts := tabsize - (totalwidth % tabsize)
@@ -736,7 +757,7 @@ func (w *BufWindow) displayBuffer() {
 			// If a word (or just a wide rune) does not fit in the window
 			if vloc.X+wordwidth > maxWidth && vloc.X > w.gutterOffset {
 				for vloc.X < maxWidth {
-					draw(' ', 0, nil, true, config.DefStyle, false, false)
+					draw(' ', nil, config.DefStyle, false, false, true)
 				}
 
 				// We either stop or we wrap to draw the word in the next line
@@ -760,15 +781,17 @@ func (w *BufWindow) displayBuffer() {
 			}
 
 			for _, r := range word {
-				draw(r.r, 0, r.combc, false, r.style, true, true)
+				drawrune, drawstyle, preservebg := getRuneStyle(r.r, r.style, 0, linex, false)
+				draw(drawrune, r.combc, drawstyle, true, true, preservebg)
 
-				// Draw any extra characters for tabs
+				// Draw extra characters for tabs or wide runes
 				for i := 1; i < r.width; i++ {
-					if r.r != '\t' {
-						draw(' ', i, nil, true, r.style, true, false)
+					if r.r == '\t' {
+						drawrune, drawstyle, preservebg = getRuneStyle('\t', r.style, i, linex+i, false)
 					} else {
-						draw('\t', i, nil, false, r.style, true, false)
+						drawrune, drawstyle, preservebg = getRuneStyle(' ', r.style, i, linex+i, true)
 					}
+					draw(drawrune, nil, drawstyle, true, false, preservebg)
 				}
 				bloc.X++
 			}
@@ -821,7 +844,8 @@ func (w *BufWindow) displayBuffer() {
 
 		if vloc.X != maxWidth {
 			// Display newline within a selection
-			draw(' ', 0, nil, true, config.DefStyle, true, true)
+			drawrune, drawstyle, preservebg := getRuneStyle(' ', config.DefStyle, 0, totalwidth, true)
+			draw(drawrune, nil, drawstyle, true, true, preservebg)
 		}
 
 		bloc.X = w.StartCol