internal/action/actions.go

   1 package action
   2
   3 import (
   4         "regexp"
   5         "runtime"
   6         "strings"
   7         "time"
   8         "unicode/utf8"
   9
  10         shellquote "github.com/kballard/go-shellquote"
  11         "github.com/zyedidia/clipboard"
  12         "github.com/zyedidia/micro/internal/buffer"
  13         "github.com/zyedidia/micro/internal/config"
  14         "github.com/zyedidia/micro/internal/screen"
  15         "github.com/zyedidia/micro/internal/shell"
  16         "github.com/zyedidia/micro/internal/util"
  17         "github.com/zyedidia/tcell"
  18 )
  19
  20 // ScrollUp is not an action
  21 func (h *BufPane) ScrollUp(n int) {
  22         v := h.GetView()
  23         if v.StartLine >= n {
  24                 v.StartLine -= n
  25                 h.SetView(v)
  26         } else {
  27                 v.StartLine = 0
  28         }
  29 }
  30
  31 // ScrollDown is not an action
  32 func (h *BufPane) ScrollDown(n int) {
  33         v := h.GetView()
  34         if v.StartLine <= h.Buf.LinesNum()-1-n {
  35                 v.StartLine += n
  36                 h.SetView(v)
  37         }
  38 }
  39
  40 // MousePress is the event that should happen when a normal click happens
  41 // This is almost always bound to left click
  42 func (h *BufPane) MousePress(e *tcell.EventMouse) bool {
  43         b := h.Buf
  44         mx, my := e.Position()
  45         mouseLoc := h.LocFromVisual(buffer.Loc{mx, my})
  46         h.Cursor.Loc = mouseLoc
  47         if h.mouseReleased {
  48                 if b.NumCursors() > 1 {
  49                         b.ClearCursors()
  50                         h.Relocate()
  51                         h.Cursor = h.Buf.GetActiveCursor()
  52                         h.Cursor.Loc = mouseLoc
  53                 }
  54                 if time.Since(h.lastClickTime)/time.Millisecond < config.DoubleClickThreshold && (mouseLoc.X == h.lastLoc.X && mouseLoc.Y == h.lastLoc.Y) {
  55                         if h.doubleClick {
  56                                 // Triple click
  57                                 h.lastClickTime = time.Now()
  58
  59                                 h.tripleClick = true
  60                                 h.doubleClick = false
  61
  62                                 h.Cursor.SelectLine()
  63                                 h.Cursor.CopySelection("primary")
  64                         } else {
  65                                 // Double click
  66                                 h.lastClickTime = time.Now()
  67
  68                                 h.doubleClick = true
  69                                 h.tripleClick = false
  70
  71                                 h.Cursor.SelectWord()
  72                                 h.Cursor.CopySelection("primary")
  73                         }
  74                 } else {
  75                         h.doubleClick = false
  76                         h.tripleClick = false
  77                         h.lastClickTime = time.Now()
  78
  79                         h.Cursor.OrigSelection[0] = h.Cursor.Loc
  80                         h.Cursor.CurSelection[0] = h.Cursor.Loc
  81                         h.Cursor.CurSelection[1] = h.Cursor.Loc
  82                 }
  83                 h.mouseReleased = false
  84         } else if !h.mouseReleased {
  85                 if h.tripleClick {
  86                         h.Cursor.AddLineToSelection()
  87                 } else if h.doubleClick {
  88                         h.Cursor.AddWordToSelection()
  89                 } else {
  90                         h.Cursor.SetSelectionEnd(h.Cursor.Loc)
  91                 }
  92         }
  93
  94         h.Cursor.StoreVisualX()
  95         h.lastLoc = mouseLoc
  96         return true
  97 }
  98
  99 // ScrollUpAction scrolls the view up
 100 func (h *BufPane) ScrollUpAction() bool {
 101         h.ScrollUp(util.IntOpt(h.Buf.Settings["scrollspeed"]))
 102         return true
 103 }
 104
 105 // ScrollDownAction scrolls the view up
 106 func (h *BufPane) ScrollDownAction() bool {
 107         h.ScrollDown(util.IntOpt(h.Buf.Settings["scrollspeed"]))
 108         return true
 109 }
 110
 111 // Center centers the view on the cursor
 112 func (h *BufPane) Center() bool {
 113         v := h.GetView()
 114         v.StartLine = h.Cursor.Y - v.Height/2
 115         if v.StartLine+v.Height > h.Buf.LinesNum() {
 116                 v.StartLine = h.Buf.LinesNum() - v.Height
 117         }
 118         if v.StartLine < 0 {
 119                 v.StartLine = 0
 120         }
 121         h.SetView(v)
 122         h.Relocate()
 123         return true
 124 }
 125
 126 // CursorUp moves the cursor up
 127 func (h *BufPane) CursorUp() bool {
 128         h.Cursor.Deselect(true)
 129         h.Cursor.Up()
 130         h.Relocate()
 131         return true
 132 }
 133
 134 // CursorDown moves the cursor down
 135 func (h *BufPane) CursorDown() bool {
 136         h.Cursor.Deselect(true)
 137         h.Cursor.Down()
 138         h.Relocate()
 139         return true
 140 }
 141
 142 // CursorLeft moves the cursor left
 143 func (h *BufPane) CursorLeft() bool {
 144         if h.Cursor.HasSelection() {
 145                 h.Cursor.Deselect(true)
 146         } else {
 147                 tabstospaces := h.Buf.Settings["tabstospaces"].(bool)
 148                 tabmovement := h.Buf.Settings["tabmovement"].(bool)
 149                 if tabstospaces && tabmovement {
 150                         tabsize := int(h.Buf.Settings["tabsize"].(float64))
 151                         line := h.Buf.LineBytes(h.Cursor.Y)
 152                         if h.Cursor.X-tabsize >= 0 && util.IsSpaces(line[h.Cursor.X-tabsize:h.Cursor.X]) && util.IsBytesWhitespace(line[0:h.Cursor.X-tabsize]) {
 153                                 for i := 0; i < tabsize; i++ {
 154                                         h.Cursor.Left()
 155                                 }
 156                         } else {
 157                                 h.Cursor.Left()
 158                         }
 159                 } else {
 160                         h.Cursor.Left()
 161                 }
 162         }
 163         h.Relocate()
 164         return true
 165 }
 166
 167 // CursorRight moves the cursor right
 168 func (h *BufPane) CursorRight() bool {
 169         if h.Cursor.HasSelection() {
 170                 h.Cursor.Deselect(false)
 171                 h.Cursor.Loc = h.Cursor.Loc.Move(1, h.Buf)
 172         } else {
 173                 tabstospaces := h.Buf.Settings["tabstospaces"].(bool)
 174                 tabmovement := h.Buf.Settings["tabmovement"].(bool)
 175                 if tabstospaces && tabmovement {
 176                         tabsize := int(h.Buf.Settings["tabsize"].(float64))
 177                         line := h.Buf.LineBytes(h.Cursor.Y)
 178                         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]) {
 179                                 for i := 0; i < tabsize; i++ {
 180                                         h.Cursor.Right()
 181                                 }
 182                         } else {
 183                                 h.Cursor.Right()
 184                         }
 185                 } else {
 186                         h.Cursor.Right()
 187                 }
 188         }
 189
 190         h.Relocate()
 191         return true
 192 }
 193
 194 // WordRight moves the cursor one word to the right
 195 func (h *BufPane) WordRight() bool {
 196         h.Cursor.Deselect(false)
 197         h.Cursor.WordRight()
 198         h.Relocate()
 199         return true
 200 }
 201
 202 // WordLeft moves the cursor one word to the left
 203 func (h *BufPane) WordLeft() bool {
 204         h.Cursor.Deselect(true)
 205         h.Cursor.WordLeft()
 206         h.Relocate()
 207         return true
 208 }
 209
 210 // SelectUp selects up one line
 211 func (h *BufPane) SelectUp() bool {
 212         if !h.Cursor.HasSelection() {
 213                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 214         }
 215         h.Cursor.Up()
 216         h.Cursor.SelectTo(h.Cursor.Loc)
 217         h.Relocate()
 218         return true
 219 }
 220
 221 // SelectDown selects down one line
 222 func (h *BufPane) SelectDown() bool {
 223         if !h.Cursor.HasSelection() {
 224                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 225         }
 226         h.Cursor.Down()
 227         h.Cursor.SelectTo(h.Cursor.Loc)
 228         h.Relocate()
 229         return true
 230 }
 231
 232 // SelectLeft selects the character to the left of the cursor
 233 func (h *BufPane) SelectLeft() bool {
 234         loc := h.Cursor.Loc
 235         count := h.Buf.End()
 236         if loc.GreaterThan(count) {
 237                 loc = count
 238         }
 239         if !h.Cursor.HasSelection() {
 240                 h.Cursor.OrigSelection[0] = loc
 241         }
 242         h.Cursor.Left()
 243         h.Cursor.SelectTo(h.Cursor.Loc)
 244         h.Relocate()
 245         return true
 246 }
 247
 248 // SelectRight selects the character to the right of the cursor
 249 func (h *BufPane) SelectRight() bool {
 250         loc := h.Cursor.Loc
 251         count := h.Buf.End()
 252         if loc.GreaterThan(count) {
 253                 loc = count
 254         }
 255         if !h.Cursor.HasSelection() {
 256                 h.Cursor.OrigSelection[0] = loc
 257         }
 258         h.Cursor.Right()
 259         h.Cursor.SelectTo(h.Cursor.Loc)
 260         h.Relocate()
 261         return true
 262 }
 263
 264 // SelectWordRight selects the word to the right of the cursor
 265 func (h *BufPane) SelectWordRight() bool {
 266         if !h.Cursor.HasSelection() {
 267                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 268         }
 269         h.Cursor.WordRight()
 270         h.Cursor.SelectTo(h.Cursor.Loc)
 271         h.Relocate()
 272         return true
 273 }
 274
 275 // SelectWordLeft selects the word to the left of the cursor
 276 func (h *BufPane) SelectWordLeft() bool {
 277         if !h.Cursor.HasSelection() {
 278                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 279         }
 280         h.Cursor.WordLeft()
 281         h.Cursor.SelectTo(h.Cursor.Loc)
 282         h.Relocate()
 283         return true
 284 }
 285
 286 // StartOfLine moves the cursor to the start of the text of the line
 287 func (h *BufPane) StartOfText() bool {
 288         h.Cursor.Deselect(true)
 289         h.Cursor.StartOfText()
 290         h.Relocate()
 291         return true
 292 }
 293
 294 // StartOfLine moves the cursor to the start of the line
 295 func (h *BufPane) StartOfLine() bool {
 296         h.Cursor.Deselect(true)
 297         h.Cursor.Start()
 298         h.Relocate()
 299         return true
 300 }
 301
 302 // EndOfLine moves the cursor to the end of the line
 303 func (h *BufPane) EndOfLine() bool {
 304         h.Cursor.Deselect(true)
 305         h.Cursor.End()
 306         h.Relocate()
 307         return true
 308 }
 309
 310 // SelectLine selects the entire current line
 311 func (h *BufPane) SelectLine() bool {
 312         h.Cursor.SelectLine()
 313         h.Relocate()
 314         return true
 315 }
 316
 317 // SelectToStartOfText selects to the start of the text on the current line
 318 func (h *BufPane) SelectToStartOfText() bool {
 319         if !h.Cursor.HasSelection() {
 320                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 321         }
 322         h.Cursor.StartOfText()
 323         h.Cursor.SelectTo(h.Cursor.Loc)
 324         h.Relocate()
 325         return true
 326 }
 327
 328 // SelectToStartOfLine selects to the start of the current line
 329 func (h *BufPane) SelectToStartOfLine() bool {
 330         if !h.Cursor.HasSelection() {
 331                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 332         }
 333         h.Cursor.Start()
 334         h.Cursor.SelectTo(h.Cursor.Loc)
 335         h.Relocate()
 336         return true
 337 }
 338
 339 // SelectToEndOfLine selects to the end of the current line
 340 func (h *BufPane) SelectToEndOfLine() bool {
 341         if !h.Cursor.HasSelection() {
 342                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 343         }
 344         h.Cursor.End()
 345         h.Cursor.SelectTo(h.Cursor.Loc)
 346         h.Relocate()
 347         return true
 348 }
 349
 350 // ParagraphPrevious moves the cursor to the previous empty line, or beginning of the buffer if there's none
 351 func (h *BufPane) ParagraphPrevious() bool {
 352         var line int
 353         for line = h.Cursor.Y; line > 0; line-- {
 354                 if len(h.Buf.LineBytes(line)) == 0 && line != h.Cursor.Y {
 355                         h.Cursor.X = 0
 356                         h.Cursor.Y = line
 357                         break
 358                 }
 359         }
 360         // If no empty line found. move cursor to end of buffer
 361         if line == 0 {
 362                 h.Cursor.Loc = h.Buf.Start()
 363         }
 364         h.Relocate()
 365         return true
 366 }
 367
 368 // ParagraphNext moves the cursor to the next empty line, or end of the buffer if there's none
 369 func (h *BufPane) ParagraphNext() bool {
 370         var line int
 371         for line = h.Cursor.Y; line < h.Buf.LinesNum(); line++ {
 372                 if len(h.Buf.LineBytes(line)) == 0 && line != h.Cursor.Y {
 373                         h.Cursor.X = 0
 374                         h.Cursor.Y = line
 375                         break
 376                 }
 377         }
 378         // If no empty line found. move cursor to end of buffer
 379         if line == h.Buf.LinesNum() {
 380                 h.Cursor.Loc = h.Buf.End()
 381         }
 382         h.Relocate()
 383         return true
 384 }
 385
 386 // Retab changes all tabs to spaces or all spaces to tabs depending
 387 // on the user's settings
 388 func (h *BufPane) Retab() bool {
 389         h.Buf.Retab()
 390         h.Relocate()
 391         return true
 392 }
 393
 394 // CursorStart moves the cursor to the start of the buffer
 395 func (h *BufPane) CursorStart() bool {
 396         h.Cursor.Deselect(true)
 397         h.Cursor.X = 0
 398         h.Cursor.Y = 0
 399         h.Relocate()
 400         return true
 401 }
 402
 403 // CursorEnd moves the cursor to the end of the buffer
 404 func (h *BufPane) CursorEnd() bool {
 405         h.Cursor.Deselect(true)
 406         h.Cursor.Loc = h.Buf.End()
 407         h.Cursor.StoreVisualX()
 408         h.Relocate()
 409         return true
 410 }
 411
 412 // SelectToStart selects the text from the cursor to the start of the buffer
 413 func (h *BufPane) SelectToStart() bool {
 414         if !h.Cursor.HasSelection() {
 415                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 416         }
 417         h.CursorStart()
 418         h.Cursor.SelectTo(h.Buf.Start())
 419         h.Relocate()
 420         return true
 421 }
 422
 423 // SelectToEnd selects the text from the cursor to the end of the buffer
 424 func (h *BufPane) SelectToEnd() bool {
 425         if !h.Cursor.HasSelection() {
 426                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
 427         }
 428         h.CursorEnd()
 429         h.Cursor.SelectTo(h.Buf.End())
 430         h.Relocate()
 431         return true
 432 }
 433
 434 // InsertNewline inserts a newline plus possible some whitespace if autoindent is on
 435 func (h *BufPane) InsertNewline() bool {
 436         // Insert a newline
 437         if h.Cursor.HasSelection() {
 438                 h.Cursor.DeleteSelection()
 439                 h.Cursor.ResetSelection()
 440         }
 441
 442         ws := util.GetLeadingWhitespace(h.Buf.LineBytes(h.Cursor.Y))
 443         cx := h.Cursor.X
 444         h.Buf.Insert(h.Cursor.Loc, "\n")
 445         // h.Cursor.Right()
 446
 447         if h.Buf.Settings["autoindent"].(bool) {
 448                 if cx < len(ws) {
 449                         ws = ws[0:cx]
 450                 }
 451                 h.Buf.Insert(h.Cursor.Loc, string(ws))
 452                 // for i := 0; i < len(ws); i++ {
 453                 //      h.Cursor.Right()
 454                 // }
 455
 456                 // Remove the whitespaces if keepautoindent setting is off
 457                 if util.IsSpacesOrTabs(h.Buf.LineBytes(h.Cursor.Y-1)) && !h.Buf.Settings["keepautoindent"].(bool) {
 458                         line := h.Buf.LineBytes(h.Cursor.Y - 1)
 459                         h.Buf.Remove(buffer.Loc{X: 0, Y: h.Cursor.Y - 1}, buffer.Loc{X: utf8.RuneCount(line), Y: h.Cursor.Y - 1})
 460                 }
 461         }
 462         h.Cursor.LastVisualX = h.Cursor.GetVisualX()
 463         h.Relocate()
 464         return true
 465 }
 466
 467 // Backspace deletes the previous character
 468 func (h *BufPane) Backspace() bool {
 469         if h.Cursor.HasSelection() {
 470                 h.Cursor.DeleteSelection()
 471                 h.Cursor.ResetSelection()
 472         } else if h.Cursor.Loc.GreaterThan(h.Buf.Start()) {
 473                 // We have to do something a bit hacky here because we want to
 474                 // delete the line by first moving left and then deleting backwards
 475                 // but the undo redo would place the cursor in the wrong place
 476                 // So instead we move left, save the position, move back, delete
 477                 // and restore the position
 478
 479                 // If the user is using spaces instead of tabs and they are deleting
 480                 // whitespace at the start of the line, we should delete as if it's a
 481                 // tab (tabSize number of spaces)
 482                 lineStart := util.SliceStart(h.Buf.LineBytes(h.Cursor.Y), h.Cursor.X)
 483                 tabSize := int(h.Buf.Settings["tabsize"].(float64))
 484                 if h.Buf.Settings["tabstospaces"].(bool) && util.IsSpaces(lineStart) && len(lineStart) != 0 && utf8.RuneCount(lineStart)%tabSize == 0 {
 485                         loc := h.Cursor.Loc
 486                         h.Buf.Remove(loc.Move(-tabSize, h.Buf), loc)
 487                 } else {
 488                         loc := h.Cursor.Loc
 489                         h.Buf.Remove(loc.Move(-1, h.Buf), loc)
 490                 }
 491         }
 492         h.Cursor.LastVisualX = h.Cursor.GetVisualX()
 493         h.Relocate()
 494         return true
 495 }
 496
 497 // DeleteWordRight deletes the word to the right of the cursor
 498 func (h *BufPane) DeleteWordRight() bool {
 499         h.SelectWordRight()
 500         if h.Cursor.HasSelection() {
 501                 h.Cursor.DeleteSelection()
 502                 h.Cursor.ResetSelection()
 503         }
 504         h.Relocate()
 505         return true
 506 }
 507
 508 // DeleteWordLeft deletes the word to the left of the cursor
 509 func (h *BufPane) DeleteWordLeft() bool {
 510         h.SelectWordLeft()
 511         if h.Cursor.HasSelection() {
 512                 h.Cursor.DeleteSelection()
 513                 h.Cursor.ResetSelection()
 514         }
 515         h.Relocate()
 516         return true
 517 }
 518
 519 // Delete deletes the next character
 520 func (h *BufPane) Delete() bool {
 521         if h.Cursor.HasSelection() {
 522                 h.Cursor.DeleteSelection()
 523                 h.Cursor.ResetSelection()
 524         } else {
 525                 loc := h.Cursor.Loc
 526                 if loc.LessThan(h.Buf.End()) {
 527                         h.Buf.Remove(loc, loc.Move(1, h.Buf))
 528                 }
 529         }
 530         h.Relocate()
 531         return true
 532 }
 533
 534 // IndentSelection indents the current selection
 535 func (h *BufPane) IndentSelection() bool {
 536         if h.Cursor.HasSelection() {
 537                 start := h.Cursor.CurSelection[0]
 538                 end := h.Cursor.CurSelection[1]
 539                 if end.Y < start.Y {
 540                         start, end = end, start
 541                         h.Cursor.SetSelectionStart(start)
 542                         h.Cursor.SetSelectionEnd(end)
 543                 }
 544
 545                 startY := start.Y
 546                 endY := end.Move(-1, h.Buf).Y
 547                 endX := end.Move(-1, h.Buf).X
 548                 tabsize := int(h.Buf.Settings["tabsize"].(float64))
 549                 indentsize := len(h.Buf.IndentString(tabsize))
 550                 for y := startY; y <= endY; y++ {
 551                         if len(h.Buf.LineBytes(y)) > 0 {
 552                                 h.Buf.Insert(buffer.Loc{X: 0, Y: y}, h.Buf.IndentString(tabsize))
 553                                 if y == startY && start.X > 0 {
 554                                         h.Cursor.SetSelectionStart(start.Move(indentsize, h.Buf))
 555                                 }
 556                                 if y == endY {
 557                                         h.Cursor.SetSelectionEnd(buffer.Loc{X: endX + indentsize + 1, Y: endY})
 558                                 }
 559                         }
 560                 }
 561                 h.Buf.RelocateCursors()
 562
 563                 h.Relocate()
 564                 return true
 565         }
 566         return false
 567 }
 568
 569 // OutdentLine moves the current line back one indentation
 570 func (h *BufPane) OutdentLine() bool {
 571         if h.Cursor.HasSelection() {
 572                 return false
 573         }
 574
 575         for x := 0; x < len(h.Buf.IndentString(util.IntOpt(h.Buf.Settings["tabsize"]))); x++ {
 576                 if len(util.GetLeadingWhitespace(h.Buf.LineBytes(h.Cursor.Y))) == 0 {
 577                         break
 578                 }
 579                 h.Buf.Remove(buffer.Loc{X: 0, Y: h.Cursor.Y}, buffer.Loc{X: 1, Y: h.Cursor.Y})
 580         }
 581         h.Buf.RelocateCursors()
 582         h.Relocate()
 583         return true
 584 }
 585
 586 // OutdentSelection takes the current selection and moves it back one indent level
 587 func (h *BufPane) OutdentSelection() bool {
 588         if h.Cursor.HasSelection() {
 589                 start := h.Cursor.CurSelection[0]
 590                 end := h.Cursor.CurSelection[1]
 591                 if end.Y < start.Y {
 592                         start, end = end, start
 593                         h.Cursor.SetSelectionStart(start)
 594                         h.Cursor.SetSelectionEnd(end)
 595                 }
 596
 597                 startY := start.Y
 598                 endY := end.Move(-1, h.Buf).Y
 599                 for y := startY; y <= endY; y++ {
 600                         for x := 0; x < len(h.Buf.IndentString(util.IntOpt(h.Buf.Settings["tabsize"]))); x++ {
 601                                 if len(util.GetLeadingWhitespace(h.Buf.LineBytes(y))) == 0 {
 602                                         break
 603                                 }
 604                                 h.Buf.Remove(buffer.Loc{X: 0, Y: y}, buffer.Loc{X: 1, Y: y})
 605                         }
 606                 }
 607                 h.Buf.RelocateCursors()
 608
 609                 h.Relocate()
 610                 return true
 611         }
 612         return false
 613 }
 614
 615 // Autocomplete cycles the suggestions and performs autocompletion if there are suggestions
 616 func (h *BufPane) Autocomplete() bool {
 617         b := h.Buf
 618
 619         if h.Cursor.HasSelection() {
 620                 return false
 621         }
 622
 623         if b.HasSuggestions {
 624                 b.CycleAutocomplete(true)
 625                 return true
 626         }
 627         return b.Autocomplete(buffer.BufferComplete)
 628 }
 629
 630 // CycleAutocompleteBack cycles back in the autocomplete suggestion list
 631 func (h *BufPane) CycleAutocompleteBack() bool {
 632         if h.Cursor.HasSelection() {
 633                 return false
 634         }
 635
 636         if h.Buf.HasSuggestions {
 637                 h.Buf.CycleAutocomplete(false)
 638                 return true
 639         }
 640         return false
 641 }
 642
 643 // InsertTab inserts a tab or spaces
 644 func (h *BufPane) InsertTab() bool {
 645         b := h.Buf
 646         indent := b.IndentString(util.IntOpt(b.Settings["tabsize"]))
 647         tabBytes := len(indent)
 648         bytesUntilIndent := tabBytes - (h.Cursor.GetVisualX() % tabBytes)
 649         b.Insert(h.Cursor.Loc, indent[:bytesUntilIndent])
 650         h.Relocate()
 651         return true
 652 }
 653
 654 // SaveAll saves all open buffers
 655 func (h *BufPane) SaveAll() bool {
 656         for _, b := range buffer.OpenBuffers {
 657                 b.Save()
 658         }
 659         return true
 660 }
 661
 662 // Save the buffer to disk
 663 func (h *BufPane) Save() bool {
 664         // If this is an empty buffer, ask for a filename
 665         if h.Buf.Path == "" {
 666                 h.SaveAs()
 667         } else {
 668                 noPrompt := h.saveBufToFile(h.Buf.Path, "Save")
 669                 if noPrompt {
 670                         return true
 671                 }
 672         }
 673
 674         return false
 675 }
 676
 677 // SaveAs saves the buffer to disk with the given name
 678 func (h *BufPane) SaveAs() bool {
 679         InfoBar.Prompt("Filename: ", "", "Save", nil, func(resp string, canceled bool) {
 680                 if !canceled {
 681                         // the filename might or might not be quoted, so unquote first then join the strings.
 682                         args, err := shellquote.Split(resp)
 683                         if err != nil {
 684                                 InfoBar.Error("Error parsing arguments: ", err)
 685                                 return
 686                         }
 687                         if len(args) == 0 {
 688                                 InfoBar.Error("No filename given")
 689                                 return
 690                         }
 691                         filename := strings.Join(args, " ")
 692                         noPrompt := h.saveBufToFile(filename, "SaveAs")
 693                         if noPrompt {
 694                                 h.completeAction("SaveAs")
 695                         }
 696                 }
 697         })
 698         return false
 699 }
 700
 701 // This function saves the buffer to `filename` and changes the buffer's path and name
 702 // to `filename` if the save is successful
 703 func (h *BufPane) saveBufToFile(filename string, action string) bool {
 704         err := h.Buf.SaveAs(filename)
 705         if err != nil {
 706                 if strings.HasSuffix(err.Error(), "permission denied") {
 707                         InfoBar.YNPrompt("Permission denied. Do you want to save this file using sudo? (y,n)", func(yes, canceled bool) {
 708                                 if yes && !canceled {
 709                                         err = h.Buf.SaveAsWithSudo(filename)
 710                                         if err != nil {
 711                                                 InfoBar.Error(err)
 712                                         } else {
 713                                                 h.Buf.Path = filename
 714                                                 h.Buf.SetName(filename)
 715                                                 InfoBar.Message("Saved " + filename)
 716                                         }
 717                                         h.completeAction(action)
 718                                 }
 719                         })
 720                         return false
 721                 } else {
 722                         InfoBar.Error(err)
 723                 }
 724         } else {
 725                 h.Buf.Path = filename
 726                 h.Buf.SetName(filename)
 727                 InfoBar.Message("Saved " + filename)
 728         }
 729         return true
 730 }
 731
 732 // Find opens a prompt and searches forward for the input
 733 func (h *BufPane) Find() bool {
 734         h.searchOrig = h.Cursor.Loc
 735         InfoBar.Prompt("Find: ", "", "Find", func(resp string) {
 736                 // Event callback
 737                 match, found, _ := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
 738                 if found {
 739                         h.Cursor.SetSelectionStart(match[0])
 740                         h.Cursor.SetSelectionEnd(match[1])
 741                         h.Cursor.OrigSelection[0] = h.Cursor.CurSelection[0]
 742                         h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
 743                         h.Cursor.GotoLoc(match[1])
 744                 } else {
 745                         h.Cursor.GotoLoc(h.searchOrig)
 746                         h.Cursor.ResetSelection()
 747                 }
 748                 h.Relocate()
 749         }, func(resp string, canceled bool) {
 750                 // Finished callback
 751                 if !canceled {
 752                         match, found, err := h.Buf.FindNext(resp, h.Buf.Start(), h.Buf.End(), h.searchOrig, true, true)
 753                         if err != nil {
 754                                 InfoBar.Error(err)
 755                         }
 756                         if found {
 757                                 h.Cursor.SetSelectionStart(match[0])
 758                                 h.Cursor.SetSelectionEnd(match[1])
 759                                 h.Cursor.OrigSelection[0] = h.Cursor.CurSelection[0]
 760                                 h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
 761                                 h.Cursor.GotoLoc(h.Cursor.CurSelection[1])
 762                                 h.lastSearch = resp
 763                         } else {
 764                                 h.Cursor.ResetSelection()
 765                                 InfoBar.Message("No matches found")
 766                         }
 767                 } else {
 768                         h.Cursor.ResetSelection()
 769                 }
 770                 h.Relocate()
 771         })
 772
 773         return true
 774 }
 775
 776 // FindNext searches forwards for the last used search term
 777 func (h *BufPane) FindNext() bool {
 778         // If the cursor is at the start of a selection and we search we want
 779         // to search from the end of the selection in the case that
 780         // the selection is a search result in which case we wouldn't move at
 781         // at all which would be bad
 782         searchLoc := h.Cursor.Loc
 783         if h.Cursor.HasSelection() {
 784                 searchLoc = h.Cursor.CurSelection[1]
 785         }
 786         match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, true, true)
 787         if err != nil {
 788                 InfoBar.Error(err)
 789         }
 790         if found {
 791                 h.Cursor.SetSelectionStart(match[0])
 792                 h.Cursor.SetSelectionEnd(match[1])
 793                 h.Cursor.OrigSelection[0] = h.Cursor.CurSelection[0]
 794                 h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
 795                 h.Cursor.Loc = h.Cursor.CurSelection[1]
 796         } else {
 797                 h.Cursor.ResetSelection()
 798         }
 799         h.Relocate()
 800         return true
 801 }
 802
 803 // FindPrevious searches backwards for the last used search term
 804 func (h *BufPane) FindPrevious() bool {
 805         // If the cursor is at the end of a selection and we search we want
 806         // to search from the beginning of the selection in the case that
 807         // the selection is a search result in which case we wouldn't move at
 808         // at all which would be bad
 809         searchLoc := h.Cursor.Loc
 810         if h.Cursor.HasSelection() {
 811                 searchLoc = h.Cursor.CurSelection[0]
 812         }
 813         match, found, err := h.Buf.FindNext(h.lastSearch, h.Buf.Start(), h.Buf.End(), searchLoc, false, true)
 814         if err != nil {
 815                 InfoBar.Error(err)
 816         }
 817         if found {
 818                 h.Cursor.SetSelectionStart(match[0])
 819                 h.Cursor.SetSelectionEnd(match[1])
 820                 h.Cursor.OrigSelection[0] = h.Cursor.CurSelection[0]
 821                 h.Cursor.OrigSelection[1] = h.Cursor.CurSelection[1]
 822                 h.Cursor.Loc = h.Cursor.CurSelection[1]
 823         } else {
 824                 h.Cursor.ResetSelection()
 825         }
 826         h.Relocate()
 827         return true
 828 }
 829
 830 // Undo undoes the last action
 831 func (h *BufPane) Undo() bool {
 832         h.Buf.Undo()
 833         InfoBar.Message("Undid action")
 834         h.Relocate()
 835         return true
 836 }
 837
 838 // Redo redoes the last action
 839 func (h *BufPane) Redo() bool {
 840         h.Buf.Redo()
 841         InfoBar.Message("Redid action")
 842         h.Relocate()
 843         return true
 844 }
 845
 846 // Copy the selection to the system clipboard
 847 func (h *BufPane) Copy() bool {
 848         if h.Cursor.HasSelection() {
 849                 h.Cursor.CopySelection("clipboard")
 850                 h.freshClip = true
 851                 if clipboard.Unsupported {
 852                         InfoBar.Message("Copied selection (install xclip for external clipboard)")
 853                 } else {
 854                         InfoBar.Message("Copied selection")
 855                 }
 856         }
 857         h.Relocate()
 858         return true
 859 }
 860
 861 // CutLine cuts the current line to the clipboard
 862 func (h *BufPane) CutLine() bool {
 863         h.Cursor.SelectLine()
 864         if !h.Cursor.HasSelection() {
 865                 return false
 866         }
 867         if h.freshClip == true {
 868                 if h.Cursor.HasSelection() {
 869                         if clip, err := clipboard.ReadAll("clipboard"); err != nil {
 870                                 // messenger.Error(err)
 871                         } else {
 872                                 clipboard.WriteAll(clip+string(h.Cursor.GetSelection()), "clipboard")
 873                         }
 874                 }
 875         } else if time.Since(h.lastCutTime)/time.Second > 10*time.Second || h.freshClip == false {
 876                 h.Copy()
 877         }
 878         h.freshClip = true
 879         h.lastCutTime = time.Now()
 880         h.Cursor.DeleteSelection()
 881         h.Cursor.ResetSelection()
 882         InfoBar.Message("Cut line")
 883         h.Relocate()
 884         return true
 885 }
 886
 887 // Cut the selection to the system clipboard
 888 func (h *BufPane) Cut() bool {
 889         if h.Cursor.HasSelection() {
 890                 h.Cursor.CopySelection("clipboard")
 891                 h.Cursor.DeleteSelection()
 892                 h.Cursor.ResetSelection()
 893                 h.freshClip = true
 894                 InfoBar.Message("Cut selection")
 895
 896                 h.Relocate()
 897                 return true
 898         } else {
 899                 return h.CutLine()
 900         }
 901 }
 902
 903 // DuplicateLine duplicates the current line or selection
 904 func (h *BufPane) DuplicateLine() bool {
 905         if h.Cursor.HasSelection() {
 906                 h.Buf.Insert(h.Cursor.CurSelection[1], string(h.Cursor.GetSelection()))
 907         } else {
 908                 h.Cursor.End()
 909                 h.Buf.Insert(h.Cursor.Loc, "\n"+string(h.Buf.LineBytes(h.Cursor.Y)))
 910                 // h.Cursor.Right()
 911         }
 912
 913         InfoBar.Message("Duplicated line")
 914         h.Relocate()
 915         return true
 916 }
 917
 918 // DeleteLine deletes the current line
 919 func (h *BufPane) DeleteLine() bool {
 920         h.Cursor.SelectLine()
 921         if !h.Cursor.HasSelection() {
 922                 return false
 923         }
 924         h.Cursor.DeleteSelection()
 925         h.Cursor.ResetSelection()
 926         InfoBar.Message("Deleted line")
 927         h.Relocate()
 928         return true
 929 }
 930
 931 // MoveLinesUp moves up the current line or selected lines if any
 932 func (h *BufPane) MoveLinesUp() bool {
 933         if h.Cursor.HasSelection() {
 934                 if h.Cursor.CurSelection[0].Y == 0 {
 935                         InfoBar.Message("Cannot move further up")
 936                         return false
 937                 }
 938                 start := h.Cursor.CurSelection[0].Y
 939                 end := h.Cursor.CurSelection[1].Y
 940                 if start > end {
 941                         end, start = start, end
 942                 }
 943
 944                 h.Buf.MoveLinesUp(
 945                         start,
 946                         end,
 947                 )
 948                 h.Cursor.CurSelection[1].Y -= 1
 949         } else {
 950                 if h.Cursor.Loc.Y == 0 {
 951                         InfoBar.Message("Cannot move further up")
 952                         return false
 953                 }
 954                 h.Buf.MoveLinesUp(
 955                         h.Cursor.Loc.Y,
 956                         h.Cursor.Loc.Y+1,
 957                 )
 958         }
 959
 960         h.Relocate()
 961         return true
 962 }
 963
 964 // MoveLinesDown moves down the current line or selected lines if any
 965 func (h *BufPane) MoveLinesDown() bool {
 966         if h.Cursor.HasSelection() {
 967                 if h.Cursor.CurSelection[1].Y >= h.Buf.LinesNum() {
 968                         InfoBar.Message("Cannot move further down")
 969                         return false
 970                 }
 971                 start := h.Cursor.CurSelection[0].Y
 972                 end := h.Cursor.CurSelection[1].Y
 973                 if start > end {
 974                         end, start = start, end
 975                 }
 976
 977                 h.Buf.MoveLinesDown(
 978                         start,
 979                         end,
 980                 )
 981         } else {
 982                 if h.Cursor.Loc.Y >= h.Buf.LinesNum()-1 {
 983                         InfoBar.Message("Cannot move further down")
 984                         return false
 985                 }
 986                 h.Buf.MoveLinesDown(
 987                         h.Cursor.Loc.Y,
 988                         h.Cursor.Loc.Y+1,
 989                 )
 990         }
 991
 992         h.Relocate()
 993         return true
 994 }
 995
 996 // Paste whatever is in the system clipboard into the buffer
 997 // Delete and paste if the user has a selection
 998 func (h *BufPane) Paste() bool {
 999         clip, _ := clipboard.ReadAll("clipboard")
1000         h.paste(clip)
1001         h.Relocate()
1002         return true
1003 }
1004
1005 // PastePrimary pastes from the primary clipboard (only use on linux)
1006 func (h *BufPane) PastePrimary() bool {
1007         clip, _ := clipboard.ReadAll("primary")
1008         h.paste(clip)
1009         h.Relocate()
1010         return true
1011 }
1012
1013 func (h *BufPane) paste(clip string) {
1014         if h.Buf.Settings["smartpaste"].(bool) {
1015                 if h.Cursor.X > 0 && len(util.GetLeadingWhitespace([]byte(strings.TrimLeft(clip, "\r\n")))) == 0 {
1016                         leadingWS := util.GetLeadingWhitespace(h.Buf.LineBytes(h.Cursor.Y))
1017                         clip = strings.Replace(clip, "\n", "\n"+string(leadingWS), -1)
1018                 }
1019         }
1020
1021         if h.Cursor.HasSelection() {
1022                 h.Cursor.DeleteSelection()
1023                 h.Cursor.ResetSelection()
1024         }
1025
1026         h.Buf.Insert(h.Cursor.Loc, clip)
1027         // h.Cursor.Loc = h.Cursor.Loc.Move(Count(clip), h.Buf)
1028         h.freshClip = false
1029         if clipboard.Unsupported {
1030                 InfoBar.Message("Pasted clipboard (install xclip for external clipboard)")
1031         } else {
1032                 InfoBar.Message("Pasted clipboard")
1033         }
1034 }
1035
1036 // JumpToMatchingBrace moves the cursor to the matching brace if it is
1037 // currently on a brace
1038 func (h *BufPane) JumpToMatchingBrace() bool {
1039         for _, bp := range buffer.BracePairs {
1040                 r := h.Cursor.RuneUnder(h.Cursor.X)
1041                 rl := h.Cursor.RuneUnder(h.Cursor.X - 1)
1042                 if r == bp[0] || r == bp[1] || rl == bp[0] || rl == bp[1] {
1043                         matchingBrace, left := h.Buf.FindMatchingBrace(bp, h.Cursor.Loc)
1044                         if left {
1045                                 h.Cursor.GotoLoc(matchingBrace)
1046                         } else {
1047                                 h.Cursor.GotoLoc(matchingBrace.Move(1, h.Buf))
1048                         }
1049                 }
1050         }
1051
1052         h.Relocate()
1053         return true
1054 }
1055
1056 // SelectAll selects the entire buffer
1057 func (h *BufPane) SelectAll() bool {
1058         h.Cursor.SetSelectionStart(h.Buf.Start())
1059         h.Cursor.SetSelectionEnd(h.Buf.End())
1060         // Put the cursor at the beginning
1061         h.Cursor.X = 0
1062         h.Cursor.Y = 0
1063         h.Relocate()
1064         return true
1065 }
1066
1067 // OpenFile opens a new file in the buffer
1068 func (h *BufPane) OpenFile() bool {
1069         InfoBar.Prompt("> ", "open ", "Open", nil, func(resp string, canceled bool) {
1070                 if !canceled {
1071                         h.HandleCommand(resp)
1072                 }
1073         })
1074         return true
1075 }
1076
1077 // Start moves the viewport to the start of the buffer
1078 func (h *BufPane) Start() bool {
1079         v := h.GetView()
1080         v.StartLine = 0
1081         h.SetView(v)
1082         return true
1083 }
1084
1085 // End moves the viewport to the end of the buffer
1086 func (h *BufPane) End() bool {
1087         // TODO: softwrap problems?
1088         v := h.GetView()
1089         if v.Height > h.Buf.LinesNum() {
1090                 v.StartLine = 0
1091                 h.SetView(v)
1092         } else {
1093                 v.StartLine = h.Buf.LinesNum() - v.Height
1094                 h.SetView(v)
1095         }
1096         return true
1097 }
1098
1099 // PageUp scrolls the view up a page
1100 func (h *BufPane) PageUp() bool {
1101         v := h.GetView()
1102         if v.StartLine > v.Height {
1103                 h.ScrollUp(v.Height)
1104         } else {
1105                 v.StartLine = 0
1106         }
1107         h.SetView(v)
1108         return true
1109 }
1110
1111 // PageDown scrolls the view down a page
1112 func (h *BufPane) PageDown() bool {
1113         v := h.GetView()
1114         if h.Buf.LinesNum()-(v.StartLine+v.Height) > v.Height {
1115                 h.ScrollDown(v.Height)
1116         } else if h.Buf.LinesNum() >= v.Height {
1117                 v.StartLine = h.Buf.LinesNum() - v.Height
1118         }
1119         return true
1120 }
1121
1122 // SelectPageUp selects up one page
1123 func (h *BufPane) SelectPageUp() bool {
1124         if !h.Cursor.HasSelection() {
1125                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
1126         }
1127         h.Cursor.UpN(h.GetView().Height)
1128         h.Cursor.SelectTo(h.Cursor.Loc)
1129         h.Relocate()
1130         return true
1131 }
1132
1133 // SelectPageDown selects down one page
1134 func (h *BufPane) SelectPageDown() bool {
1135         if !h.Cursor.HasSelection() {
1136                 h.Cursor.OrigSelection[0] = h.Cursor.Loc
1137         }
1138         h.Cursor.DownN(h.GetView().Height)
1139         h.Cursor.SelectTo(h.Cursor.Loc)
1140         h.Relocate()
1141         return true
1142 }
1143
1144 // CursorPageUp places the cursor a page up
1145 func (h *BufPane) CursorPageUp() bool {
1146         h.Cursor.Deselect(true)
1147
1148         if h.Cursor.HasSelection() {
1149                 h.Cursor.Loc = h.Cursor.CurSelection[0]
1150                 h.Cursor.ResetSelection()
1151                 h.Cursor.StoreVisualX()
1152         }
1153         h.Cursor.UpN(h.GetView().Height)
1154         h.Relocate()
1155         return true
1156 }
1157
1158 // CursorPageDown places the cursor a page up
1159 func (h *BufPane) CursorPageDown() bool {
1160         h.Cursor.Deselect(false)
1161
1162         if h.Cursor.HasSelection() {
1163                 h.Cursor.Loc = h.Cursor.CurSelection[1]
1164                 h.Cursor.ResetSelection()
1165                 h.Cursor.StoreVisualX()
1166         }
1167         h.Cursor.DownN(h.GetView().Height)
1168         h.Relocate()
1169         return true
1170 }
1171
1172 // HalfPageUp scrolls the view up half a page
1173 func (h *BufPane) HalfPageUp() bool {
1174         v := h.GetView()
1175         if v.StartLine > v.Height/2 {
1176                 h.ScrollUp(v.Height / 2)
1177         } else {
1178                 v.StartLine = 0
1179         }
1180         h.SetView(v)
1181         return true
1182 }
1183
1184 // HalfPageDown scrolls the view down half a page
1185 func (h *BufPane) HalfPageDown() bool {
1186         v := h.GetView()
1187         if h.Buf.LinesNum()-(v.StartLine+v.Height) > v.Height/2 {
1188                 h.ScrollDown(v.Height / 2)
1189         } else {
1190                 if h.Buf.LinesNum() >= v.Height {
1191                         v.StartLine = h.Buf.LinesNum() - v.Height
1192                 }
1193         }
1194         h.SetView(v)
1195         return true
1196 }
1197
1198 // ToggleRuler turns line numbers off and on
1199 func (h *BufPane) ToggleRuler() bool {
1200         if !h.Buf.Settings["ruler"].(bool) {
1201                 h.Buf.Settings["ruler"] = true
1202                 InfoBar.Message("Enabled ruler")
1203         } else {
1204                 h.Buf.Settings["ruler"] = false
1205                 InfoBar.Message("Disabled ruler")
1206         }
1207         return true
1208 }
1209
1210 // ClearStatus clears the messenger bar
1211 func (h *BufPane) ClearStatus() bool {
1212         InfoBar.Message("")
1213         return true
1214 }
1215
1216 // ToggleHelp toggles the help screen
1217 func (h *BufPane) ToggleHelp() bool {
1218         if h.Buf.Type == buffer.BTHelp {
1219                 h.Quit()
1220         } else {
1221                 h.openHelp("help")
1222         }
1223         return true
1224 }
1225
1226 // ToggleKeyMenu toggles the keymenu option and resizes all tabs
1227 func (h *BufPane) ToggleKeyMenu() bool {
1228         config.GlobalSettings["keymenu"] = !config.GetGlobalOption("keymenu").(bool)
1229         Tabs.Resize()
1230         return true
1231 }
1232
1233 // ShellMode opens a terminal to run a shell command
1234 func (h *BufPane) ShellMode() bool {
1235         InfoBar.Prompt("$ ", "", "Shell", nil, func(resp string, canceled bool) {
1236                 if !canceled {
1237                         // The true here is for openTerm to make the command interactive
1238                         shell.RunInteractiveShell(resp, true, false)
1239                 }
1240         })
1241
1242         return true
1243 }
1244
1245 // CommandMode lets the user enter a command
1246 func (h *BufPane) CommandMode() bool {
1247         InfoBar.Prompt("> ", "", "Command", nil, func(resp string, canceled bool) {
1248                 if !canceled {
1249                         h.HandleCommand(resp)
1250                 }
1251         })
1252         return true
1253 }
1254
1255 // ToggleOverwriteMode lets the user toggle the text overwrite mode
1256 func (h *BufPane) ToggleOverwriteMode() bool {
1257         h.isOverwriteMode = !h.isOverwriteMode
1258         return true
1259 }
1260
1261 // Escape leaves current mode
1262 func (h *BufPane) Escape() bool {
1263         return true
1264 }
1265
1266 // Quit this will close the current tab or view that is open
1267 func (h *BufPane) Quit() bool {
1268         quit := func() {
1269                 h.Buf.Close()
1270                 if len(MainTab().Panes) > 1 {
1271                         h.Unsplit()
1272                 } else if len(Tabs.List) > 1 {
1273                         Tabs.RemoveTab(h.splitID)
1274                 } else {
1275                         screen.Screen.Fini()
1276                         InfoBar.Close()
1277                         runtime.Goexit()
1278                 }
1279         }
1280         if h.Buf.Modified() {
1281                 // if config.GlobalSettings["autosave"].(float64) > 0 {
1282                 // autosave on means we automatically save when quitting
1283                 // h.Save()
1284                 // quit()
1285                 // } else {
1286                 InfoBar.YNPrompt("Save changes to "+h.Buf.GetName()+" before closing? (y,n,esc)", func(yes, canceled bool) {
1287                         if !canceled && !yes {
1288                                 quit()
1289                         } else if !canceled && yes {
1290                                 h.Save()
1291                                 quit()
1292                         }
1293                 })
1294                 // }
1295         } else {
1296                 quit()
1297         }
1298         return true
1299 }
1300
1301 // QuitAll quits the whole editor; all splits and tabs
1302 func (h *BufPane) QuitAll() bool {
1303         anyModified := false
1304         for _, b := range buffer.OpenBuffers {
1305                 if b.Modified() {
1306                         anyModified = true
1307                         break
1308                 }
1309         }
1310
1311         quit := func() {
1312                 for _, b := range buffer.OpenBuffers {
1313                         b.Close()
1314                 }
1315                 screen.Screen.Fini()
1316                 InfoBar.Close()
1317                 runtime.Goexit()
1318         }
1319
1320         if anyModified {
1321                 InfoBar.YNPrompt("Quit micro? (all open buffers will be closed without saving)", func(yes, canceled bool) {
1322                         if !canceled && yes {
1323                                 quit()
1324                         }
1325                 })
1326         } else {
1327                 quit()
1328         }
1329
1330         return true
1331 }
1332
1333 // AddTab adds a new tab with an empty buffer
1334 func (h *BufPane) AddTab() bool {
1335         width, height := screen.Screen.Size()
1336         iOffset := config.GetInfoBarOffset()
1337         b := buffer.NewBufferFromString("", "", buffer.BTDefault)
1338         tp := NewTabFromBuffer(0, 0, width, height-iOffset, b)
1339         Tabs.AddTab(tp)
1340         Tabs.SetActive(len(Tabs.List) - 1)
1341
1342         return true
1343 }
1344
1345 // PreviousTab switches to the previous tab in the tab list
1346 func (h *BufPane) PreviousTab() bool {
1347         a := Tabs.Active()
1348         Tabs.SetActive(util.Clamp(a-1, 0, len(Tabs.List)-1))
1349
1350         return true
1351 }
1352
1353 // NextTab switches to the next tab in the tab list
1354 func (h *BufPane) NextTab() bool {
1355         a := Tabs.Active()
1356         Tabs.SetActive(util.Clamp(a+1, 0, len(Tabs.List)-1))
1357         return true
1358 }
1359
1360 // VSplitAction opens an empty vertical split
1361 func (h *BufPane) VSplitAction() bool {
1362         h.VSplitBuf(buffer.NewBufferFromString("", "", buffer.BTDefault))
1363
1364         return true
1365 }
1366
1367 // HSplitAction opens an empty horizontal split
1368 func (h *BufPane) HSplitAction() bool {
1369         h.HSplitBuf(buffer.NewBufferFromString("", "", buffer.BTDefault))
1370
1371         return true
1372 }
1373
1374 // Unsplit closes all splits in the current tab except the active one
1375 func (h *BufPane) Unsplit() bool {
1376         n := MainTab().GetNode(h.splitID)
1377         n.Unsplit()
1378
1379         MainTab().RemovePane(MainTab().GetPane(h.splitID))
1380         MainTab().Resize()
1381         MainTab().SetActive(len(MainTab().Panes) - 1)
1382         return true
1383 }
1384
1385 // NextSplit changes the view to the next split
1386 func (h *BufPane) NextSplit() bool {
1387         a := MainTab().active
1388         if a < len(MainTab().Panes)-1 {
1389                 a++
1390         } else {
1391                 a = 0
1392         }
1393
1394         MainTab().SetActive(a)
1395
1396         return true
1397 }
1398
1399 // PreviousSplit changes the view to the previous split
1400 func (h *BufPane) PreviousSplit() bool {
1401         a := MainTab().active
1402         if a > 0 {
1403                 a--
1404         } else {
1405                 a = len(MainTab().Panes) - 1
1406         }
1407         MainTab().SetActive(a)
1408
1409         return true
1410 }
1411
1412 var curmacro []interface{}
1413 var recording_macro bool
1414
1415 // ToggleMacro toggles recording of a macro
1416 func (h *BufPane) ToggleMacro() bool {
1417         recording_macro = !recording_macro
1418         if recording_macro {
1419                 curmacro = []interface{}{}
1420                 InfoBar.Message("Recording")
1421         } else {
1422                 InfoBar.Message("Stopped recording")
1423         }
1424         h.Relocate()
1425         return true
1426 }
1427
1428 // PlayMacro plays back the most recently recorded macro
1429 func (h *BufPane) PlayMacro() bool {
1430         if recording_macro {
1431                 return false
1432         }
1433         for _, action := range curmacro {
1434                 switch t := action.(type) {
1435                 case rune:
1436                         h.DoRuneInsert(t)
1437                 case func(*BufPane) bool:
1438                         t(h)
1439                 }
1440         }
1441         h.Relocate()
1442         return true
1443 }
1444
1445 // SpawnMultiCursor creates a new multiple cursor at the next occurrence of the current selection or current word
1446 func (h *BufPane) SpawnMultiCursor() bool {
1447         spawner := h.Buf.GetCursor(h.Buf.NumCursors() - 1)
1448         if !spawner.HasSelection() {
1449                 spawner.SelectWord()
1450                 h.multiWord = true
1451                 h.Relocate()
1452                 return true
1453         }
1454
1455         sel := spawner.GetSelection()
1456         searchStart := spawner.CurSelection[1]
1457
1458         search := string(sel)
1459         search = regexp.QuoteMeta(search)
1460         if h.multiWord {
1461                 search = "\\b" + search + "\\b"
1462         }
1463         match, found, err := h.Buf.FindNext(search, h.Buf.Start(), h.Buf.End(), searchStart, true, true)
1464         if err != nil {
1465                 InfoBar.Error(err)
1466         }
1467         if found {
1468                 c := buffer.NewCursor(h.Buf, buffer.Loc{})
1469                 c.SetSelectionStart(match[0])
1470                 c.SetSelectionEnd(match[1])
1471                 c.OrigSelection[0] = c.CurSelection[0]
1472                 c.OrigSelection[1] = c.CurSelection[1]
1473                 c.Loc = c.CurSelection[1]
1474
1475                 h.Buf.AddCursor(c)
1476                 h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
1477                 h.Buf.MergeCursors()
1478         } else {
1479                 InfoBar.Message("No matches found")
1480         }
1481
1482         h.Relocate()
1483         return true
1484 }
1485
1486 // SpawnMultiCursorUp creates additional cursor, at the same X (if possible), one Y less.
1487 func (h *BufPane) SpawnMultiCursorUp() bool {
1488         if h.Cursor.Y == 0 {
1489                 return false
1490         } else {
1491                 h.Cursor.GotoLoc(buffer.Loc{h.Cursor.X, h.Cursor.Y - 1})
1492                 h.Cursor.Relocate()
1493         }
1494
1495         c := buffer.NewCursor(h.Buf, buffer.Loc{h.Cursor.X, h.Cursor.Y + 1})
1496         h.Buf.AddCursor(c)
1497         h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
1498         h.Buf.MergeCursors()
1499
1500         h.Relocate()
1501         return true
1502 }
1503
1504 // SpawnMultiCursorUp creates additional cursor, at the same X (if possible), one Y more.
1505 func (h *BufPane) SpawnMultiCursorDown() bool {
1506         if h.Cursor.Y+1 == h.Buf.LinesNum() {
1507                 return false
1508         } else {
1509                 h.Cursor.GotoLoc(buffer.Loc{h.Cursor.X, h.Cursor.Y + 1})
1510                 h.Cursor.Relocate()
1511         }
1512
1513         c := buffer.NewCursor(h.Buf, buffer.Loc{h.Cursor.X, h.Cursor.Y - 1})
1514         h.Buf.AddCursor(c)
1515         h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
1516         h.Buf.MergeCursors()
1517         h.Relocate()
1518         return true
1519 }
1520
1521 // SpawnMultiCursorSelect adds a cursor at the beginning of each line of a selection
1522 func (h *BufPane) SpawnMultiCursorSelect() bool {
1523         // Avoid cases where multiple cursors already exist, that would create problems
1524         if h.Buf.NumCursors() > 1 {
1525                 return false
1526         }
1527
1528         var startLine int
1529         var endLine int
1530
1531         a, b := h.Cursor.CurSelection[0].Y, h.Cursor.CurSelection[1].Y
1532         if a > b {
1533                 startLine, endLine = b, a
1534         } else {
1535                 startLine, endLine = a, b
1536         }
1537
1538         if h.Cursor.HasSelection() {
1539                 h.Cursor.ResetSelection()
1540                 h.Cursor.GotoLoc(buffer.Loc{0, startLine})
1541
1542                 for i := startLine; i <= endLine; i++ {
1543                         c := buffer.NewCursor(h.Buf, buffer.Loc{0, i})
1544                         c.StoreVisualX()
1545                         h.Buf.AddCursor(c)
1546                 }
1547                 h.Buf.MergeCursors()
1548         } else {
1549                 return false
1550         }
1551         InfoBar.Message("Added cursors from selection")
1552         return true
1553 }
1554
1555 // MouseMultiCursor is a mouse action which puts a new cursor at the mouse position
1556 func (h *BufPane) MouseMultiCursor(e *tcell.EventMouse) bool {
1557         b := h.Buf
1558         mx, my := e.Position()
1559         mouseLoc := h.LocFromVisual(buffer.Loc{X: mx, Y: my})
1560         c := buffer.NewCursor(b, mouseLoc)
1561         b.AddCursor(c)
1562         b.MergeCursors()
1563
1564         return true
1565 }
1566
1567 // SkipMultiCursor moves the current multiple cursor to the next available position
1568 func (h *BufPane) SkipMultiCursor() bool {
1569         lastC := h.Buf.GetCursor(h.Buf.NumCursors() - 1)
1570         sel := lastC.GetSelection()
1571         searchStart := lastC.CurSelection[1]
1572
1573         search := string(sel)
1574         search = regexp.QuoteMeta(search)
1575         if h.multiWord {
1576                 search = "\\b" + search + "\\b"
1577         }
1578
1579         match, found, err := h.Buf.FindNext(search, h.Buf.Start(), h.Buf.End(), searchStart, true, true)
1580         if err != nil {
1581                 InfoBar.Error(err)
1582         }
1583         if found {
1584                 lastC.SetSelectionStart(match[0])
1585                 lastC.SetSelectionEnd(match[1])
1586                 lastC.OrigSelection[0] = lastC.CurSelection[0]
1587                 lastC.OrigSelection[1] = lastC.CurSelection[1]
1588                 lastC.Loc = lastC.CurSelection[1]
1589
1590                 h.Buf.MergeCursors()
1591                 h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
1592         } else {
1593                 InfoBar.Message("No matches found")
1594         }
1595         h.Relocate()
1596         return true
1597 }
1598
1599 // RemoveMultiCursor removes the latest multiple cursor
1600 func (h *BufPane) RemoveMultiCursor() bool {
1601         if h.Buf.NumCursors() > 1 {
1602                 h.Buf.RemoveCursor(h.Buf.NumCursors() - 1)
1603                 h.Buf.SetCurCursor(h.Buf.NumCursors() - 1)
1604                 h.Buf.UpdateCursors()
1605         } else {
1606                 h.multiWord = false
1607         }
1608         h.Relocate()
1609         return true
1610 }
1611
1612 // RemoveAllMultiCursors removes all cursors except the base cursor
1613 func (h *BufPane) RemoveAllMultiCursors() bool {
1614         h.Buf.ClearCursors()
1615         h.multiWord = false
1616         h.Relocate()
1617         return true
1618 }
1619
1620 // None is an action that does nothing
1621 func (h *BufPane) None() bool {
1622         return true
1623 }