X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=internal%2Faction%2Factions.go;h=5d7b31e0238b9f0dd70ab9ca2a4515791a2eefea;hb=f143418267df07c0f9424e02cc942edfdf3f450f;hp=925c97e8b97d2a20feae8f1697490a97127ae56f;hpb=0301e3539ea3bba36f6105b9d4e40b0a6ff03994;p=micro.git

diff --git a/internal/action/actions.go b/internal/action/actions.go
index 925c97e8..5d7b31e0 100644
--- a/internal/action/actions.go
+++ b/internal/action/actions.go
@@ -5,15 +5,14 @@ import (
 	"runtime"
 	"strings"
 	"time"
-	"unicode/utf8"
-
-	"github.com/zyedidia/clipboard"
-	"github.com/zyedidia/micro/internal/buffer"
-	"github.com/zyedidia/micro/internal/config"
-	"github.com/zyedidia/micro/internal/screen"
-	"github.com/zyedidia/micro/internal/shell"
-	"github.com/zyedidia/micro/internal/util"
-	"github.com/zyedidia/micro/pkg/shellwords"
+
+	shellquote "github.com/kballard/go-shellquote"
+	"github.com/zyedidia/micro/v2/internal/buffer"
+	"github.com/zyedidia/micro/v2/internal/clipboard"
+	"github.com/zyedidia/micro/v2/internal/config"
+	"github.com/zyedidia/micro/v2/internal/screen"
+	"github.com/zyedidia/micro/v2/internal/shell"
+	"github.com/zyedidia/micro/v2/internal/util"
 	"github.com/zyedidia/tcell"
 )
 
