Mercurial
comparison .cms/lib/codemirror/keymap/emacs.js @ 0:78edf6b517a0 draft
24.10
author | Coffee CMS <info@coffee-cms.ru> |
---|---|
date | Fri, 11 Oct 2024 22:40:23 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:78edf6b517a0 |
---|---|
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 }); |