X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=cmd%2Fmicro%2Fview.go;h=bf1468fd86b0385c3d5ae17ddfa565406bc853f5;hb=a333f0ade2b8127e19a9898fbce90501289101d1;hp=9428a0b98cae4188f713266966f817e53c2ba550;hpb=774695254556c8ee0b70fd1fdfaca607855722f8;p=micro.git

diff --git a/cmd/micro/view.go b/cmd/micro/view.go
index 9428a0b9..bf1468fd 100644
--- a/cmd/micro/view.go
+++ b/cmd/micro/view.go
@@ -6,17 +6,17 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gdamore/tcell"
+	"github.com/zyedidia/tcell"
 )
 
 // The View struct stores information about a view into a buffer.
-// It has a stores information about the cursor, and the viewport
+// It stores information about the cursor, and the viewport
 // that the user sees the buffer from.
 type View struct {
-	cursor Cursor
+	Cursor Cursor
 
 	// The topmost line, used for vertical scrolling
-	topline int
+	Topline int
 	// The leftmost column, used for horizontal scrolling
 	leftCol int
 
@@ -34,8 +34,11 @@ type View struct {
 	// The eventhandler for undo/redo
 	eh *EventHandler
 
+	// Holds the list of gutter messages
+	messages []GutterMessage
+
 	// The buffer
-	buf *Buffer
+	Buf *Buffer
 	// The statusline
 	sline Statusline
 
@@ -49,6 +52,13 @@ type View struct {
 	// This is useful for detecting double and triple clicks
 	lastClickTime time.Time
 
+	// lastCutTime stores when the last ctrl+k was issued.
+	// It is used for clearing the clipboard to replace it with fresh cut lines.
+	lastCutTime time.Time
+
+	// freshClip returns true if the clipboard has never been pasted.
+	freshClip bool
+
 	// Was the last mouse event actually a double click?
 	// Useful for detecting triple clicks -- if a double click is detected
 	// but the last mouse event was actually a double click, it's a triple click
@@ -102,20 +112,20 @@ func (v *View) Resize(w, h int) {
 // ScrollUp scrolls the view up n lines (if possible)
 func (v *View) ScrollUp(n int) {
 	// Try to scroll by n but if it would overflow, scroll by 1
-	if v.topline-n >= 0 {
-		v.topline -= n
-	} else if v.topline > 0 {
-		v.topline--
+	if v.Topline-n >= 0 {
+		v.Topline -= n
+	} else if v.Topline > 0 {
+		v.Topline--
 	}
 }
 
 // ScrollDown scrolls the view down n lines (if possible)
 func (v *View) ScrollDown(n int) {
 	// Try to scroll by n but if it would overflow, scroll by 1
-	if v.topline+n <= len(v.buf.lines)-v.height {
-		v.topline += n
-	} else if v.topline < len(v.buf.lines)-v.height {
-		v.topline++
+	if v.Topline+n <= v.Buf.NumLines-v.height {
+		v.Topline += n
+	} else if v.Topline < v.Buf.NumLines-v.height {
+		v.Topline++
 	}
 }
 
@@ -124,13 +134,13 @@ func (v *View) ScrollDown(n int) {
 // causing them to lose the unsaved changes
 // The message is what to print after saying "You have unsaved changes. "
 func (v *View) CanClose(msg string) bool {
-	if v.buf.IsDirty() {
+	if v.Buf.IsDirty() {
 		quit, canceled := messenger.Prompt("You have unsaved changes. " + msg)
 		if !canceled {
 			if strings.ToLower(quit) == "yes" || strings.ToLower(quit) == "y" {
 				return true
 			} else if strings.ToLower(quit) == "save" || strings.ToLower(quit) == "s" {
-				Save(v)
+				v.Save()
 				return true
 			}
 		}
@@ -143,16 +153,16 @@ func (v *View) CanClose(msg string) bool {
 // OpenBuffer opens a new buffer in this view.
 // This resets the topline, event handler and cursor.
 func (v *View) OpenBuffer(buf *Buffer) {
-	v.buf = buf
-	v.topline = 0
+	v.Buf = buf
+	v.Topline = 0
 	v.leftCol = 0
 	// Put the cursor at the first spot
-	v.cursor = Cursor{
+	v.Cursor = Cursor{
 		x: 0,
 		y: 0,
 		v: v,
 	}
-	v.cursor.ResetSelection()
+	v.Cursor.ResetSelection()
 
 	v.eh = NewEventHandler(v)
 	v.matches = Match(v)
@@ -163,43 +173,39 @@ func (v *View) OpenBuffer(buf *Buffer) {
 	v.lastClickTime = time.Time{}
 }
 
-// Close and Re-open the current file.
-func (v *View) reOpen() {
+// ReOpen reloads the current buffer
+func (v *View) ReOpen() {
 	if v.CanClose("Continue? (yes, no, save) ") {
-		file, err := ioutil.ReadFile(v.buf.path)
-		filename := v.buf.name
+		file, err := ioutil.ReadFile(v.Buf.Path)
+		filename := v.Buf.Name
 
 		if err != nil {
 			messenger.Error(err.Error())
 			return
 		}
 		buf := NewBuffer(string(file), filename)
-		v.buf = buf
+		v.Buf = buf
 		v.matches = Match(v)
+		v.Cursor.Relocate()
 		v.Relocate()
 	}
 }
 
-// OpenFile opens a new file in the current view
-// It makes sure that the current buffer can be closed first (unsaved changes)
-func (v *View) OpenFile() {
-}
-
 // Relocate moves the view window so that the cursor is in view
 // This is useful if the user has scrolled far away, and then starts typing
 func (v *View) Relocate() bool {
 	ret := false
-	cy := v.cursor.y
-	if cy < v.topline {
-		v.topline = cy
+	cy := v.Cursor.y
+	if cy < v.Topline {
+		v.Topline = cy
 		ret = true
 	}
-	if cy > v.topline+v.height-1 {
-		v.topline = cy - v.height + 1
+	if cy > v.Topline+v.height-1 {
+		v.Topline = cy - v.height + 1
 		ret = true
 	}
 
-	cx := v.cursor.GetVisualX()
+	cx := v.Cursor.GetVisualX()
 	if cx < v.leftCol {
 		v.leftCol = cx
 		ret = true
@@ -214,12 +220,12 @@ func (v *View) Relocate() bool {
 // MoveToMouseClick moves the cursor to location x, y assuming x, y were given
 // by a mouse click
 func (v *View) MoveToMouseClick(x, y int) {
-	if y-v.topline > v.height-1 {
+	if y-v.Topline > v.height-1 {
 		v.ScrollDown(1)
-		y = v.height + v.topline - 1
+		y = v.height + v.Topline - 1
 	}
-	if y >= len(v.buf.lines) {
-		y = len(v.buf.lines) - 1
+	if y >= v.Buf.NumLines {
+		y = v.Buf.NumLines - 1
 	}
 	if y < 0 {
 		y = 0
@@ -228,13 +234,13 @@ func (v *View) MoveToMouseClick(x, y int) {
 		x = 0
 	}
 
-	x = v.cursor.GetCharPosInLine(y, x)
-	if x > Count(v.buf.lines[y]) {
-		x = Count(v.buf.lines[y])
+	x = v.Cursor.GetCharPosInLine(y, x)
+	if x > Count(v.Buf.Lines[y]) {
+		x = Count(v.Buf.Lines[y])
 	}
-	v.cursor.x = x
-	v.cursor.y = y
-	v.cursor.lastVisualX = v.cursor.GetVisualX()
+	v.Cursor.x = x
+	v.Cursor.y = y
+	v.Cursor.lastVisualX = v.Cursor.GetVisualX()
 }
 
 // HandleEvent handles an event passed by the main loop
@@ -250,12 +256,12 @@ func (v *View) HandleEvent(event tcell.Event) {
 	case *tcell.EventKey:
 		if e.Key() == tcell.KeyRune {
 			// Insert a character
-			if v.cursor.HasSelection() {
-				v.cursor.DeleteSelection()
-				v.cursor.ResetSelection()
+			if v.Cursor.HasSelection() {
+				v.Cursor.DeleteSelection()
+				v.Cursor.ResetSelection()
 			}
-			v.eh.Insert(v.cursor.Loc(), string(e.Rune()))
-			v.cursor.Right()
+			v.eh.Insert(v.Cursor.Loc(), string(e.Rune()))
+			v.Cursor.Right()
 		} else {
 			for key, action := range bindings {
 				if e.Key() == key {
@@ -263,22 +269,28 @@ func (v *View) HandleEvent(event tcell.Event) {
 				}
 			}
 		}
+	case *tcell.EventPaste:
+		if v.Cursor.HasSelection() {
+			v.Cursor.DeleteSelection()
+			v.Cursor.ResetSelection()
+		}
+		clip := e.Text()
+		v.eh.Insert(v.Cursor.Loc(), clip)
+		v.Cursor.SetLoc(v.Cursor.Loc() + Count(clip))
+		v.freshClip = false
 	case *tcell.EventMouse:
 		x, y := e.Position()
 		x -= v.lineNumOffset - v.leftCol
-		y += v.topline
+		y += v.Topline
 
 		button := e.Buttons()
 
 		switch button {
 		case tcell.Button1:
 			// Left click
-			origX, origY := v.cursor.x, v.cursor.y
-			v.MoveToMouseClick(x, y)
-
-			if v.mouseReleased {
-				if (time.Since(v.lastClickTime)/time.Millisecond < doubleClickThreshold) &&
-					(origX == v.cursor.x && origY == v.cursor.y) {
+			if v.mouseReleased && !e.HasMotion() {
+				v.MoveToMouseClick(x, y)
+				if time.Since(v.lastClickTime)/time.Millisecond < doubleClickThreshold {
 					if v.doubleClick {
 						// Triple click
 						v.lastClickTime = time.Now()
@@ -286,7 +298,7 @@ func (v *View) HandleEvent(event tcell.Event) {
 						v.tripleClick = true
 						v.doubleClick = false
 
-						v.cursor.SelectLine()
+						v.Cursor.SelectLine()
 					} else {
 						// Double click
 						v.lastClickTime = time.Now()
@@ -294,27 +306,29 @@ func (v *View) HandleEvent(event tcell.Event) {
 						v.doubleClick = true
 						v.tripleClick = false
 
-						v.cursor.SelectWord()
+						v.Cursor.SelectWord()
 					}
 				} else {
 					v.doubleClick = false
 					v.tripleClick = false
 					v.lastClickTime = time.Now()
 
-					loc := v.cursor.Loc()
-					v.cursor.curSelection[0] = loc
-					v.cursor.curSelection[1] = loc
+					loc := v.Cursor.Loc()
+					v.Cursor.origSelection[0] = loc
+					v.Cursor.curSelection[0] = loc
+					v.Cursor.curSelection[1] = loc
 				}
-			} else {
+				v.mouseReleased = false
+			} else if !v.mouseReleased {
+				v.MoveToMouseClick(x, y)
 				if v.tripleClick {
-					v.cursor.AddLineToSelection()
+					v.Cursor.AddLineToSelection()
 				} else if v.doubleClick {
-					v.cursor.AddWordToSelection()
+					v.Cursor.AddWordToSelection()
 				} else {
-					v.cursor.curSelection[1] = v.cursor.Loc()
+					v.Cursor.curSelection[1] = v.Cursor.Loc()
 				}
 			}
-			v.mouseReleased = false
 		case tcell.ButtonNone:
 			// Mouse event with no click
 			if !v.mouseReleased {
@@ -328,7 +342,7 @@ func (v *View) HandleEvent(event tcell.Event) {
 
 				if !v.doubleClick && !v.tripleClick {
 					v.MoveToMouseClick(x, y)
-					v.cursor.curSelection[1] = v.cursor.Loc()
+					v.Cursor.curSelection[1] = v.Cursor.Loc()
 				}
 				v.mouseReleased = true
 			}
@@ -351,35 +365,97 @@ func (v *View) HandleEvent(event tcell.Event) {
 	if relocate {
 		v.Relocate()
 	}
-	if settings.Syntax {
+	if settings["syntax"].(bool) {
 		v.matches = Match(v)
 	}
 }
 
+// GutterMessage creates a message in this view's gutter
+func (v *View) GutterMessage(lineN int, msg string, kind int) {
+	lineN--
+	gutterMsg := GutterMessage{
+		lineNum: lineN,
+		msg:     msg,
+		kind:    kind,
+	}
+	for _, gmsg := range v.messages {
+		if gmsg.lineNum == lineN {
+			return
+		}
+	}
+	v.messages = append(v.messages, gutterMsg)
+}
+
 // DisplayView renders the view to the screen
 func (v *View) DisplayView() {
 	// The character number of the character in the top left of the screen
-	charNum := ToCharPos(0, v.topline, v.buf)
+	charNum := ToCharPos(0, v.Topline, v.Buf)
 
 	// 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
-	maxLineLength := len(strconv.Itoa(len(v.buf.lines)))
+	maxLineLength := len(strconv.Itoa(v.Buf.NumLines))
 	// + 1 for the little space after the line number
-	if settings.Ruler == true {
+	if settings["ruler"] == true {
 		v.lineNumOffset = maxLineLength + 1
 	} else {
 		v.lineNumOffset = 0
 	}
 	var highlightStyle tcell.Style
 
+	if len(v.messages) > 0 {
+		v.lineNumOffset += 2
+	}
+
 	for lineN := 0; lineN < v.height; lineN++ {
 		var x int
 		// If the buffer is smaller than the view height
 		// and we went too far, break
-		if lineN+v.topline >= len(v.buf.lines) {
+		if lineN+v.Topline >= v.Buf.NumLines {
 			break
 		}
-		line := v.buf.lines[lineN+v.topline]
+		line := v.Buf.Lines[lineN+v.Topline]
+
+		if len(v.messages) > 0 {
+			msgOnLine := false
+			for _, msg := range v.messages {
+				if msg.lineNum == lineN+v.Topline {
+					msgOnLine = true
+					gutterStyle := tcell.StyleDefault
+					switch msg.kind {
+					case GutterInfo:
+						if style, ok := colorscheme["gutter-info"]; ok {
+							gutterStyle = style
+						}
+					case GutterWarning:
+						if style, ok := colorscheme["gutter-warning"]; ok {
+							gutterStyle = style
+						}
+					case GutterError:
+						if style, ok := colorscheme["gutter-error"]; ok {
+							gutterStyle = style
+						}
+					}
+					screen.SetContent(x, lineN, '>', nil, gutterStyle)
+					x++
+					screen.SetContent(x, lineN, '>', nil, gutterStyle)
+					x++
+					if v.Cursor.y == lineN {
+						messenger.Message(msg.msg)
+						messenger.gutterMessage = true
+					}
+				}
+			}
+			if !msgOnLine {
+				screen.SetContent(x, lineN, ' ', nil, tcell.StyleDefault)
+				x++
+				screen.SetContent(x, lineN, ' ', nil, tcell.StyleDefault)
+				x++
+				if v.Cursor.y == lineN && messenger.gutterMessage {
+					messenger.Reset()
+					messenger.gutterMessage = false
+				}
+			}
+		}
 
 		// Write the line number
 		lineNumStyle := defStyle
@@ -388,8 +464,8 @@ func (v *View) DisplayView() {
 		}
 		// Write the spaces before the line number if necessary
 		var lineNum string
-		if settings.Ruler == true {
-			lineNum = strconv.Itoa(lineN + v.topline + 1)
+		if settings["ruler"] == true {
+			lineNum = strconv.Itoa(lineN + v.Topline + 1)
 			for i := 0; i < maxLineLength-len(lineNum); i++ {
 				screen.SetContent(x, lineN, ' ', nil, lineNumStyle)
 				x++
@@ -400,7 +476,7 @@ func (v *View) DisplayView() {
 				x++
 			}
 
-			if settings.Ruler == true {
+			if settings["ruler"] == true {
 				// Write the extra space
 				screen.SetContent(x, lineN, ' ', nil, lineNumStyle)
 				x++
@@ -411,14 +487,14 @@ func (v *View) DisplayView() {
 		for colN, ch := range line {
 			var lineStyle tcell.Style
 
-			if settings.Syntax {
+			if settings["syntax"].(bool) {
 				// Syntax highlighting is enabled
 				highlightStyle = v.matches[lineN][colN]
 			}
 
-			if v.cursor.HasSelection() &&
-				(charNum >= v.cursor.curSelection[0] && charNum < v.cursor.curSelection[1] ||
-					charNum < v.cursor.curSelection[0] && charNum >= v.cursor.curSelection[1]) {
+			if v.Cursor.HasSelection() &&
+				(charNum >= v.Cursor.curSelection[0] && charNum < v.Cursor.curSelection[1] ||
+					charNum < v.Cursor.curSelection[0] && charNum >= v.Cursor.curSelection[1]) {
 
 				lineStyle = tcell.StyleDefault.Reverse(true)
 
@@ -431,7 +507,7 @@ func (v *View) DisplayView() {
 
 			if ch == '\t' {
 				screen.SetContent(x+tabchars, lineN, ' ', nil, lineStyle)
-				tabSize := settings.TabSize
+				tabSize := int(settings["tabsize"].(float64))
 				for i := 0; i < tabSize-1; i++ {
 					tabchars++
 					if x-v.leftCol+tabchars >= v.lineNumOffset {
@@ -450,9 +526,9 @@ func (v *View) DisplayView() {
 
 		// The newline may be selected, in which case we should draw the selection style
 		// with a space to represent it
-		if v.cursor.HasSelection() &&
-			(charNum >= v.cursor.curSelection[0] && charNum < v.cursor.curSelection[1] ||
-				charNum < v.cursor.curSelection[0] && charNum >= v.cursor.curSelection[1]) {
+		if v.Cursor.HasSelection() &&
+			(charNum >= v.Cursor.curSelection[0] && charNum < v.Cursor.curSelection[1] ||
+				charNum < v.Cursor.curSelection[0] && charNum >= v.Cursor.curSelection[1]) {
 
 			selectStyle := defStyle.Reverse(true)
 
@@ -469,6 +545,6 @@ func (v *View) DisplayView() {
 // Display renders the view, the cursor, and statusline
 func (v *View) Display() {
 	v.DisplayView()
-	v.cursor.Display()
+	v.Cursor.Display()
 	v.sline.Display()
 }