@@ -60,7 +59,7 @@ func (h *BufPane) MousePress(e *tcell.EventMouse) bool {
 				h.doubleClick = false
 
 				h.Cursor.SelectLine()
-				h.Cursor.CopySelection("primary")
+				h.Cursor.CopySelection(clipboard.PrimaryReg)
 			} else {
 				// Double click
 				h.lastClickTime = time.Now()
@@ -69,7 +68,7 @@ func (h *BufPane) MousePress(e *tcell.EventMouse) bool {
 				h.tripleClick = false
 
 				h.Cursor.SelectWord()
-				h.Cursor.CopySelection("primary")
+				h.Cursor.CopySelection(clipboard.PrimaryReg)
 			}
 		} else {
 			h.doubleClick = false
@@ -175,7 +174,7 @@ func (h *BufPane) CursorRight() bool {
 		if tabstospaces && tabmovement {
 			tabsize := int(h.Buf.Settings["tabsize"].(float64))
 			line := h.Buf.LineBytes(h.Cursor.Y)
-			if h.Cursor.X+tabsize < utf8.RuneCount(line) && util.IsSpaces(line[h.Cursor.X:h.Cursor.X+tabsize]) && util.IsBytesWhitespace(line[0:h.Cursor.X]) {
+			if h.Cursor.X+tabsize < util.CharacterCount(line) && util.IsSpaces(line[h.Cursor.X:h.Cursor.X+tabsize]) && util.IsBytesWhitespace(line[0:h.Cursor.X]) {
 				for i := 0; i < tabsize; i++ {
 					h.Cursor.Right()
 				}
@@ -283,15 +282,31 @@ func (h *BufPane) SelectWordLeft() bool {
 	return true
 }
 
+// StartOfText moves the cursor to the start of the text of the line
+func (h *BufPane) StartOfText() bool {
+	h.Cursor.Deselect(true)
+	h.Cursor.StartOfText()
+	h.Relocate()
+	return true
+}
+
+// StartOfTextToggle toggles the cursor between the start of the text of the line
+// and the start of the line
+func (h *BufPane) StartOfTextToggle() bool {
+	h.Cursor.Deselect(true)
+	if h.Cursor.IsStartOfText() {
+		h.Cursor.Start()
+	} else {
+		h.Cursor.StartOfText()
+	}
+	h.Relocate()
+	return true
+}
+
 // StartOfLine moves the cursor to the start of the line
 func (h *BufPane) StartOfLine() bool {
 	h.Cursor.Deselect(true)
-	h.Cursor.StartOfText()
-	// if h.Cursor.X != 0 {
-	// 	h.Cursor.Start()
-	// } else {
-	// 	h.Cursor.StartOfText()
-	// }
+	h.Cursor.Start()
 	h.Relocate()
 	return true
 }
@@ -311,6 +326,33 @@ func (h *BufPane) SelectLine() bool {
 	return true
 }
 
+// SelectToStartOfText selects to the start of the text on the current line
+func (h *BufPane) SelectToStartOfText() bool {
+	if !h.Cursor.HasSelection() {
+		h.Cursor.OrigSelection[0] = h.Cursor.Loc
+	}
+	h.Cursor.StartOfText()
+	h.Cursor.SelectTo(h.Cursor.Loc)
+	h.Relocate()
+	return true
+}
+
+// SelectToStartOfTextToggle toggles the selection between the start of the text
+// on the current line and the start of the line
+func (h *BufPane) SelectToStartOfTextToggle() bool {
+	if !h.Cursor.HasSelection() {
+		h.Cursor.OrigSelection[0] = h.Cursor.Loc
+	}
+	if h.Cursor.IsStartOfText() {
+		h.Cursor.Start()
+	} else {
+		h.Cursor.StartOfText()
+	}
+	h.Cursor.SelectTo(h.Cursor.Loc)
+	h.Relocate()
+	return true
+}
+
 // SelectToStartOfLine selects to the start of the current line
 func (h *BufPane) SelectToStartOfLine() bool {
 	if !h.Cursor.HasSelection() {
@@ -382,6 +424,7 @@ func (h *BufPane) CursorStart() bool {
 	h.Cursor.Deselect(true)
 	h.Cursor.X = 0
 	h.Cursor.Y = 0
+	h.Cursor.StoreVisualX()
 	h.Relocate()
 	return true
 }
@@ -442,7 +485,7 @@ func (h *BufPane) InsertNewline() bool {
 		// Remove the whitespaces if keepautoindent setting is off
 		if util.IsSpacesOrTabs(h.Buf.LineBytes(h.Cursor.Y-1)) && !h.Buf.Settings["keepautoindent"].(bool) {
 			line := h.Buf.LineBytes(h.Cursor.Y - 1)
-			h.Buf.Remove(buffer.Loc{X: 0, Y: h.Cursor.Y - 1}, buffer.Loc{X: utf8.RuneCount(line), Y: h.Cursor.Y - 1})
+			h.Buf.Remove(buffer.Loc{X: 0, Y: h.Cursor.Y - 1}, buffer.Loc{X: util.CharacterCount(line), Y: h.Cursor.Y - 1})
 		}
 	}
 	h.Cursor.LastVisualX = h.Cursor.GetVisualX()
@@ -467,7 +510,7 @@ func (h *BufPane) Backspace() bool {
 		// tab (tabSize number of spaces)
 		lineStart := util.SliceStart(h.Buf.LineBytes(h.Cursor.Y), h.Cursor.X)
 		tabSize := int(h.Buf.Settings["tabsize"].(float64))
-		if h.Buf.Settings["tabstospaces"].(bool) && util.IsSpaces(lineStart) && len(lineStart) != 0 && utf8.RuneCount(lineStart)%tabSize == 0 {
+		if h.Buf.Settings["tabstospaces"].(bool) && util.IsSpaces(lineStart) && len(lineStart) != 0 && util.CharacterCount(lineStart)%tabSize == 0 {
 			loc := h.Cursor.Loc
 			h.Buf.Remove(loc.Move(-tabSize, h.Buf), loc)
 		} else {
@@ -534,12 +577,14 @@ func (h *BufPane) IndentSelection() bool {
 		tabsize := int(h.Buf.Settings["tabsize"].(float64))
 		indentsize := len(h.Buf.IndentString(tabsize))
 		for y := startY; y <= endY; y++ {
-			h.Buf.Insert(buffer.Loc{X: 0, Y: y}, h.Buf.IndentString(tabsize))
-			if y == startY && start.X > 0 {
-				h.Cursor.SetSelectionStart(start.Move(indentsize, h.Buf))
-			}
-			if y == endY {
-				h.Cursor.SetSelectionEnd(buffer.Loc{X: endX + indentsize + 1, Y: endY})
+			if len(h.Buf.LineBytes(y)) > 0 {
+				h.Buf.Insert(buffer.Loc{X: 0, Y: y}, h.Buf.IndentString(tabsize))
+				if y == startY && start.X > 0 {
+					h.Cursor.SetSelectionStart(start.Move(indentsize, h.Buf))
+				}
+				if y == endY {
+					h.Cursor.SetSelectionEnd(buffer.Loc{X: endX + indentsize + 1, Y: endY})
+				}
 			}
 		}
 		h.Buf.RelocateCursors()
@@ -550,6 +595,20 @@ func (h *BufPane) IndentSelection() bool {
 	return false
 }
 
+// IndentLine moves the current line forward one indentation
+func (h *BufPane) IndentLine() bool {
+	if h.Cursor.HasSelection() {
+		return false
+	}
+
+	tabsize := int(h.Buf.Settings["tabsize"].(float64))
+	indentstr := h.Buf.IndentString(tabsize)
+	h.Buf.Insert(buffer.Loc{X: 0, Y: h.Cursor.Y}, indentstr)
+	h.Buf.RelocateCursors()
+	h.Relocate()
+	return true
+}
+
 // OutdentLine moves the current line back one indentation
 func (h *BufPane) OutdentLine() bool {
 	if h.Cursor.HasSelection() {
@@ -604,6 +663,16 @@ func (h *BufPane) Autocomplete() bool {
 		return false
 	}
 
+	if h.Cursor.X == 0 {
+		return false
+	}
+	r := h.Cursor.RuneUnder(h.Cursor.X)
+	prev := h.Cursor.RuneUnder(h.Cursor.X - 1)
+	if !util.IsAutocomplete(prev) || !util.IsNonAlphaNumeric(r) {
+		// don't autocomplete if cursor is on alpha numeric character (middle of a word)
+		return false
+	}
+
 	if b.HasSuggestions {
 		b.CycleAutocomplete(true)
 		return true
@@ -611,6 +680,19 @@ func (h *BufPane) Autocomplete() bool {
 	return b.Autocomplete(buffer.BufferComplete)
 }
 
+// CycleAutocompleteBack cycles back in the autocomplete suggestion list
+func (h *BufPane) CycleAutocompleteBack() bool {
+	if h.Cursor.HasSelection() {
+		return false
+	}
+
+	if h.Buf.HasSuggestions {
+		h.Buf.CycleAutocomplete(false)
+		return true
+	}
+	return false
+}
+
 // InsertTab inserts a tab or spaces
 func (h *BufPane) InsertTab() bool {
 	b := h.Buf
@@ -630,54 +712,86 @@ func (h *BufPane) SaveAll() bool {
 	return true
 }
 
-// Save the buffer to disk
-func (h *BufPane) Save() bool {
+// SaveCB performs a save and does a callback at the very end (after all prompts have been resolved)
+func (h *BufPane) SaveCB(action string, callback func()) bool {
 	// If this is an empty buffer, ask for a filename
 	if h.Buf.Path == "" {
-		h.SaveAs()
+		h.SaveAsCB(action, callback)
 	} else {
-		h.saveBufToFile(h.Buf.Path, "Save")
+		noPrompt := h.saveBufToFile(h.Buf.Path, action, callback)
+		if noPrompt {
+			return true
+		}
 	}
-
 	return false
 }
 
-// SaveAs saves the buffer to disk with the given name
-func (h *BufPane) SaveAs() bool {
+// Save the buffer to disk
+func (h *BufPane) Save() bool {
+	return h.SaveCB("Save", nil)
+}
+
+// SaveAsCB performs a save as and does a callback at the very end (after all prompts have been resolved)
+// The callback is only called if the save was successful
+func (h *BufPane) SaveAsCB(action string, callback func()) bool {
 	InfoBar.Prompt("Filename: ", "", "Save", nil, func(resp string, canceled bool) {
 		if !canceled {
 			// the filename might or might not be quoted, so unquote first then join the strings.
-			args, err := shellwords.Split(resp)
-			filename := strings.Join(args, " ")
+			args, err := shellquote.Split(resp)
 			if err != nil {
 				InfoBar.Error("Error parsing arguments: ", err)
 				return
 			}
-			h.saveBufToFile(filename, "SaveAs")
+			if len(args) == 0 {
+				InfoBar.Error("No filename given")
+				return
+			}
+			filename := strings.Join(args, " ")
+			noPrompt := h.saveBufToFile(filename, action, callback)
+			if noPrompt {
+				h.completeAction(action)
+			}
 		}
 	})
 	return false
 }
 
+// SaveAs saves the buffer to disk with the given name
+func (h *BufPane) SaveAs() bool {
+	return h.SaveAsCB("SaveAs", nil)
+}
+
 // This function saves the buffer to `filename` and changes the buffer's path and name
 // to `filename` if the save is successful
-func (h *BufPane) saveBufToFile(filename string, action string) {
+// The callback is only called if the save was successful
+func (h *BufPane) saveBufToFile(filename string, action string, callback func()) bool {
 	err := h.Buf.SaveAs(filename)
 	if err != nil {
 		if strings.HasSuffix(err.Error(), "permission denied") {
-			InfoBar.YNPrompt("Permission denied. Do you want to save this file using sudo? (y,n)", func(yes, canceled bool) {
-				if yes && !canceled {
-					err = h.Buf.SaveAsWithSudo(filename)
-					if err != nil {
-						InfoBar.Error(err)
-					} else {
-						h.Buf.Path = filename
-						h.Buf.SetName(filename)
-						InfoBar.Message("Saved " + filename)
+			saveWithSudo := func() {
+				err = h.Buf.SaveAsWithSudo(filename)
+				if err != nil {
+					InfoBar.Error(err)
+				} else {
+					h.Buf.Path = filename
+					h.Buf.SetName(filename)
+					InfoBar.Message("Saved " + filename)
+					if callback != nil {
+						callback()
 					}
-					h.completeAction(action)
 				}
-			})
+			}
+			if h.Buf.Settings["autosu"].(bool) {
+				saveWithSudo()
+			} else {
+				InfoBar.YNPrompt("Permission denied. Do you want to save this file using sudo? (y,n)", func(yes, canceled bool) {
+					if yes && !canceled {
+						saveWithSudo()
+						h.completeAction(action)
+					}
+				})
+				return false
+			}
 		} else {
 			InfoBar.Error(err)
 		}
@@ -685,16 +799,56 @@ func (h *BufPane) saveBufToFile(filename string, action string) {
 		h.Buf.Path = filename
 		h.Buf.SetName(filename)
 		InfoBar.Message("Saved " + filename)
-		h.completeAction(action)
+		if callback != nil {
+			callback()
+		}
 	}
+	return true
 }
 
 // Find opens a prompt and searches forward for the input
 func (h *BufPane) Find() bool {
+	return h.find(true)
+}
+
+// FindLiteral is the same as Find() but does not support regular expressions
+func (h *BufPane) FindLiteral() bool {
+	return h.find(false)
+}
+
+// Search searches for a given string/regex in the buffer and selects the next
+// match if a match is found
+// This function affects lastSearch and lastSearchRegex (saved searches) for
+// use with FindNext and FindPrevious
+func (h *BufPane) Search(str string, useRegex bool, searchDown bool) error {
+	match, found, err := h.Buf.FindNext(str, h.Buf.Start(), h.Buf.End(), h.Cursor.Loc, searchDown, useRegex)
+	if err != nil {
+		return err
+	}
+	if found {
+		h.Cursor.SetSelectionStart(match[0])
+		h.Cursor.SetSelectionEnd(match[1])
+		h.Cursor.OrigSelection[0] = h.Cursor.CurSelection[0]
+		h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
+		h.Cursor.GotoLoc(h.Cursor.CurSelection[1])
+		h.lastSearch = str
+		h.lastSearchRegex = useRegex
+		h.Relocate()
+	} else {
+		h.Cursor.ResetSelection()
+	}
+	return nil
+}
+
+func (h *BufPane) find(useRegex bool) bool {
 	h.searchOrig = h.Cursor.Loc
-	InfoBar.Prompt("Find: ", "", "Find", func(resp string) {
+	prompt := "Find: "
+	if useRegex {
+		prompt = "Find (regex): "
+	}
+	InfoBar.Prompt(prompt, "", "Find", func(resp string) {
 		// Event callback
-		match, found, _ := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
+		match, found, _ := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, useRegex)
 		if found {
 			h.Cursor.SetSelectionStart(match[0])
 			h.Cursor.SetSelectionEnd(match[1])
@@ -709,7 +863,7 @@ func (h *BufPane) Find() bool {
 	}, func(resp string, canceled bool) {
 		// Finished callback
 		if !canceled {
-			match, found, err := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
+			match, found, err := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, useRegex)
 			if err != nil {
 				InfoBar.Error(err)
 			}
@@ -720,6 +874,7 @@ func (h *BufPane) Find() bool {
 				h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
 				h.Cursor.GotoLoc(h.Cursor.CurSelection[1])
 				h.lastSearch = resp
+				h.lastSearchRegex = useRegex
 			} else {
 				h.Cursor.ResetSelection()
 				InfoBar.Message("No matches found")
@@ -743,7 +898,7 @@ func (h *BufPane) FindNext() bool {
 	if h.Cursor.HasSelection() {
 		searchLoc = h.Cursor.CurSelection[1]
 	}
-	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, true, true)
+	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, true, h.lastSearchRegex)
 	if err != nil {
 		InfoBar.Error(err)
 	}
@@ -770,7 +925,7 @@ func (h *BufPane) FindPrevious() bool {
 	if h.Cursor.HasSelection() {
 		searchLoc = h.Cursor.CurSelection[0]
 	}
-	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, false, true)
+	match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, false, h.lastSearchRegex)
 	if err != nil {
 		InfoBar.Error(err)
 	}
@@ -806,14 +961,25 @@ func (h *BufPane) Redo() bool {
 // Copy the selection to the system clipboard
 func (h *BufPane) Copy() bool {
 	if h.Cursor.HasSelection() {
-		h.Cursor.CopySelection("clipboard")
+		h.Cursor.CopySelection(clipboard.ClipboardReg)
 		h.freshClip = true
-		if clipboard.Unsupported {
-			InfoBar.Message("Copied selection (install xclip for external clipboard)")
-		} else {
-			InfoBar.Message("Copied selection")
-		}
+		InfoBar.Message("Copied selection")
+	}
+	h.Relocate()
+	return true
+}
+
+// Copy the current line to the clipboard
+func (h *BufPane) CopyLine() bool {
+	if h.Cursor.HasSelection() {
+		return false
+	} else {
+		h.Cursor.SelectLine()
+		h.Cursor.CopySelection(clipboard.ClipboardReg)
+		h.freshClip = true
+		InfoBar.Message("Copied line")
 	}
+	h.Cursor.Deselect(true)
 	h.Relocate()
 	return true
 }
@@ -826,10 +992,10 @@ func (h *BufPane) CutLine() bool {
 	}
 	if h.freshClip == true {
 		if h.Cursor.HasSelection() {
-			if clip, err := clipboard.ReadAll("clipboard"); err != nil {
-				// messenger.Error(err)
+			if clip, err := clipboard.Read(clipboard.ClipboardReg); err != nil {
+				InfoBar.Error(err)
 			} else {
-				clipboard.WriteAll(clip+string(h.Cursor.GetSelection()), "clipboard")
+				clipboard.Write(clip+string(h.Cursor.GetSelection()), clipboard.ClipboardReg)
 			}
 		}
 	} else if time.Since(h.lastCutTime)/time.Second > 10*time.Second || h.freshClip == false {
@@ -847,7 +1013,7 @@ func (h *BufPane) CutLine() bool {
 // Cut the selection to the system clipboard
 func (h *BufPane) Cut() bool {
 	if h.Cursor.HasSelection() {
-		h.Cursor.CopySelection("clipboard")
+		h.Cursor.CopySelection(clipboard.ClipboardReg)
 		h.Cursor.DeleteSelection()
 		h.Cursor.ResetSelection()
 		h.freshClip = true
@@ -897,15 +1063,26 @@ func (h *BufPane) MoveLinesUp() bool {
 		}
 		start := h.Cursor.CurSelection[0].Y
 		end := h.Cursor.CurSelection[1].Y
+		sel := 1
 		if start > end {
 			end, start = start, end
+			sel = 0
+		}
+
+		compensate := false
+		if h.Cursor.CurSelection[sel].X != 0 {
+			end++
+		} else {
+			compensate = true
 		}
 
 		h.Buf.MoveLinesUp(
 			start,
 			end,
 		)
-		h.Cursor.CurSelection[1].Y -= 1
+		if compensate {
+			h.Cursor.CurSelection[sel].Y -= 1
+		}
 	} else {
 		if h.Cursor.Loc.Y == 0 {
 			InfoBar.Message("Cannot move further up")
@@ -930,8 +1107,14 @@ func (h *BufPane) MoveLinesDown() bool {
 		}
 		start := h.Cursor.CurSelection[0].Y
 		end := h.Cursor.CurSelection[1].Y
+		sel := 1
 		if start > end {
 			end, start = start, end
+			sel = 0
+		}
+
+		if h.Cursor.CurSelection[sel].X != 0 {
+			end++
 		}
 
 		h.Buf.MoveLinesDown(
@@ -956,7 +1139,10 @@ func (h *BufPane) MoveLinesDown() bool {
 // Paste whatever is in the system clipboard into the buffer
 // Delete and paste if the user has a selection
 func (h *BufPane) Paste() bool {
-	clip, _ := clipboard.ReadAll("clipboard")
+	clip, err := clipboard.Read(clipboard.ClipboardReg)
+	if err != nil {
+		InfoBar.Error(err)
+	}
 	h.paste(clip)
 	h.Relocate()
 	return true
@@ -964,7 +1150,10 @@ func (h *BufPane) Paste() bool {
 
 // PastePrimary pastes from the primary clipboard (only use on linux)
 func (h *BufPane) PastePrimary() bool {
-	clip, _ := clipboard.ReadAll("primary")
+	clip, err := clipboard.Read(clipboard.PrimaryReg)
+	if err != nil {
+		InfoBar.Error(err)
+	}
 	h.paste(clip)
 	h.Relocate()
 	return true
@@ -986,11 +1175,7 @@ func (h *BufPane) paste(clip string) {
 	h.Buf.Insert(h.Cursor.Loc, clip)
 	// h.Cursor.Loc = h.Cursor.Loc.Move(Count(clip), h.Buf)
 	h.freshClip = false
-	if clipboard.Unsupported {
-		InfoBar.Message("Pasted clipboard (install xclip for external clipboard)")
-	} else {
-		InfoBar.Message("Pasted clipboard")
-	}
+	InfoBar.Message("Pasted clipboard")
 }
 
 // JumpToMatchingBrace moves the cursor to the matching brace if it is
@@ -1000,11 +1185,15 @@ func (h *BufPane) JumpToMatchingBrace() bool {
 		r := h.Cursor.RuneUnder(h.Cursor.X)
 		rl := h.Cursor.RuneUnder(h.Cursor.X - 1)
 		if r == bp[0] || r == bp[1] || rl == bp[0] || rl == bp[1] {
-			matchingBrace, left := h.Buf.FindMatchingBrace(bp, h.Cursor.Loc)
-			if left {
-				h.Cursor.GotoLoc(matchingBrace)
+			matchingBrace, left, found := h.Buf.FindMatchingBrace(bp, h.Cursor.Loc)
+			if found {
+				if left {
+					h.Cursor.GotoLoc(matchingBrace)
+				} else {
+					h.Cursor.GotoLoc(matchingBrace.Move(1, h.Buf))
+				}
 			} else {
-				h.Cursor.GotoLoc(matchingBrace.Move(1, h.Buf))
+				return false
 			}
 		}
 	}
@@ -1034,6 +1223,16 @@ func (h *BufPane) OpenFile() bool {
 	return true
 }
 
+// OpenFile opens a new file in the buffer
+func (h *BufPane) JumpLine() bool {
+	InfoBar.Prompt("> ", "goto ", "Command", nil, func(resp string, canceled bool) {
+		if !canceled {
+			h.HandleCommand(resp)
+		}
+	})
+	return true
+}
+
 // Start moves the viewport to the start of the buffer
 func (h *BufPane) Start() bool {
 	v := h.GetView()
@@ -1155,6 +1354,21 @@ func (h *BufPane) HalfPageDown() bool {
 	return true
 }
 
+// ToggleDiffGutter turns the diff gutter off and on
+func (h *BufPane) ToggleDiffGutter() bool {
+	if !h.Buf.Settings["diffgutter"].(bool) {
+		h.Buf.Settings["diffgutter"] = true
+		h.Buf.UpdateDiff(func(synchronous bool) {
+			screen.Redraw()
+		})
+		InfoBar.Message("Enabled diff gutter")
+	} else {
+		h.Buf.Settings["diffgutter"] = false
+		InfoBar.Message("Disabled diff gutter")
+	}
+	return true
+}
+
 // ToggleRuler turns line numbers off and on
 func (h *BufPane) ToggleRuler() bool {
 	if !h.Buf.Settings["ruler"].(bool) {
@@ -1223,6 +1437,18 @@ func (h *BufPane) Escape() bool {
 	return true
 }
 
+// Deselect deselects on the current cursor
+func (h *BufPane) Deselect() bool {
+	h.Cursor.Deselect(true)
+	return true
+}
+
+// ClearInfo clears the infobar
+func (h *BufPane) ClearInfo() bool {
+	InfoBar.Message("")
+	return true
+}
+
 // Quit this will close the current tab or view that is open
 func (h *BufPane) Quit() bool {
 	quit := func() {
@@ -1238,20 +1464,22 @@ func (h *BufPane) Quit() bool {
 		}
 	}
 	if h.Buf.Modified() {
-		// if config.GlobalSettings["autosave"].(float64) > 0 {
-		// autosave on means we automatically save when quitting
-		// h.Save()
-		// quit()
-		// } else {
-		InfoBar.YNPrompt("Save changes to "+h.Buf.GetName()+" before closing? (y,n,esc)", func(yes, canceled bool) {
-			if !canceled && !yes {
+		if config.GlobalSettings["autosave"].(float64) > 0 {
+			// autosave on means we automatically save when quitting
+			h.SaveCB("Quit", func() {
 				quit()
-			} else if !canceled && yes {
-				h.Save()
-				quit()
-			}
-		})
-		// }
+			})
+		} else {
+			InfoBar.YNPrompt("Save changes to "+h.Buf.GetName()+" before closing? (y,n,esc)", func(yes, canceled bool) {
+				if !canceled && !yes {
+					quit()
+				} else if !canceled && yes {
+					h.SaveCB("Quit", func() {
+						quit()
+					})
+				}
+			})
+		}
 	} else {
 		quit()
 	}
@@ -1304,8 +1532,9 @@ func (h *BufPane) AddTab() bool {
 
 // PreviousTab switches to the previous tab in the tab list
 func (h *BufPane) PreviousTab() bool {
-	a := Tabs.Active()
-	Tabs.SetActive(util.Clamp(a-1, 0, len(Tabs.List)-1))
+	tabsLen := len(Tabs.List)
+	a := Tabs.Active() + tabsLen
+	Tabs.SetActive((a - 1) % tabsLen)
 
 	return true
 }
@@ -1313,7 +1542,8 @@ func (h *BufPane) PreviousTab() bool {
 // NextTab switches to the next tab in the tab list
 func (h *BufPane) NextTab() bool {
 	a := Tabs.Active()
-	Tabs.SetActive(util.Clamp(a+1, 0, len(Tabs.List)-1))
+	Tabs.SetActive((a + 1) % len(Tabs.List))
+
 	return true
 }
 
@@ -1333,38 +1563,42 @@ func (h *BufPane) HSplitAction() bool {
 
 // Unsplit closes all splits in the current tab except the active one
 func (h *BufPane) Unsplit() bool {
-	n := MainTab().GetNode(h.splitID)
-	n.Unsplit()
+	tab := h.tab
+	n := tab.GetNode(h.splitID)
+	ok := n.Unsplit()
+	if ok {
+		tab.RemovePane(tab.GetPane(h.splitID))
+		tab.Resize()
+		tab.SetActive(len(tab.Panes) - 1)
 
-	MainTab().RemovePane(MainTab().GetPane(h.splitID))
-	MainTab().Resize()
-	MainTab().SetActive(len(MainTab().Panes) - 1)
-	return true
+		return true
+	}
+	return false
 }
 
 // NextSplit changes the view to the next split
 func (h *BufPane) NextSplit() bool {
-	a := MainTab().active
-	if a < len(MainTab().Panes)-1 {
+	a := h.tab.active
+	if a < len(h.tab.Panes)-1 {
 		a++
 	} else {
 		a = 0
 	}
 
-	MainTab().SetActive(a)
+	h.tab.SetActive(a)
 
 	return true
 }
 
 // PreviousSplit changes the view to the previous split
 func (h *BufPane) PreviousSplit() bool {
-	a := MainTab().active
+	a := h.tab.active
 	if a > 0 {
 		a--
 	} else {
-		a = len(MainTab().Panes) - 1
+		a = len(h.tab.Panes) - 1
 	}
-	MainTab().SetActive(a)
+	h.tab.SetActive(a)
 
 	return true
 }
@@ -1443,6 +1677,41 @@ func (h *BufPane) SpawnMultiCursor() bool {
 	return true
 }
 
+// SpawnMultiCursorUp creates additional cursor, at the same X (if possible), one Y less.
+func (h *BufPane) SpawnMultiCursorUp() bool {
+	if h.Cursor.Y == 0 {
+		return false
+	} else {
+		h.Cursor.GotoLoc(buffer.Loc{h.Cursor.X, h.Cursor.Y - 1})
+		h.Cursor.Relocate()
+	}
+
+	c := buffer.NewCursor(h.Buf, buffer.Loc{h.Cursor.X, h.Cursor.Y + 1})
+	h.Buf.AddCursor(c)
+	h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
+	h.Buf.MergeCursors()
+
+	h.Relocate()
+	return true
+}
+
+// SpawnMultiCursorDown creates additional cursor, at the same X (if possible), one Y more.
+func (h *BufPane) SpawnMultiCursorDown() bool {
+	if h.Cursor.Y+1 == h.Buf.LinesNum() {
+		return false
+	} else {
+		h.Cursor.GotoLoc(buffer.Loc{h.Cursor.X, h.Cursor.Y + 1})
+		h.Cursor.Relocate()
+	}
+
+	c := buffer.NewCursor(h.Buf, buffer.Loc{h.Cursor.X, h.Cursor.Y - 1})
+	h.Buf.AddCursor(c)
+	h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
+	h.Buf.MergeCursors()
+	h.Relocate()
+	return true
+}
+
 // SpawnMultiCursorSelect adds a cursor at the beginning of each line of a selection
 func (h *BufPane) SpawnMultiCursorSelect() bool {
 	// Avoid cases where multiple cursors already exist, that would create problems