The Tor Browser / file comparison

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

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

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:cf6873707903
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