The Tor Browser / file revision

browser/devtools/sourceeditor/codemirror/keymap/emacs.js@6474c204b198

browser/devtools/sourceeditor/codemirror/keymap/emacs.js

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 (function(mod) {

     2   if (typeof exports == "object" && typeof module == "object") // CommonJS

     3     mod(require("../lib/codemirror"));

     4   else if (typeof define == "function" && define.amd) // AMD

     5     define(["../lib/codemirror"], mod);

     6   else // Plain browser env

     7     mod(CodeMirror);

     8 })(function(CodeMirror) {

     9   "use strict";

    10 

    11   var Pos = CodeMirror.Pos;

    12   function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }

    13 

    14   // Kill 'ring'

    15 

    16   var killRing = [];

    17   function addToRing(str) {

    18     killRing.push(str);

    19     if (killRing.length > 50) killRing.shift();

    20   }

    21   function growRingTop(str) {

    22     if (!killRing.length) return addToRing(str);

    23     killRing[killRing.length - 1] += str;

    24   }

    25   function getFromRing(n) { return killRing[killRing.length - (n ? Math.min(n, 1) : 1)] || ""; }

    26   function popFromRing() { if (killRing.length > 1) killRing.pop(); return getFromRing(); }

    27 

    28   var lastKill = null;

    29 

    30   function kill(cm, from, to, mayGrow, text) {

    31     if (text == null) text = cm.getRange(from, to);

    32 

    33     if (mayGrow && lastKill && lastKill.cm == cm && posEq(from, lastKill.pos) && cm.isClean(lastKill.gen))

    34       growRingTop(text);

    35     else

    36       addToRing(text);

    37     cm.replaceRange("", from, to, "+delete");

    38 

    39     if (mayGrow) lastKill = {cm: cm, pos: from, gen: cm.changeGeneration()};

    40     else lastKill = null;

    41   }

    42 

    43   // Boundaries of various units

    44 

    45   function byChar(cm, pos, dir) {

    46     return cm.findPosH(pos, dir, "char", true);

    47   }

    48 

    49   function byWord(cm, pos, dir) {

    50     return cm.findPosH(pos, dir, "word", true);

    51   }

    52 

    53   function byLine(cm, pos, dir) {

    54     return cm.findPosV(pos, dir, "line", cm.doc.sel.goalColumn);

    55   }

    56 

    57   function byPage(cm, pos, dir) {

    58     return cm.findPosV(pos, dir, "page", cm.doc.sel.goalColumn);

    59   }

    60 

    61   function byParagraph(cm, pos, dir) {

    62     var no = pos.line, line = cm.getLine(no);

    63     var sawText = /\S/.test(dir < 0 ? line.slice(0, pos.ch) : line.slice(pos.ch));

    64     var fst = cm.firstLine(), lst = cm.lastLine();

    65     for (;;) {

    66       no += dir;

    67       if (no < fst || no > lst)

    68         return cm.clipPos(Pos(no - dir, dir < 0 ? 0 : null));

    69       line = cm.getLine(no);

    70       var hasText = /\S/.test(line);

    71       if (hasText) sawText = true;

    72       else if (sawText) return Pos(no, 0);

    73     }

    74   }

    75 

    76   function bySentence(cm, pos, dir) {

    77     var line = pos.line, ch = pos.ch;

    78     var text = cm.getLine(pos.line), sawWord = false;

    79     for (;;) {

    80       var next = text.charAt(ch + (dir < 0 ? -1 : 0));

    81       if (!next) { // End/beginning of line reached

    82         if (line == (dir < 0 ? cm.firstLine() : cm.lastLine())) return Pos(line, ch);

    83         text = cm.getLine(line + dir);

    84         if (!/\S/.test(text)) return Pos(line, ch);

    85         line += dir;

    86         ch = dir < 0 ? text.length : 0;

    87         continue;

    88       }

    89       if (sawWord && /[!?.]/.test(next)) return Pos(line, ch + (dir > 0 ? 1 : 0));

    90       if (!sawWord) sawWord = /\w/.test(next);

    91       ch += dir;

    92     }

    93   }

    94 

    95   function byExpr(cm, pos, dir) {

    96     var wrap;

    97     if (cm.findMatchingBracket && (wrap = cm.findMatchingBracket(pos, true))

    98         && wrap.match && (wrap.forward ? 1 : -1) == dir)

    99       return dir > 0 ? Pos(wrap.to.line, wrap.to.ch + 1) : wrap.to;

   100 

   101     for (var first = true;; first = false) {

   102       var token = cm.getTokenAt(pos);

   103       var after = Pos(pos.line, dir < 0 ? token.start : token.end);

   104       if (first && dir > 0 && token.end == pos.ch || !/\w/.test(token.string)) {

   105         var newPos = cm.findPosH(after, dir, "char");

   106         if (posEq(after, newPos)) return pos;

   107         else pos = newPos;

   108       } else {

   109         return after;

   110       }

   111     }

   112   }

   113 

   114   // Prefixes (only crudely supported)

   115 

   116   function getPrefix(cm, precise) {

   117     var digits = cm.state.emacsPrefix;

   118     if (!digits) return precise ? null : 1;

   119     clearPrefix(cm);

   120     return digits == "-" ? -1 : Number(digits);

   121   }

   122 

   123   function repeated(cmd) {

   124     var f = typeof cmd == "string" ? function(cm) { cm.execCommand(cmd); } : cmd;

   125     return function(cm) {

   126       var prefix = getPrefix(cm);

   127       f(cm);

   128       for (var i = 1; i < prefix; ++i) f(cm);

   129     };

   130   }

   131 

   132   function findEnd(cm, by, dir) {

   133     var pos = cm.getCursor(), prefix = getPrefix(cm);

   134     if (prefix < 0) { dir = -dir; prefix = -prefix; }

   135     for (var i = 0; i < prefix; ++i) {

   136       var newPos = by(cm, pos, dir);

   137       if (posEq(newPos, pos)) break;

   138       pos = newPos;

   139     }

   140     return pos;

   141   }

   142 

   143   function move(by, dir) {

   144     var f = function(cm) {

   145       cm.extendSelection(findEnd(cm, by, dir));

   146     };

   147     f.motion = true;

   148     return f;

   149   }

   150 

   151   function killTo(cm, by, dir) {

   152     kill(cm, cm.getCursor(), findEnd(cm, by, dir), true);

   153   }

   154 

   155   function addPrefix(cm, digit) {

   156     if (cm.state.emacsPrefix) {

   157       if (digit != "-") cm.state.emacsPrefix += digit;

   158       return;

   159     }

   160     // Not active yet

   161     cm.state.emacsPrefix = digit;

   162     cm.on("keyHandled", maybeClearPrefix);

   163     cm.on("inputRead", maybeDuplicateInput);

   164   }

   165 

   166   var prefixPreservingKeys = {"Alt-G": true, "Ctrl-X": true, "Ctrl-Q": true, "Ctrl-U": true};

   167 

   168   function maybeClearPrefix(cm, arg) {

   169     if (!cm.state.emacsPrefixMap && !prefixPreservingKeys.hasOwnProperty(arg))

   170       clearPrefix(cm);

   171   }

   172 

   173   function clearPrefix(cm) {

   174     cm.state.emacsPrefix = null;

   175     cm.off("keyHandled", maybeClearPrefix);

   176     cm.off("inputRead", maybeDuplicateInput);

   177   }

   178 

   179   function maybeDuplicateInput(cm, event) {

   180     var dup = getPrefix(cm);

   181     if (dup > 1 && event.origin == "+input") {

   182       var one = event.text.join("\n"), txt = "";

   183       for (var i = 1; i < dup; ++i) txt += one;

   184       cm.replaceSelection(txt);

   185     }

   186   }

   187 

   188   function addPrefixMap(cm) {

   189     cm.state.emacsPrefixMap = true;

   190     cm.addKeyMap(prefixMap);

   191     cm.on("keyHandled", maybeRemovePrefixMap);

   192     cm.on("inputRead", maybeRemovePrefixMap);

   193   }

   194 

   195   function maybeRemovePrefixMap(cm, arg) {

   196     if (typeof arg == "string" && (/^\d$/.test(arg) || arg == "Ctrl-U")) return;

   197     cm.removeKeyMap(prefixMap);

   198     cm.state.emacsPrefixMap = false;

   199     cm.off("keyHandled", maybeRemovePrefixMap);

   200     cm.off("inputRead", maybeRemovePrefixMap);

   201   }

   202 

   203   // Utilities

   204 

   205   function setMark(cm) {

   206     cm.setCursor(cm.getCursor());

   207     cm.setExtending(!cm.getExtending());

   208     cm.on("change", function() { cm.setExtending(false); });

   209   }

   210 

   211   function clearMark(cm) {

   212     cm.setExtending(false);

   213     cm.setCursor(cm.getCursor());

   214   }

   215 

   216   function getInput(cm, msg, f) {

   217     if (cm.openDialog)

   218       cm.openDialog(msg + ": <input type=\"text\" style=\"width: 10em\"/>", f, {bottom: true});

   219     else

   220       f(prompt(msg, ""));

   221   }

   222 

   223   function operateOnWord(cm, op) {

   224     var start = cm.getCursor(), end = cm.findPosH(start, 1, "word");

   225     cm.replaceRange(op(cm.getRange(start, end)), start, end);

   226     cm.setCursor(end);

   227   }

   228 

   229   function toEnclosingExpr(cm) {

   230     var pos = cm.getCursor(), line = pos.line, ch = pos.ch;

   231     var stack = [];

   232     while (line >= cm.firstLine()) {

   233       var text = cm.getLine(line);

   234       for (var i = ch == null ? text.length : ch; i > 0;) {

   235         var ch = text.charAt(--i);

   236         if (ch == ")")

   237           stack.push("(");

   238         else if (ch == "]")

   239           stack.push("[");

   240         else if (ch == "}")

   241           stack.push("{");

   242         else if (/[\(\{\[]/.test(ch) && (!stack.length || stack.pop() != ch))

   243           return cm.extendSelection(Pos(line, i));

   244       }

   245       --line; ch = null;

   246     }

   247   }

   248 

   249   function quit(cm) {

   250     cm.execCommand("clearSearch");

   251     clearMark(cm);

   252   }

   253 

   254   // Actual keymap

   255 

   256   var keyMap = CodeMirror.keyMap.emacs = {

   257     "Ctrl-W": function(cm) {kill(cm, cm.getCursor("start"), cm.getCursor("end"));},

   258     "Ctrl-K": repeated(function(cm) {

   259       var start = cm.getCursor(), end = cm.clipPos(Pos(start.line));

   260       var text = cm.getRange(start, end);

   261       if (!/\S/.test(text)) {

   262         text += "\n";

   263         end = Pos(start.line + 1, 0);

   264       }

   265       kill(cm, start, end, true, text);

   266     }),

   267     "Alt-W": function(cm) {

   268       addToRing(cm.getSelection());

   269       clearMark(cm);

   270     },

   271     "Ctrl-Y": function(cm) {

   272       var start = cm.getCursor();

   273       cm.replaceRange(getFromRing(getPrefix(cm)), start, start, "paste");

   274       cm.setSelection(start, cm.getCursor());

   275     },

   276     "Alt-Y": function(cm) {cm.replaceSelection(popFromRing(), "around", "paste");},

   277 

   278     "Ctrl-Space": setMark, "Ctrl-Shift-2": setMark,

   279 

   280     "Ctrl-F": move(byChar, 1), "Ctrl-B": move(byChar, -1),

   281     "Right": move(byChar, 1), "Left": move(byChar, -1),

   282     "Ctrl-D": function(cm) { killTo(cm, byChar, 1); },

   283     "Delete": function(cm) { killTo(cm, byChar, 1); },

   284     "Ctrl-H": function(cm) { killTo(cm, byChar, -1); },

   285     "Backspace": function(cm) { killTo(cm, byChar, -1); },

   286 

   287     "Alt-F": move(byWord, 1), "Alt-B": move(byWord, -1),

   288     "Alt-D": function(cm) { killTo(cm, byWord, 1); },

   289     "Alt-Backspace": function(cm) { killTo(cm, byWord, -1); },

   290 

   291     "Ctrl-N": move(byLine, 1), "Ctrl-P": move(byLine, -1),

   292     "Down": move(byLine, 1), "Up": move(byLine, -1),

   293     "Ctrl-A": "goLineStart", "Ctrl-E": "goLineEnd",

   294     "End": "goLineEnd", "Home": "goLineStart",

   295 

   296     "Alt-V": move(byPage, -1), "Ctrl-V": move(byPage, 1),

   297     "PageUp": move(byPage, -1), "PageDown": move(byPage, 1),

   298 

   299     "Ctrl-Up": move(byParagraph, -1), "Ctrl-Down": move(byParagraph, 1),

   300 

   301     "Alt-A": move(bySentence, -1), "Alt-E": move(bySentence, 1),

   302     "Alt-K": function(cm) { killTo(cm, bySentence, 1); },

   303 

   304     "Ctrl-Alt-K": function(cm) { killTo(cm, byExpr, 1); },

   305     "Ctrl-Alt-Backspace": function(cm) { killTo(cm, byExpr, -1); },

   306     "Ctrl-Alt-F": move(byExpr, 1), "Ctrl-Alt-B": move(byExpr, -1),

   307 

   308     "Shift-Ctrl-Alt-2": function(cm) {

   309       cm.setSelection(findEnd(cm, byExpr, 1), cm.getCursor());

   310     },

   311     "Ctrl-Alt-T": function(cm) {

   312       var leftStart = byExpr(cm, cm.getCursor(), -1), leftEnd = byExpr(cm, leftStart, 1);

   313       var rightEnd = byExpr(cm, leftEnd, 1), rightStart = byExpr(cm, rightEnd, -1);

   314       cm.replaceRange(cm.getRange(rightStart, rightEnd) + cm.getRange(leftEnd, rightStart) +

   315                       cm.getRange(leftStart, leftEnd), leftStart, rightEnd);

   316     },

   317     "Ctrl-Alt-U": repeated(toEnclosingExpr),

   318 

   319     "Alt-Space": function(cm) {

   320       var pos = cm.getCursor(), from = pos.ch, to = pos.ch, text = cm.getLine(pos.line);

   321       while (from && /\s/.test(text.charAt(from - 1))) --from;

   322       while (to < text.length && /\s/.test(text.charAt(to))) ++to;

   323       cm.replaceRange(" ", Pos(pos.line, from), Pos(pos.line, to));

   324     },

   325     "Ctrl-O": repeated(function(cm) { cm.replaceSelection("\n", "start"); }),

   326     "Ctrl-T": repeated(function(cm) {

   327       var pos = cm.getCursor();

   328       if (pos.ch < cm.getLine(pos.line).length) pos = Pos(pos.line, pos.ch + 1);

   329       var from = cm.findPosH(pos, -2, "char");

   330       var range = cm.getRange(from, pos);

   331       if (range.length != 2) return;

   332       cm.setSelection(from, pos);

   333       cm.replaceSelection(range.charAt(1) + range.charAt(0), null, "+transpose");

   334     }),

   335 

   336     "Alt-C": repeated(function(cm) {

   337       operateOnWord(cm, function(w) {

   338         var letter = w.search(/\w/);

   339         if (letter == -1) return w;

   340         return w.slice(0, letter) + w.charAt(letter).toUpperCase() + w.slice(letter + 1).toLowerCase();

   341       });

   342     }),

   343     "Alt-U": repeated(function(cm) {

   344       operateOnWord(cm, function(w) { return w.toUpperCase(); });

   345     }),

   346     "Alt-L": repeated(function(cm) {

   347       operateOnWord(cm, function(w) { return w.toLowerCase(); });

   348     }),

   349 

   350     "Alt-;": "toggleComment",

   351 

   352     "Ctrl-/": repeated("undo"), "Shift-Ctrl--": repeated("undo"),

   353     "Ctrl-Z": repeated("undo"), "Cmd-Z": repeated("undo"),

   354     "Shift-Alt-,": "goDocStart", "Shift-Alt-.": "goDocEnd",

   355     "Ctrl-S": "findNext", "Ctrl-R": "findPrev", "Ctrl-G": quit, "Shift-Alt-5": "replace",

   356     "Alt-/": "autocomplete",

   357     "Ctrl-J": "newlineAndIndent", "Enter": false, "Tab": "indentAuto",

   358 

   359     "Alt-G": function(cm) {cm.setOption("keyMap", "emacs-Alt-G");},

   360     "Ctrl-X": function(cm) {cm.setOption("keyMap", "emacs-Ctrl-X");},

   361     "Ctrl-Q": function(cm) {cm.setOption("keyMap", "emacs-Ctrl-Q");},

   362     "Ctrl-U": addPrefixMap

   363   };

   364 

   365   CodeMirror.keyMap["emacs-Ctrl-X"] = {

   366     "Tab": function(cm) {

   367       cm.indentSelection(getPrefix(cm, true) || cm.getOption("indentUnit"));

   368     },

   369     "Ctrl-X": function(cm) {

   370       cm.setSelection(cm.getCursor("head"), cm.getCursor("anchor"));

   371     },

   372 

   373     "Ctrl-S": "save", "Ctrl-W": "save", "S": "saveAll", "F": "open", "U": repeated("undo"), "K": "close",

   374     "Delete": function(cm) { kill(cm, cm.getCursor(), bySentence(cm, cm.getCursor(), 1), true); },

   375     auto: "emacs", nofallthrough: true, disableInput: true

   376   };

   377 

   378   CodeMirror.keyMap["emacs-Alt-G"] = {

   379     "G": function(cm) {

   380       var prefix = getPrefix(cm, true);

   381       if (prefix != null && prefix > 0) return cm.setCursor(prefix - 1);

   382 

   383       getInput(cm, "Goto line", function(str) {

   384         var num;

   385         if (str && !isNaN(num = Number(str)) && num == num|0 && num > 0)

   386           cm.setCursor(num - 1);

   387       });

   388     },

   389     auto: "emacs", nofallthrough: true, disableInput: true

   390   };

   391 

   392   CodeMirror.keyMap["emacs-Ctrl-Q"] = {

   393     "Tab": repeated("insertTab"),

   394     auto: "emacs", nofallthrough: true

   395   };

   396 

   397   var prefixMap = {"Ctrl-G": clearPrefix};

   398   function regPrefix(d) {

   399     prefixMap[d] = function(cm) { addPrefix(cm, d); };

   400     keyMap["Ctrl-" + d] = function(cm) { addPrefix(cm, d); };

   401     prefixPreservingKeys["Ctrl-" + d] = true;

   402   }

   403   for (var i = 0; i < 10; ++i) regPrefix(String(i));

   404   regPrefix("-");

   405 });

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial