Last active
December 13, 2015 21:18
-
-
Save jonsherrard/4976588 to your computer and use it in GitHub Desktop.
A Userscript compatible version of VimFlowy plugin for Workflowy - https://github.com/thricedotted/vimflowy
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| function enterNormalMode() { | |
| console.log("entering normal mode"); | |
| $(".editor > textarea").bind("keydown", blockAll); | |
| $(".editor > textarea").addModalKeyboardShortcuts(normalKeybindings, insertKeybindings) | |
| } | |
| function enterInsertMode(e) { | |
| e.preventDefault(); | |
| console.log("entering insert mode"); | |
| $(".editor > textarea").unbind("keydown", blockAll); | |
| $(".editor > textarea").addModalKeyboardShortcuts(insertKeybindings, normalKeybindings) | |
| }(function () { | |
| function e(e) { | |
| if (typeof e.value != "undefined") return "value"; | |
| if (typeof e.text != "undefined") return "text"; | |
| if (typeof e.textContent != "undefined") return "textContent"; | |
| return "innerText" | |
| } | |
| function t() {} | |
| function n() {} | |
| function r(e, t) { | |
| var n = t.text.replace(/\r/g, "").length; | |
| if (e.compareEndPoints("StartToStart", t) <= 0) return 0; | |
| if (e.compareEndPoints("StartToEnd", t) >= 0) return n; | |
| for (var r = 0; e.compareEndPoints("StartToStart", t) > 0; ++r, e.moveStart("character", -1)); | |
| return r | |
| } | |
| function i(e, t) { | |
| var n = t.text.replace(/\r/g, "").length; | |
| if (e.compareEndPoints("EndToEnd", t) >= 0) return n; | |
| if (e.compareEndPoints("EndToStart", t) <= 0) return 0; | |
| for (var r = 0; e.compareEndPoints("EndToStart", t) > 0; ++r, e.moveEnd("character", -1)); | |
| return r | |
| } | |
| function s() {} | |
| function o() {} | |
| function u(e, t) { | |
| if (e.firstChild) return e.firstChild; | |
| if (e.nextSibling) return e.nextSibling; | |
| if (e === t) return null; | |
| while (e.parentNode) { | |
| e = e.parentNode; | |
| if (e == t) return null; | |
| if (e.nextSibling) return e.nextSibling | |
| } | |
| return null | |
| } | |
| function a(e, t, n, r) { | |
| if (t <= 0) return; | |
| var i = e[n ? "startContainer" : "endContainer"]; | |
| if (i.nodeType == 3) { | |
| t += e[n ? "startOffset" : "endOffset"] | |
| } | |
| while (i) { | |
| if (i.nodeType == 3) { | |
| if (t <= i.nodeValue.length) { | |
| e[n ? "setStart" : "setEnd"](i, t); | |
| if (t == i.nodeValue.length) { | |
| for (var s = u(i, r); s && s.nodeType == 3 && s.nodeValue.length == 0; s = u(s, r)) { | |
| e[n ? "setStartAfter" : "setEndAfter"](s) | |
| } | |
| if (s && s.nodeType == 1 && s.nodeName == "BR") e[n ? "setStartAfter" : "setEndAfter"](s) | |
| } | |
| return | |
| } else { | |
| e[n ? "setStartAfter" : "setEndAfter"](i); | |
| t -= i.nodeValue.length | |
| } | |
| } | |
| i = u(i, r) | |
| } | |
| } | |
| function p(e, t) { | |
| if (e.compareBoundaryPoints(f, t) <= 0) return 0; | |
| if (e.compareBoundaryPoints(h, t) >= 0) return t.toString().length; | |
| e = e.cloneRange(); | |
| e.setEnd(t.endContainer, t.endOffset); | |
| return t.toString().length - e.toString().length | |
| } | |
| function d(e, t) { | |
| if (e.compareBoundaryPoints(c, t) >= 0) return t.toString().length; | |
| if (e.compareBoundaryPoints(l, t) <= 0) return 0; | |
| e = e.cloneRange(); | |
| e.setStart(t.startContainer, t.startOffset); | |
| return e.toString().length | |
| } | |
| function v() {} | |
| bililiteRange = function (t, r) { | |
| var i; | |
| if (r) { | |
| i = new v | |
| } else if (document.selection) { | |
| i = new n | |
| } else if (window.getSelection && t.setSelectionRange) { | |
| i = new s | |
| } else if (window.getSelection) { | |
| i = new o | |
| } else { | |
| i = new v | |
| } | |
| i._el = t; | |
| i._textProp = e(t); | |
| i._bounds = [0, i.length()]; | |
| return i | |
| }; | |
| t.prototype = { | |
| length: function () { | |
| return this._el[this._textProp].replace(/\r/g, "").length | |
| }, | |
| bounds: function (e) { | |
| if (e === "all") { | |
| this._bounds = [0, this.length()] | |
| } else if (e === "start") { | |
| this._bounds = [0, 0] | |
| } else if (e === "end") { | |
| this._bounds = [this.length(), this.length()] | |
| } else if (e === "selection") { | |
| this.bounds("all"); | |
| this._bounds = this._nativeSelection() | |
| } else if (e) { | |
| this._bounds = e | |
| } else { | |
| var t = [Math.max(0, Math.min(this.length(), this._bounds[0])), Math.max(0, Math.min(this.length(), this._bounds[1]))]; | |
| return t | |
| } | |
| return this | |
| }, | |
| select: function () { | |
| this._nativeSelect(this._nativeRange(this.bounds())); | |
| return this | |
| }, | |
| text: function (e, t) { | |
| if (arguments.length) { | |
| this._nativeSetText(e, this._nativeRange(this.bounds())); | |
| if (t == "start") { | |
| this.bounds([this._bounds[0], this._bounds[0]]); | |
| this.select() | |
| } else if (t == "end") { | |
| this.bounds([this._bounds[0] + e.length, this._bounds[0] + e.length]); | |
| this.select() | |
| } else if (t == "all") { | |
| this.bounds([this._bounds[0], this._bounds[0] + e.length]); | |
| this.select() | |
| } | |
| return this | |
| } else { | |
| return this._nativeGetText(this._nativeRange(this.bounds())) | |
| } | |
| }, | |
| insertEOL: function () { | |
| this._nativeEOL(); | |
| this._bounds = [this._bounds[0] + 1, this._bounds[0] + 1]; | |
| return this | |
| } | |
| }; | |
| n.prototype = new t; | |
| n.prototype._nativeRange = function (e) { | |
| var t; | |
| if (this._el.tagName == "INPUT") { | |
| t = this._el.createTextRange() | |
| } else { | |
| t = document.body.createTextRange(); | |
| t.moveToElementText(this._el) | |
| } | |
| if (e) { | |
| if (e[1] < 0) e[1] = 0; | |
| if (e[0] > this.length()) e[0] = this.length(); | |
| if (e[1] < t.text.replace(/\r/g, "").length) { | |
| t.moveEnd("character", -1); | |
| t.moveEnd("character", e[1] - t.text.replace(/\r/g, "").length) | |
| } | |
| if (e[0] > 0) t.moveStart("character", e[0]) | |
| } | |
| return t | |
| }; | |
| n.prototype._nativeSelect = function (e) { | |
| e.select() | |
| }; | |
| n.prototype._nativeSelection = function () { | |
| var e = this._nativeRange(); | |
| var t = this.length(); | |
| if (document.selection.type != "Text") return [t, t]; | |
| var n = document.selection.createRange(); | |
| try { | |
| return [r(n, e), i(n, e)] | |
| } catch (s) { | |
| return n.parentElement().sourceIndex < this._el.sourceIndex ? [0, 0] : [t, t] | |
| } | |
| }; | |
| n.prototype._nativeGetText = function (e) { | |
| return e.text.replace(/\r/g, "") | |
| }; | |
| n.prototype._nativeSetText = function (e, t) { | |
| t.text = e | |
| }; | |
| n.prototype._nativeEOL = function () { | |
| if (typeof this._el.value != "undefined") { | |
| this.text("\n") | |
| } else { | |
| this._nativeRange(this.bounds()).pasteHTML("<br/>") | |
| } | |
| }; | |
| s.prototype = new t; | |
| s.prototype._nativeRange = function (e) { | |
| return e || [0, this.length()] | |
| }; | |
| s.prototype._nativeSelect = function (e) { | |
| this._el.setSelectionRange(e[0], e[1]) | |
| }; | |
| s.prototype._nativeSelection = function () { | |
| return [this._el.selectionStart, this._el.selectionEnd] | |
| }; | |
| s.prototype._nativeGetText = function (e) { | |
| return this._el.value.substring(e[0], e[1]) | |
| }; | |
| s.prototype._nativeSetText = function (e, t) { | |
| var n = this._el.value; | |
| this._el.value = n.substring(0, t[0]) + e + n.substring(t[1]) | |
| }; | |
| s.prototype._nativeEOL = function () { | |
| this.text("\n") | |
| }; | |
| o.prototype = new t; | |
| o.prototype._nativeRange = function (e) { | |
| var t = document.createRange(); | |
| t.selectNodeContents(this._el); | |
| if (e) { | |
| a(t, e[0], true, this._el); | |
| t.collapse(true); | |
| a(t, e[1] - e[0], false, this._el) | |
| } | |
| return t | |
| }; | |
| o.prototype._nativeSelect = function (e) { | |
| window.getSelection().removeAllRanges(); | |
| window.getSelection().addRange(e) | |
| }; | |
| o.prototype._nativeSelection = function () { | |
| var e = this._nativeRange(); | |
| if (window.getSelection().rangeCount == 0) return [this.length(), this.length()]; | |
| var t = window.getSelection().getRangeAt(0); | |
| return [p(t, e), d(t, e)] | |
| }; | |
| o.prototype._nativeGetText = function (e) { | |
| return e.toString() | |
| }; | |
| o.prototype._nativeSetText = function (e, t) { | |
| t.deleteContents(); | |
| t.insertNode(document.createTextNode(e)); | |
| this._el.normalize() | |
| }; | |
| o.prototype._nativeEOL = function () { | |
| var e = this._nativeRange(this.bounds()); | |
| e.deleteContents(); | |
| var t = document.createElement("br"); | |
| t.setAttribute("_moz_dirty", ""); | |
| e.insertNode(t); | |
| e.insertNode(document.createTextNode("\n")); | |
| e.collapse(false) | |
| }; | |
| var f = 0; | |
| var l = 1; | |
| var c = 2; | |
| var h = 3; | |
| v.prototype = new t; | |
| v.prototype._nativeRange = function (e) { | |
| return e || [0, this.length()] | |
| }; | |
| v.prototype._nativeSelect = function (e) {}; | |
| v.prototype._nativeSelection = function () { | |
| return [0, 0] | |
| }; | |
| v.prototype._nativeGetText = function (e) { | |
| return this._el[this._textProp].substring(e[0], e[1]) | |
| }; | |
| v.prototype._nativeSetText = function (e, t) { | |
| var n = this._el[this._textProp]; | |
| this._el[this._textProp] = n.substring(0, t[0]) + e + n.substring(t[1]) | |
| }; | |
| v.prototype._nativeEOL = function () { | |
| this.text("\n") | |
| } | |
| })(); | |
| (function (e) { | |
| "use strict"; | |
| function i(e) { | |
| return r.test(Object.prototype.toString.call(e)) | |
| } | |
| function s(e) { | |
| for (var t = 0; t < window.frames.length; t += 1) { | |
| if (window.frames[t].document === e) { | |
| return window.frames[t] | |
| } | |
| } | |
| return window | |
| } | |
| function o(t) { | |
| var n, r; | |
| t = e(t); | |
| if (i(t[0])) { | |
| r = t; | |
| n = { | |
| left: 0, | |
| top: 0 | |
| } | |
| } else { | |
| r = e(t[0].ownerDocument || document); | |
| n = t.offset() | |
| } | |
| return { | |
| x: n.left + t.outerWidth() / 2 - r.scrollLeft(), | |
| y: n.top + t.outerHeight() / 2 - r.scrollTop() | |
| } | |
| } | |
| var t = /^key/, | |
| n = /^(?:mouse|contextmenu)|click/, | |
| r = /\[object (?:HTML)?Document\]/; | |
| e.fn.simulate = function (t, n) { | |
| return this.each(function () { | |
| new e.simulate(this, t, n) | |
| }) | |
| }; | |
| e.simulate = function (t, n, r) { | |
| var i = e.camelCase("simulate-" + n); | |
| this.target = t; | |
| this.options = r || {}; | |
| if (this[i]) { | |
| this[i]() | |
| } else { | |
| this.simulateEvent(t, n, this.options) | |
| } | |
| }; | |
| e.extend(e.simulate.prototype, { | |
| simulateEvent: function (e, t, n) { | |
| var r = this.createEvent(t, n); | |
| this.dispatchEvent(e, t, r, n) | |
| }, | |
| createEvent: function (e, r) { | |
| if (t.test(e)) { | |
| return this.keyEvent(e, r) | |
| } | |
| if (n.test(e)) { | |
| return this.mouseEvent(e, r) | |
| } | |
| }, | |
| mouseEvent: function (t, n) { | |
| var r, o, u = i(this.target) ? this.target : this.target.ownerDocument || document, | |
| a, f; | |
| n = e.extend({ | |
| bubbles: true, | |
| cancelable: t !== "mousemove", | |
| view: s(u), | |
| detail: 0, | |
| screenX: 0, | |
| screenY: 0, | |
| clientX: 1, | |
| clientY: 1, | |
| ctrlKey: false, | |
| altKey: false, | |
| shiftKey: false, | |
| metaKey: false, | |
| button: 0, | |
| relatedTarget: undefined | |
| }, n); | |
| if (u.createEvent) { | |
| r = u.createEvent("MouseEvents"); | |
| r.initMouseEvent(t, n.bubbles, n.cancelable, n.view, n.detail, n.screenX, n.screenY, n.clientX, n.clientY, n.ctrlKey, n.altKey, n.shiftKey, n.metaKey, n.button, n.relatedTarget || u.body.parentNode); | |
| if (r.pageX === 0 && r.pageY === 0 && Object.defineProperty) { | |
| o = i(r.relatedTarget) ? r.relatedTarget : r.relatedTarget.ownerDocument || document; | |
| a = o.documentElement; | |
| f = o.body; | |
| Object.defineProperty(r, "pageX", { | |
| get: function () { | |
| return n.clientX + (a && a.scrollLeft || f && f.scrollLeft || 0) - (a && a.clientLeft || f && f.clientLeft || 0) | |
| } | |
| }); | |
| Object.defineProperty(r, "pageY", { | |
| get: function () { | |
| return n.clientY + (a && a.scrollTop || f && f.scrollTop || 0) - (a && a.clientTop || f && f.clientTop || 0) | |
| } | |
| }) | |
| } | |
| } else if (u.createEventObject) { | |
| r = u.createEventObject(); | |
| e.extend(r, n); | |
| r.button = { | |
| 0: 1, | |
| 1: 4, | |
| 2: 2 | |
| }[r.button] || r.button | |
| } | |
| return r | |
| }, | |
| keyEvent: function (t, n) { | |
| var r, o; | |
| n = e.extend({ | |
| bubbles: true, | |
| cancelable: true, | |
| view: s(o), | |
| ctrlKey: false, | |
| altKey: false, | |
| shiftKey: false, | |
| metaKey: false, | |
| keyCode: 0, | |
| charCode: undefined | |
| }, n); | |
| o = i(this.target) ? this.target : this.target.ownerDocument || document; | |
| if (o.createEvent) { | |
| try { | |
| r = o.createEvent("KeyEvents"); | |
| r.initKeyEvent(t, n.bubbles, n.cancelable, n.view, n.ctrlKey, n.altKey, n.shiftKey, n.metaKey, n.keyCode, n.charCode) | |
| } catch (u) { | |
| r = o.createEvent("Events"); | |
| r.initEvent(t, n.bubbles, n.cancelable); | |
| e.extend(r, { | |
| view: n.view, | |
| ctrlKey: n.ctrlKey, | |
| altKey: n.altKey, | |
| shiftKey: n.shiftKey, | |
| metaKey: n.metaKey, | |
| keyCode: n.keyCode, | |
| charCode: n.charCode | |
| }) | |
| } | |
| } else if (o.createEventObject) { | |
| r = o.createEventObject(); | |
| e.extend(r, n) | |
| } | |
| if (e.browser.msie || e.browser.opera) { | |
| r.keyCode = n.charCode > 0 ? n.charCode : n.keyCode; | |
| r.charCode = undefined | |
| } | |
| return r | |
| }, | |
| dispatchEvent: function (e, t, n) { | |
| if (e.dispatchEvent) { | |
| e.dispatchEvent(n) | |
| } else if (e.fireEvent) { | |
| e.fireEvent("on" + t, n) | |
| } | |
| }, | |
| simulateFocus: function () { | |
| function i() { | |
| n = true | |
| } | |
| var t, n = false, | |
| r = e(this.target); | |
| r.bind("focus", i); | |
| r[0].focus(); | |
| if (!n) { | |
| t = e.Event("focusin"); | |
| t.preventDefault(); | |
| r.trigger(t); | |
| r.triggerHandler("focus") | |
| } | |
| r.unbind("focus", i) | |
| }, | |
| simulateBlur: function () { | |
| function i() { | |
| n = true | |
| } | |
| var t, n = false, | |
| r = e(this.target); | |
| r.bind("blur", i); | |
| r[0].blur(); | |
| setTimeout(function () { | |
| if (r[0].ownerDocument.activeElement === r[0]) { | |
| r[0].ownerDocument.body.focus() | |
| } | |
| if (!n) { | |
| t = e.Event("focusout"); | |
| t.preventDefault(); | |
| r.trigger(t); | |
| r.triggerHandler("blur") | |
| } | |
| r.unbind("blur", i) | |
| }, 1) | |
| } | |
| }); | |
| e.extend(e.simulate.prototype, { | |
| simulateDrag: function () { | |
| var e = this.target, | |
| t = this.options, | |
| n = o(e), | |
| r = Math.floor(n.x), | |
| s = Math.floor(n.y), | |
| u = t.dx || 0, | |
| a = t.dy || 0, | |
| f = { | |
| clientX: r, | |
| clientY: s | |
| }, l = i(e) ? e : e.ownerDocument || document; | |
| this.simulateEvent(e, "mousedown", f); | |
| f = { | |
| clientX: r + 1, | |
| clientY: s + 1 | |
| }; | |
| this.simulateEvent(l, "mousemove", f); | |
| f = { | |
| clientX: r + u, | |
| clientY: s + a | |
| }; | |
| this.simulateEvent(l, "mousemove", f); | |
| this.simulateEvent(l, "mousemove", f); | |
| this.simulateEvent(e, "mouseup", f); | |
| this.simulateEvent(e, "click", f) | |
| } | |
| }) | |
| })(jQuery); | |
| (function (e) { | |
| "use strict"; | |
| var t = e.simulate.prototype.mouseEvent, | |
| n = /\[object (?:HTML)?Document\]/; | |
| e.simulate.prototype.mouseEvent = function (r, i) { | |
| if (i.pageX || i.pageY) { | |
| var s = n.test(Object.prototype.toString.call(this.target)) ? this.target : this.target.ownerDocument || document; | |
| i.clientX = (i.pageX || 0) - e(s).scrollLeft(); | |
| i.clientY = (i.pageY || 0) - e(s).scrollTop() | |
| } | |
| return t.apply(this, [r, i]) | |
| } | |
| })(jQuery); | |
| (function (e) { | |
| "use strict"; | |
| e.extend(e.simulate.prototype, { | |
| simulateKeySequence: function () { | |
| function o() { | |
| e(t).trigger({ | |
| type: "simulate-keySequence", | |
| sequence: r | |
| }); | |
| if (e.isFunction(n.callback)) { | |
| n.callback.apply(t, [{ | |
| sequence: r | |
| }]) | |
| } | |
| } | |
| function u() { | |
| var t = f() - l; | |
| if (t >= n.delay) { | |
| var c = a.exec(r); | |
| if (c !== null) { | |
| var h = c[0]; | |
| (i[h] || e.simulate.prototype.simulateKeySequence.defaults[h] || e.simulate.prototype.simulateKeySequence.defaults.simplechar)(s, h, n); | |
| setTimeout(u, n.delay) | |
| } else { | |
| o() | |
| } | |
| l = f() | |
| } else { | |
| setTimeout(u, n.delay - t) | |
| } | |
| } | |
| var t = this.target, | |
| n = e.extend({ | |
| sequence: "", | |
| triggerKeyEvents: true, | |
| delay: 0, | |
| callback: undefined | |
| }, this.options), | |
| r = n.sequence; | |
| n.delay = parseInt(n.delay, 10); | |
| var i = e.extend({}, n, e(t).data("simulate-keySequence")); | |
| var s = e.data(t, "simulate-keySequence.selection"); | |
| if (!s) { | |
| s = bililiteRange(t).bounds("selection"); | |
| e.data(t, "simulate-keySequence.selection", s); | |
| e(t).bind("mouseup.simulate-keySequence", function () { | |
| e.data(t, "simulate-keySequence.selection").bounds("selection") | |
| }).bind("keyup.simulate-keySequence", function (n) { | |
| if (n.which === 9) { | |
| e.data(t, "simulate-keySequence.selection").select() | |
| } else { | |
| e.data(t, "simulate-keySequence.selection").bounds("selection") | |
| } | |
| }) | |
| } | |
| t.focus(); | |
| if (typeof r === "undefined") { | |
| return | |
| } | |
| r = r.replace(/\n/g, "{enter}"); | |
| if (!n.delay || n.delay <= 0) { | |
| r.replace(/\{[^}]*\}|[^{]+/g, function (t) { | |
| (i[t] || e.simulate.prototype.simulateKeySequence.defaults[t] || e.simulate.prototype.simulateKeySequence.defaults.simplechar)(s, t, n) | |
| }); | |
| o() | |
| } else { | |
| var a = /\{[^}]*\}|[^{]/g; | |
| var f = Date.now || function () { | |
| return (new Date).getTime() | |
| }, l = f(); | |
| u() | |
| } | |
| } | |
| }); | |
| e.extend(e.simulate.prototype.simulateKeySequence.prototype, { | |
| IEKeyCodeTable: { | |
| 33: 49, | |
| 64: 50, | |
| 35: 51, | |
| 36: 52, | |
| 37: 53, | |
| 94: 54, | |
| 38: 55, | |
| 42: 56, | |
| 40: 57, | |
| 41: 48, | |
| 59: 186, | |
| 58: 186, | |
| 61: 187, | |
| 43: 187, | |
| 44: 188, | |
| 60: 188, | |
| 45: 189, | |
| 95: 189, | |
| 46: 190, | |
| 62: 190, | |
| 47: 191, | |
| 63: 191, | |
| 96: 192, | |
| 126: 192, | |
| 91: 219, | |
| 123: 219, | |
| 92: 220, | |
| 124: 220, | |
| 93: 221, | |
| 125: 221, | |
| 39: 222, | |
| 34: 222 | |
| }, | |
| charToKeyCode: function (t) { | |
| var n = e.simulate.prototype.simulateKeySequence.prototype.IEKeyCodeTable; | |
| var r = t.charCodeAt(0); | |
| if (r >= 64 && r <= 90 || r >= 48 && r <= 57) { | |
| return r | |
| } else if (r >= 97 && r <= 122) { | |
| return t.toUpperCase().charCodeAt(0) | |
| } else if (n[r] !== undefined) { | |
| return n[r] | |
| } else { | |
| return r | |
| } | |
| } | |
| }); | |
| e.simulate.prototype.simulateKeySequence.defaults = { | |
| simplechar: function (t, n, r) { | |
| t.text(n, "end"); | |
| if (r.triggerKeyEvents) { | |
| for (var i = 0; i < n.length; i += 1) { | |
| var s = n.charCodeAt(i); | |
| var o = e.simulate.prototype.simulateKeySequence.prototype.charToKeyCode(n.charAt(i)); | |
| e(t._el).simulate("keydown", { | |
| keyCode: o | |
| }); | |
| e(t._el).simulate("keypress", { | |
| keyCode: s, | |
| which: s, | |
| charCode: s | |
| }); | |
| e(t._el).simulate("keyup", { | |
| keyCode: o | |
| }) | |
| } | |
| } | |
| }, | |
| "{{}": function (t, n, r) { | |
| e.simulate.prototype.simulateKeySequence.defaults.simplechar(t, "{", r) | |
| }, | |
| "{enter}": function (t, n, r) { | |
| t.insertEOL(); | |
| t.select(); | |
| if (r.triggerKeyEvents === true) { | |
| e(t._el).simulate("keydown", { | |
| keyCode: 13 | |
| }); | |
| e(t._el).simulate("keypress", { | |
| keyCode: 13, | |
| which: 13, | |
| charCode: 13 | |
| }); | |
| e(t._el).simulate("keyup", { | |
| keyCode: 13 | |
| }) | |
| } | |
| }, | |
| "{backspace}": function (t, n, r) { | |
| var i = t.bounds(); | |
| if (i[0] === i[1]) { | |
| t.bounds([i[0] - 1, i[0]]) | |
| } | |
| t.text("", "end"); | |
| if (r.triggerKeyEvents === true) { | |
| e(t._el).simulate("keydown", { | |
| keyCode: 8 | |
| }); | |
| e(t._el).simulate("keyup", { | |
| keyCode: 8 | |
| }) | |
| } | |
| }, | |
| "{del}": function (t, n, r) { | |
| var i = t.bounds(); | |
| if (i[0] === i[1]) { | |
| t.bounds([i[0], i[0] + 1]) | |
| } | |
| t.text("", "end"); | |
| if (r.triggerKeyEvents === true) { | |
| e(t._el).simulate("keydown", { | |
| keyCode: 46 | |
| }); | |
| e(t._el).simulate("keyup", { | |
| keyCode: 46 | |
| }) | |
| } | |
| }, | |
| "{rightarrow}": function (t, n, r) { | |
| var i = t.bounds(); | |
| if (i[0] === i[1]) { | |
| i[1] += 1 | |
| } | |
| t.bounds([i[1], i[1]]).select(); | |
| if (r.triggerKeyEvents === true) { | |
| e(t._el).simulate("keydown", { | |
| keyCode: 39 | |
| }); | |
| e(t._el).simulate("keyup", { | |
| keyCode: 39 | |
| }) | |
| } | |
| }, | |
| "{leftarrow}": function (t, n, r) { | |
| var i = t.bounds(); | |
| if (i[0] === i[1]) { | |
| i[0] -= 1 | |
| } | |
| t.bounds([i[0], i[0]]).select(); | |
| if (r.triggerKeyEvents === true) { | |
| e(t._el).simulate("keydown", { | |
| keyCode: 37 | |
| }); | |
| e(t._el).simulate("keyup", { | |
| keyCode: 37 | |
| }) | |
| } | |
| }, | |
| "{selectall}": function (e) { | |
| e.bounds("all").select() | |
| } | |
| } | |
| })(jQuery); | |
| jQuery.fn.addModalKeyboardShortcuts = function (e, t) { | |
| this.each(function () { | |
| for (var n in e) { | |
| if (e.hasOwnProperty(n)) { | |
| $(this).bind("keydown", n, e[n]) | |
| } | |
| } | |
| for (var n in t) { | |
| if (t.hasOwnProperty(n)) { | |
| $(this).unbind("keydown", t[n]) | |
| } | |
| } | |
| }) | |
| }; | |
| jQuery.fn.addGlobalKeyboardShortcuts = function () { | |
| this.each(function () { | |
| $(this).registerHandlerForShortcuts("s", ["ctrl", "meta"], function () { | |
| saveEditingContent(); | |
| pushpoll.scheduleNextPushAndPoll(true); | |
| return false | |
| }); | |
| $(this).registerHandlerForShortcuts("z", ["ctrl", "meta"], function () { | |
| undoredo.undo(); | |
| return false | |
| }); | |
| $(this).registerHandlerForShortcuts("shift+z", ["ctrl", "meta"], function () { | |
| undoredo.redo(); | |
| return false | |
| }); | |
| $(this).registerHandlerForShortcuts("y", ["ctrl", "meta"], function () { | |
| undoredo.redo(); | |
| return false | |
| }); | |
| $(this).registerHandlerForShortcuts("home", ["ctrl", "meta"], function () { | |
| var e = getCurrentlyFocusedEditor(); | |
| if (!(e !== null && e.isNote())) { | |
| focusFirstProject(); | |
| return false | |
| } | |
| }); | |
| $(this).registerHandlerForShortcuts("end", ["ctrl", "meta"], function () { | |
| var e = getCurrentlyFocusedEditor(); | |
| if (!(e !== null && e.isNote())) { | |
| focusLastProject(); | |
| return false | |
| } | |
| }); | |
| $(this).registerHandlerForShortcuts("shift+/", ["ctrl", "meta"], function () { | |
| keyboardShortcutHelper.toggle(); | |
| return false | |
| }); | |
| $(this).registerHandlerForShortcuts("/", ["ctrl", "meta"], function () { | |
| keyboardShortcutHelper.toggle(); | |
| return false | |
| }) | |
| }); | |
| return this | |
| }; | |
| var commands = { | |
| deleteWordBack: function (e) { | |
| e.preventDefault(); | |
| var t = indexOfNextCaret($(e.target).getCaret().start, $(e.target).val(), { | |
| backward: true, | |
| shift: true | |
| }); | |
| var n = $(e.target).getCaret().start - t; | |
| for (var r = 0; r < n; r++) { | |
| $(e.target).simulate("key-sequence", { | |
| sequence: "{backspace}", | |
| triggerKeyEvents: true | |
| }) | |
| } | |
| return false | |
| }, | |
| deleteItemBack: function (e) { | |
| e.preventDefault(); | |
| var t = $(e.target).getCaret().start; | |
| for (var n = 0; n < t; n++) { | |
| $(e.target).simulate("key-sequence", { | |
| sequence: "{backspace}", | |
| triggerKeyEvents: true | |
| }) | |
| } | |
| return false | |
| }, | |
| moveWordForward: function (e) { | |
| e.preventDefault(); | |
| var t = indexOfNextCaret($(e.target).getCaret().start, $(e.target).val(), { | |
| shift: true | |
| }); | |
| if (t > 0) { | |
| $(e.target).setCaret(t) | |
| } else { | |
| $(e.target).setCaret($(e.target).val().length); | |
| $(e.target).rightArrowHandler() | |
| } | |
| return false | |
| }, | |
| moveWordBackward: function (e) { | |
| e.preventDefault(); | |
| var t = indexOfNextCaret($(e.target).getCaret().start, $(e.target).val(), { | |
| backward: true, | |
| shift: true | |
| }); | |
| if (t > -1) { | |
| $(e.target).setCaret(t) | |
| } else { | |
| $(e.target).setCaret(0); | |
| $(e.target).leftArrowHandler() | |
| } | |
| return false | |
| }, | |
| doBackspace: function (e) { | |
| e.preventDefault(); | |
| $(e.target).simulate("key-sequence", { | |
| sequence: "{backspace}", | |
| triggerKeyEvents: true | |
| }); | |
| return false | |
| }, | |
| moveDown: function (e) { | |
| e.preventDefault(); | |
| $(e.target).downArrowHandler(); | |
| return false | |
| }, | |
| moveUp: function (e) { | |
| e.preventDefault(); | |
| $(e.target).upArrowHandler(); | |
| return false | |
| }, | |
| moveLeft: function (e) { | |
| e.preventDefault(); | |
| if ($(e.target).getCaret().start === 0) { | |
| $(e.target).leftArrowHandler() | |
| } else { | |
| $(e.target).simulate("key-sequence", { | |
| sequence: "{leftarrow}", | |
| triggerKeyEvents: false | |
| }) | |
| } | |
| return false | |
| }, | |
| moveRight: function (e) { | |
| e.preventDefault(); | |
| if ($(e.target).getCaret().start === $(e.target).val().length) { | |
| $(e.target).rightArrowHandler() | |
| } else { | |
| $(e.target).simulate("key-sequence", { | |
| sequence: "{rightarrow}", | |
| triggerKeyEvents: false | |
| }) | |
| } | |
| return false | |
| }, | |
| doUndo: function (e) { | |
| undoredo.undo(); | |
| return false | |
| }, | |
| doRedo: function (e) { | |
| e.preventDefault(); | |
| undoredo.redo(); | |
| return false | |
| }, | |
| toggleFold: function (e) { | |
| $(e.target).keyboardExpandToggle(); | |
| return false | |
| }, | |
| openFold: function (e) { | |
| $(e.target).keyboardExpand(); | |
| return false | |
| }, | |
| closeFold: function (e) { | |
| $(e.target).keyboardCollapse(); | |
| return false | |
| }, | |
| zoomInFold: function (e) { | |
| $(e.target).keyboardZoomIn(); | |
| return false | |
| }, | |
| zoomOutFold: function (e) { | |
| keyboardZoomOut(); | |
| return false | |
| }, | |
| doIndent: function (e) { | |
| $(e.target).indentProject(); | |
| return false | |
| }, | |
| doDedent: function (e) { | |
| $(e.target).dedentProject(); | |
| return false | |
| }, | |
| createNewAfter: function (e) { | |
| e.preventDefault(); | |
| $(e.target).setCaret($(e.target).val().length); | |
| $(e.target).returnHandler(); | |
| enterInsertMode(e); | |
| return false | |
| }, | |
| createNewBefore: function (e) { | |
| e.preventDefault(); | |
| $(e.target).setCaret(0); | |
| $(e.target).returnHandler(); | |
| $(e.target).upArrowHandler(); | |
| enterInsertMode(e); | |
| return false | |
| }, | |
| insertBeginning: function (e) { | |
| e.preventDefault(); | |
| $(e.target).setCaret(0); | |
| enterInsertMode(e); | |
| return false | |
| }, | |
| insertEnd: function (e) { | |
| e.preventDefault(); | |
| $(e.target).setCaret($(e.target).val().length); | |
| enterInsertMode(e); | |
| return false | |
| }, | |
| doProjectUp: function (e) { | |
| e.preventDefault(); | |
| $(e.target).moveProjectUp(); | |
| return false | |
| }, | |
| doProjectDown: function (e) { | |
| e.preventDefault(); | |
| $(e.target).moveProjectDown(); | |
| return false | |
| }, | |
| enterSearchMode: function () { | |
| $("#searchBox").focus(); | |
| return false | |
| } | |
| }; | |
| var indicesOf = function (e, t) { | |
| var n = 0, | |
| r = e.length; | |
| var i, s = []; | |
| while ((i = t.indexOf(e, n)) > -1) { | |
| s.push(i); | |
| n = i + r | |
| } | |
| return s | |
| }; | |
| var indexOfNextCaret = function (e, t, n) { | |
| if (typeof n === "undefined") { | |
| var n = new Object; | |
| n.backward = false; | |
| n.shift = false | |
| } else { | |
| n.backward = typeof n.backward !== "undefined" ? n.backward : false; | |
| n.shift = typeof n.shift !== "undefined" ? n.shift : false | |
| } | |
| var r, i = []; | |
| var s = " "; | |
| if (n.backward == false) { | |
| r = t.indexOf(s, e + 1) | |
| } else { | |
| if (t.charAt(e - 1) == " ") { | |
| e-- | |
| } | |
| while (t.indexOf(s, r + 1) > -1 && t.indexOf(s, r + 1) < e) { | |
| r = t.indexOf(s, r + 1) | |
| } | |
| if (isNaN(r)) { | |
| r = -1 | |
| } | |
| if (e == 0) { | |
| r = -2 | |
| } | |
| } | |
| if (n.shift == true) { | |
| r++ | |
| } | |
| return r | |
| }; | |
| var normalKeybindings = { | |
| j: commands.moveDown, | |
| k: commands.moveUp, | |
| h: commands.moveLeft, | |
| l: commands.moveRight, | |
| w: commands.moveWordForward, | |
| b: commands.moveWordBackward, | |
| x: commands.doBackspace, | |
| "shift+o": commands.createNewBefore, | |
| o: commands.createNewAfter, | |
| "shift+i": commands.insertBeginning, | |
| "shift+a": commands.insertEnd, | |
| u: commands.doUndo, | |
| "ctrl+r": commands.doRedo, | |
| i: enterInsertMode, | |
| a: enterInsertMode | |
| }; | |
| var insertKeybindings = { | |
| esc: enterNormalMode, | |
| "ctrl+c": enterNormalMode, | |
| "ctrl+w": commands.deleteWordBack, | |
| "ctrl+u": commands.deleteItemBack | |
| }; | |
| var alwaysKeybindings = { | |
| "alt+l": commands.zoomInFold, | |
| "alt+h": commands.zoomOutFold, | |
| "alt+shift+l": commands.doIndent, | |
| "alt+shift+h": commands.doDedent, | |
| "alt+shift+k": commands.doProjectUp, | |
| "alt+shift+j": commands.doProjectDown | |
| }; | |
| $(".editor > textarea").unbind("keydown"); | |
| $(".editor > textarea").addTextAreaEventHandlers(); | |
| $(".editor > textarea").addModalKeyboardShortcuts(alwaysKeybindings); | |
| var blockAll = function (e) { | |
| e.preventDefault() | |
| }; | |
| enterNormalMode() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment