[Summary view] [Print] [Text view]

   1  // CodeMirror, copyright (c) by Marijn Haverbeke and others
   2  // Distributed under an MIT license: https://codemirror.net/5/LICENSE
   3  
   4  (function(mod) {
   5    if (typeof exports == "object" && typeof module == "object") // CommonJS
   6      mod(require("../lib/codemirror"));
   7    else if (typeof define == "function" && define.amd) // AMD
   8      define(["../lib/codemirror"], mod);
   9    else // Plain browser env
  10      mod(CodeMirror);
  11  })(function(CodeMirror) {
  12    "use strict";
  13  
  14    var cmds = CodeMirror.commands;
  15    var Pos = CodeMirror.Pos;
  16    function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }
  17  
  18    // Kill 'ring'
  19  
  20    var killRing = [];
  21    function addToRing(str) {
  22      killRing.push(str);
  23      if (killRing.length > 50) killRing.shift();
  24    }
  25    function growRingTop(str) {
  26      if (!killRing.length) return addToRing(str);
  27      killRing[killRing.length - 1] += str;
  28    }
  29    function getFromRing(n) { return killRing[killRing.length - (n ? Math.min(n, 1) : 1)] || ""; }
  30    function popFromRing() { if (killRing.length > 1) killRing.pop(); return getFromRing(); }
  31  
  32    var lastKill = null;
  33  
  34    // Internal generic kill function, used by several mapped kill "family" functions.
  35    function _kill(cm, from, to, ring, text) {
  36      if (text == null) text = cm.getRange(from, to);
  37  
  38      if (ring == "grow" && lastKill && lastKill.cm == cm && posEq(from, lastKill.pos) && cm.isClean(lastKill.gen))
  39        growRingTop(text);
  40      else if (ring !== false)
  41        addToRing(text);
  42      cm.replaceRange("", from, to, "+delete");
  43  
  44      if (ring == "grow") lastKill = {cm: cm, pos: from, gen: cm.changeGeneration()};
  45      else lastKill = null;
  46    }
  47  
  48    // Boundaries of various units
  49  
  50    function byChar(cm, pos, dir) {
  51      return cm.findPosH(pos, dir, "char", true);
  52    }
  53  
  54    function byWord(cm, pos, dir) {
  55      return cm.findPosH(pos, dir, "word", true);
  56    }
  57  
  58    function byLine(cm, pos, dir) {
  59      return cm.findPosV(pos, dir, "line", cm.doc.sel.goalColumn);
  60    }
  61  
  62    function byPage(cm, pos, dir) {
  63      return cm.findPosV(pos, dir, "page", cm.doc.sel.goalColumn);
  64    }
  65  
  66    function byParagraph(cm, pos, dir) {
  67      var no = pos.line, line = cm.getLine(no);
  68      var sawText = /\S/.test(dir < 0 ? line.slice(0, pos.ch) : line.slice(pos.ch));
  69      var fst = cm.firstLine(), lst = cm.lastLine();
  70      for (;;) {
  71        no += dir;
  72        if (no < fst || no > lst)
  73          return cm.clipPos(Pos(no - dir, dir < 0 ? 0 : null));
  74        line = cm.getLine(no);
  75        var hasText = /\S/.test(line);
  76        if (hasText) sawText = true;
  77        else if (sawText) return Pos(no, 0);
  78      }
  79    }
  80  
  81    function bySentence(cm, pos, dir) {
  82      var line = pos.line, ch = pos.ch;
  83      var text = cm.getLine(pos.line), sawWord = false;
  84      for (;;) {
  85        var next = text.charAt(ch + (dir < 0 ? -1 : 0));
  86        if (!next) { // End/beginning of line reached
  87          if (line == (dir < 0 ? cm.firstLine() : cm.lastLine())) return Pos(line, ch);
  88          text = cm.getLine(line + dir);
  89          if (!/\S/.test(text)) return Pos(line, ch);
  90          line += dir;
  91          ch = dir < 0 ? text.length : 0;
  92          continue;
  93        }
  94        if (sawWord && /[!?.]/.test(next)) return Pos(line, ch + (dir > 0 ? 1 : 0));
  95        if (!sawWord) sawWord = /\w/.test(next);
  96        ch += dir;
  97      }
  98    }
  99  
 100    function byExpr(cm, pos, dir) {
 101      var wrap;
 102      if (cm.findMatchingBracket && (wrap = cm.findMatchingBracket(pos, {strict: true}))
 103          && wrap.match && (wrap.forward ? 1 : -1) == dir)
 104        return dir > 0 ? Pos(wrap.to.line, wrap.to.ch + 1) : wrap.to;
 105  
 106      for (var first = true;; first = false) {
 107        var token = cm.getTokenAt(pos);
 108        var after = Pos(pos.line, dir < 0 ? token.start : token.end);
 109        if (first && dir > 0 && token.end == pos.ch || !/\w/.test(token.string)) {
 110          var newPos = cm.findPosH(after, dir, "char");
 111          if (posEq(after, newPos)) return pos;
 112          else pos = newPos;
 113        } else {
 114          return after;
 115        }
 116      }
 117    }
 118  
 119    // Prefixes (only crudely supported)
 120  
 121    function getPrefix(cm, precise) {
 122      var digits = cm.state.emacsPrefix;
 123      if (!digits) return precise ? null : 1;
 124      clearPrefix(cm);
 125      return digits == "-" ? -1 : Number(digits);
 126    }
 127  
 128    function repeated(cmd) {
 129      var f = typeof cmd == "string" ? function(cm) { cm.execCommand(cmd); } : cmd;
 130      return function(cm) {
 131        var prefix = getPrefix(cm);
 132        f(cm);
 133        for (var i = 1; i < prefix; ++i) f(cm);
 134      };
 135    }
 136  
 137    function findEnd(cm, pos, by, dir) {
 138      var prefix = getPrefix(cm);
 139      if (prefix < 0) { dir = -dir; prefix = -prefix; }
 140      for (var i = 0; i < prefix; ++i) {
 141        var newPos = by(cm, pos, dir);
 142        if (posEq(newPos, pos)) break;
 143        pos = newPos;
 144      }
 145      return pos;
 146    }
 147  
 148    function move(by, dir) {
 149      var f = function(cm) {
 150        cm.extendSelection(findEnd(cm, cm.getCursor(), by, dir));
 151      };
 152      f.motion = true;
 153      return f;
 154    }
 155  
 156    function killTo(cm, by, dir, ring) {
 157      var selections = cm.listSelections(), cursor;
 158      var i = selections.length;
 159      while (i--) {
 160        cursor = selections[i].head;
 161        _kill(cm, cursor, findEnd(cm, cursor, by, dir), ring);
 162      }
 163    }
 164  
 165    function _killRegion(cm, ring) {
 166      if (cm.somethingSelected()) {
 167        var selections = cm.listSelections(), selection;
 168        var i = selections.length;
 169        while (i--) {
 170          selection = selections[i];
 171          _kill(cm, selection.anchor, selection.head, ring);
 172        }
 173        return true;
 174      }
 175    }
 176  
 177    function addPrefix(cm, digit) {
 178      if (cm.state.emacsPrefix) {
 179        if (digit != "-") cm.state.emacsPrefix += digit;
 180        return;
 181      }
 182      // Not active yet
 183      cm.state.emacsPrefix = digit;
 184      cm.on("keyHandled", maybeClearPrefix);
 185      cm.on("inputRead", maybeDuplicateInput);
 186    }
 187  
 188    var prefixPreservingKeys = {"Alt-G": true, "Ctrl-X": true, "Ctrl-Q": true, "Ctrl-U": true};
 189  
 190    function maybeClearPrefix(cm, arg) {
 191      if (!cm.state.emacsPrefixMap && !prefixPreservingKeys.hasOwnProperty(arg))
 192        clearPrefix(cm);
 193    }
 194  
 195    function clearPrefix(cm) {
 196      cm.state.emacsPrefix = null;
 197      cm.off("keyHandled", maybeClearPrefix);
 198      cm.off("inputRead", maybeDuplicateInput);
 199    }
 200  
 201    function maybeDuplicateInput(cm, event) {
 202      var dup = getPrefix(cm);
 203      if (dup > 1 && event.origin == "+input") {
 204        var one = event.text.join("\n"), txt = "";
 205        for (var i = 1; i < dup; ++i) txt += one;
 206        cm.replaceSelection(txt);
 207      }
 208    }
 209  
 210    function maybeRemovePrefixMap(cm, arg) {
 211      if (typeof arg == "string" && (/^\d$/.test(arg) || arg == "Ctrl-U")) return;
 212      cm.removeKeyMap(prefixMap);
 213      cm.state.emacsPrefixMap = false;
 214      cm.off("keyHandled", maybeRemovePrefixMap);
 215      cm.off("inputRead", maybeRemovePrefixMap);
 216    }
 217  
 218    // Utilities
 219  
 220    cmds.setMark = function (cm) {
 221      cm.setCursor(cm.getCursor());
 222      cm.setExtending(!cm.getExtending());
 223      cm.on("change", function() { cm.setExtending(false); });
 224    }
 225  
 226    function clearMark(cm) {
 227      cm.setExtending(false);
 228      cm.setCursor(cm.getCursor());
 229    }
 230  
 231    function makePrompt(msg) {
 232      var fragment = document.createDocumentFragment();
 233      var input = document.createElement("input");
 234      input.setAttribute("type", "text");
 235      input.style.width = "10em";
 236      fragment.appendChild(document.createTextNode(msg + ": "));
 237      fragment.appendChild(input);
 238      return fragment;
 239    }
 240  
 241    function getInput(cm, msg, f) {
 242      if (cm.openDialog)
 243        cm.openDialog(makePrompt(msg), f, {bottom: true});
 244      else
 245        f(prompt(msg, ""));
 246    }
 247  
 248    function operateOnWord(cm, op) {
 249      var start = cm.getCursor(), end = cm.findPosH(start, 1, "word");
 250      cm.replaceRange(op(cm.getRange(start, end)), start, end);
 251      cm.setCursor(end);
 252    }
 253  
 254    function toEnclosingExpr(cm) {
 255      var pos = cm.getCursor(), line = pos.line, ch = pos.ch;
 256      var stack = [];
 257      while (line >= cm.firstLine()) {
 258        var text = cm.getLine(line);
 259        for (var i = ch == null ? text.length : ch; i > 0;) {
 260          var ch = text.charAt(--i);
 261          if (ch == ")")
 262            stack.push("(");
 263          else if (ch == "]")
 264            stack.push("[");
 265          else if (ch == "}")
 266            stack.push("{");
 267          else if (/[\(\{\[]/.test(ch) && (!stack.length || stack.pop() != ch))
 268            return cm.extendSelection(Pos(line, i));
 269        }
 270        --line; ch = null;
 271      }
 272    }
 273  
 274    // Commands. Names should match emacs function names (albeit in camelCase)
 275    // except where emacs function names collide with code mirror core commands.
 276  
 277    cmds.killRegion = function(cm) {
 278      _kill(cm, cm.getCursor("start"), cm.getCursor("end"), true);
 279    };
 280  
 281    // Maps to emacs kill-line
 282    cmds.killLineEmacs = repeated(function(cm) {
 283      var start = cm.getCursor(), end = cm.clipPos(Pos(start.line));
 284      var text = cm.getRange(start, end);
 285      if (!/\S/.test(text)) {
 286        text += "\n";
 287        end = Pos(start.line + 1, 0);
 288      }
 289      _kill(cm, start, end, "grow", text);
 290    });
 291  
 292    cmds.killRingSave = function(cm) {
 293      addToRing(cm.getSelection());
 294      clearMark(cm);
 295    };
 296  
 297    cmds.yank = function(cm) {
 298      var start = cm.getCursor();
 299      cm.replaceRange(getFromRing(getPrefix(cm)), start, start, "paste");
 300      cm.setSelection(start, cm.getCursor());
 301    };
 302  
 303    cmds.yankPop = function(cm) {
 304      cm.replaceSelection(popFromRing(), "around", "paste");
 305    };
 306  
 307    cmds.forwardChar = move(byChar, 1);
 308  
 309    cmds.backwardChar = move(byChar, -1)
 310  
 311    cmds.deleteChar = function(cm) { killTo(cm, byChar, 1, false); };
 312  
 313    cmds.deleteForwardChar = function(cm) {
 314      _killRegion(cm, false) || killTo(cm, byChar, 1, false);
 315    };
 316  
 317    cmds.deleteBackwardChar = function(cm) {
 318      _killRegion(cm, false) || killTo(cm, byChar, -1, false);
 319    };
 320  
 321    cmds.forwardWord = move(byWord, 1);
 322  
 323    cmds.backwardWord = move(byWord, -1);
 324  
 325    cmds.killWord = function(cm) { killTo(cm, byWord, 1, "grow"); };
 326  
 327    cmds.backwardKillWord = function(cm) { killTo(cm, byWord, -1, "grow"); };
 328  
 329    cmds.nextLine = move(byLine, 1);
 330  
 331    cmds.previousLine = move(byLine, -1);
 332  
 333    cmds.scrollDownCommand = move(byPage, -1);
 334  
 335    cmds.scrollUpCommand = move(byPage, 1);
 336  
 337    cmds.backwardParagraph = move(byParagraph, -1);
 338  
 339    cmds.forwardParagraph = move(byParagraph, 1);
 340  
 341    cmds.backwardSentence = move(bySentence, -1);
 342  
 343    cmds.forwardSentence = move(bySentence, 1);
 344  
 345    cmds.killSentence = function(cm) { killTo(cm, bySentence, 1, "grow"); };
 346  
 347    cmds.backwardKillSentence = function(cm) {
 348      _kill(cm, cm.getCursor(), bySentence(cm, cm.getCursor(), 1), "grow");
 349    };
 350  
 351    cmds.killSexp = function(cm) { killTo(cm, byExpr, 1, "grow"); };
 352  
 353    cmds.backwardKillSexp = function(cm) { killTo(cm, byExpr, -1, "grow"); };
 354  
 355    cmds.forwardSexp = move(byExpr, 1);
 356  
 357    cmds.backwardSexp = move(byExpr, -1);
 358  
 359    cmds.markSexp = function(cm) {
 360      var cursor = cm.getCursor();
 361      cm.setSelection(findEnd(cm, cursor, byExpr, 1), cursor);
 362    };
 363  
 364    cmds.transposeSexps = function(cm) {
 365      var leftStart = byExpr(cm, cm.getCursor(), -1);
 366      var leftEnd = byExpr(cm, leftStart, 1);
 367      var rightEnd = byExpr(cm, leftEnd, 1);
 368      var rightStart = byExpr(cm, rightEnd, -1);
 369      cm.replaceRange(cm.getRange(rightStart, rightEnd) +
 370                      cm.getRange(leftEnd, rightStart) +
 371                      cm.getRange(leftStart, leftEnd), leftStart, rightEnd);
 372    };
 373  
 374    cmds.backwardUpList = repeated(toEnclosingExpr);
 375  
 376    cmds.justOneSpace = function(cm) {
 377      var pos = cm.getCursor(), from = pos.ch;
 378      var to = pos.ch, text = cm.getLine(pos.line);
 379      while (from && /\s/.test(text.charAt(from - 1))) --from;
 380      while (to < text.length && /\s/.test(text.charAt(to))) ++to;
 381      cm.replaceRange(" ", Pos(pos.line, from), Pos(pos.line, to));
 382    };
 383  
 384    cmds.openLine = repeated(function(cm) {
 385      cm.replaceSelection("\n", "start");
 386    });
 387  
 388    // maps to emacs 'transpose-chars'
 389    cmds.transposeCharsRepeatable = repeated(function(cm) {
 390      cm.execCommand("transposeChars");
 391    });
 392  
 393    cmds.capitalizeWord = repeated(function(cm) {
 394      operateOnWord(cm, function(w) {
 395        var letter = w.search(/\w/);
 396        if (letter == -1) return w;
 397        return w.slice(0, letter) + w.charAt(letter).toUpperCase() +
 398            w.slice(letter + 1).toLowerCase();
 399      });
 400    });
 401  
 402    cmds.upcaseWord = repeated(function(cm) {
 403      operateOnWord(cm, function(w) { return w.toUpperCase(); });
 404    });
 405  
 406    cmds.downcaseWord = repeated(function(cm) {
 407      operateOnWord(cm, function(w) { return w.toLowerCase(); });
 408    });
 409  
 410    // maps to emacs 'undo'
 411    cmds.undoRepeatable = repeated("undo");
 412  
 413    cmds.keyboardQuit = function(cm) {
 414      cm.execCommand("clearSearch");
 415      clearMark(cm);
 416    }
 417  
 418    cmds.newline = repeated(function(cm) { cm.replaceSelection("\n", "end"); });
 419  
 420    cmds.gotoLine = function(cm) {
 421      var prefix = getPrefix(cm, true);
 422      if (prefix != null && prefix > 0) return cm.setCursor(prefix - 1);
 423  
 424      getInput(cm, "Goto line", function(str) {
 425        var num;
 426        if (str && !isNaN(num = Number(str)) && num == (num|0) && num > 0)
 427        cm.setCursor(num - 1);
 428      });
 429    };
 430  
 431    cmds.indentRigidly = function(cm) {
 432      cm.indentSelection(getPrefix(cm, true) || cm.getOption("indentUnit"));
 433    };
 434  
 435    cmds.exchangePointAndMark = function(cm) {
 436      cm.setSelection(cm.getCursor("head"), cm.getCursor("anchor"));
 437    };
 438  
 439    cmds.quotedInsertTab = repeated("insertTab");
 440  
 441    cmds.universalArgument = function addPrefixMap(cm) {
 442      cm.state.emacsPrefixMap = true;
 443      cm.addKeyMap(prefixMap);
 444      cm.on("keyHandled", maybeRemovePrefixMap);
 445      cm.on("inputRead", maybeRemovePrefixMap);
 446    };
 447  
 448    CodeMirror.emacs = {kill: _kill, killRegion: _killRegion, repeated: repeated};
 449  
 450    // Actual keymap
 451    var keyMap = CodeMirror.keyMap.emacs = CodeMirror.normalizeKeyMap({
 452      "Ctrl-W": "killRegion",
 453      "Ctrl-K": "killLineEmacs",
 454      "Alt-W": "killRingSave",
 455      "Ctrl-Y": "yank",
 456      "Alt-Y": "yankPop",
 457      "Ctrl-Space": "setMark",
 458      "Ctrl-Shift-2": "setMark",
 459      "Ctrl-F": "forwardChar",
 460      "Ctrl-B": "backwardChar",
 461      "Right": "forwardChar",
 462      "Left": "backwardChar",
 463      "Ctrl-D": "deleteChar",
 464      "Delete": "deleteForwardChar",
 465      "Ctrl-H": "deleteBackwardChar",
 466      "Backspace": "deleteBackwardChar",
 467      "Alt-F": "forwardWord",
 468      "Alt-B": "backwardWord",
 469      "Alt-Right": "forwardWord",
 470      "Alt-Left": "backwardWord",
 471      "Alt-D": "killWord",
 472      "Alt-Backspace": "backwardKillWord",
 473      "Ctrl-N": "nextLine",
 474      "Ctrl-P": "previousLine",
 475      "Down": "nextLine",
 476      "Up": "previousLine",
 477      "Ctrl-A": "goLineStart",
 478      "Ctrl-E": "goLineEnd",
 479      "End": "goLineEnd",
 480      "Home": "goLineStart",
 481      "Alt-V": "scrollDownCommand",
 482      "Ctrl-V": "scrollUpCommand",
 483      "PageUp": "scrollDownCommand",
 484      "PageDown": "scrollUpCommand",
 485      "Ctrl-Up": "backwardParagraph",
 486      "Ctrl-Down": "forwardParagraph",
 487      "Alt-{": "backwardParagraph",
 488      "Alt-}": "forwardParagraph",
 489      "Alt-A": "backwardSentence",
 490      "Alt-E": "forwardSentence",
 491      "Alt-K": "killSentence",
 492      "Ctrl-X Delete": "backwardKillSentence",
 493      "Ctrl-Alt-K": "killSexp",
 494      "Ctrl-Alt-Backspace": "backwardKillSexp",
 495      "Ctrl-Alt-F": "forwardSexp",
 496      "Ctrl-Alt-B": "backwardSexp",
 497      "Shift-Ctrl-Alt-2": "markSexp",
 498      "Ctrl-Alt-T": "transposeSexps",
 499      "Ctrl-Alt-U": "backwardUpList",
 500      "Alt-Space": "justOneSpace",
 501      "Ctrl-O": "openLine",
 502      "Ctrl-T": "transposeCharsRepeatable",
 503      "Alt-C": "capitalizeWord",
 504      "Alt-U": "upcaseWord",
 505      "Alt-L": "downcaseWord",
 506      "Alt-;": "toggleComment",
 507      "Ctrl-/": "undoRepeatable",
 508      "Shift-Ctrl--": "undoRepeatable",
 509      "Ctrl-Z": "undoRepeatable",
 510      "Cmd-Z": "undoRepeatable",
 511      "Ctrl-X U": "undoRepeatable",
 512      "Shift-Ctrl-Z": "redo",
 513      "Shift-Alt-,": "goDocStart",
 514      "Shift-Alt-.": "goDocEnd",
 515      "Ctrl-S": "findPersistentNext",
 516      "Ctrl-R": "findPersistentPrev",
 517      "Ctrl-G": "keyboardQuit",
 518      "Shift-Alt-5": "replace",
 519      "Alt-/": "autocomplete",
 520      "Enter": "newlineAndIndent",
 521      "Ctrl-J": "newline",
 522      "Tab": "indentAuto",
 523      "Alt-G G": "gotoLine",
 524      "Ctrl-X Tab": "indentRigidly",
 525      "Ctrl-X Ctrl-X": "exchangePointAndMark",
 526      "Ctrl-X Ctrl-S": "save",
 527      "Ctrl-X Ctrl-W": "save",
 528      "Ctrl-X S": "saveAll",
 529      "Ctrl-X F": "open",
 530      "Ctrl-X K": "close",
 531      "Ctrl-X H": "selectAll",
 532      "Ctrl-Q Tab": "quotedInsertTab",
 533      "Ctrl-U": "universalArgument",
 534      "fallthrough": "default"
 535    });
 536  
 537    var prefixMap = {"Ctrl-G": clearPrefix};
 538    function regPrefix(d) {
 539      prefixMap[d] = function(cm) { addPrefix(cm, d); };
 540      keyMap["Ctrl-" + d] = function(cm) { addPrefix(cm, d); };
 541      prefixPreservingKeys["Ctrl-" + d] = true;
 542    }
 543    for (var i = 0; i < 10; ++i) regPrefix(String(i));
 544    regPrefix("-");
 545  });