You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3442 lines
107 KiB
3442 lines
107 KiB
/* ***** BEGIN LICENSE BLOCK ***** |
|
* Distributed under the BSD license: |
|
* |
|
* Copyright (c) 2010, Ajax.org B.V. |
|
* All rights reserved. |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions are met: |
|
* * Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* * Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in the |
|
* documentation and/or other materials provided with the distribution. |
|
* * Neither the name of Ajax.org B.V. nor the |
|
* names of its contributors may be used to endorse or promote products |
|
* derived from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
|
* DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY |
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* |
|
* ***** END LICENSE BLOCK ***** */ |
|
|
|
|
|
define('kitchen-sink/demo', ['require', 'exports', 'module' , 'ace/lib/fixoldbrowsers', 'ace/config', 'ace/lib/dom', 'ace/lib/net', 'ace/lib/lang', 'ace/lib/useragent', 'ace/lib/event', 'ace/theme/textmate', 'ace/edit_session', 'ace/undomanager', 'ace/keyboard/hash_handler', 'ace/virtual_renderer', 'ace/editor', 'ace/multi_select', 'kitchen-sink/doclist', 'kitchen-sink/modelist', 'kitchen-sink/layout', 'kitchen-sink/token_tooltip', 'kitchen-sink/util', 'ace/ext/elastic_tabstops_lite', 'ace/split', 'ace/keyboard/vim', 'kitchen-sink/statusbar'], function(require, exports, module) { |
|
|
|
|
|
require("ace/lib/fixoldbrowsers"); |
|
require("ace/config").init(); |
|
var env = {}; |
|
|
|
var dom = require("ace/lib/dom"); |
|
var net = require("ace/lib/net"); |
|
var lang = require("ace/lib/lang"); |
|
var useragent = require("ace/lib/useragent"); |
|
|
|
var event = require("ace/lib/event"); |
|
var theme = require("ace/theme/textmate"); |
|
var EditSession = require("ace/edit_session").EditSession; |
|
var UndoManager = require("ace/undomanager").UndoManager; |
|
|
|
var HashHandler = require("ace/keyboard/hash_handler").HashHandler; |
|
|
|
var Renderer = require("ace/virtual_renderer").VirtualRenderer; |
|
var Editor = require("ace/editor").Editor; |
|
var MultiSelect = require("ace/multi_select").MultiSelect; |
|
|
|
var doclist = require("./doclist"); |
|
var modelist = require("./modelist"); |
|
var layout = require("./layout"); |
|
var TokenTooltip = require("./token_tooltip").TokenTooltip; |
|
var util = require("./util"); |
|
var saveOption = util.saveOption; |
|
var fillDropdown = util.fillDropdown; |
|
var bindCheckbox = util.bindCheckbox; |
|
var bindDropdown = util.bindDropdown; |
|
|
|
var ElasticTabstopsLite = require("ace/ext/elastic_tabstops_lite").ElasticTabstopsLite; |
|
var container = document.getElementById("editor-container"); |
|
var Split = require("ace/split").Split; |
|
var split = new Split(container, theme, 1); |
|
env.editor = split.getEditor(0); |
|
split.on("focus", function(editor) { |
|
env.editor = editor; |
|
updateUIEditorOptions(); |
|
}); |
|
env.split = split; |
|
window.env = env; |
|
window.ace = env.editor; |
|
env.editor.setAnimatedScroll(true); |
|
require("ace/multi_select").MultiSelect(env.editor); |
|
|
|
var consoleEl = dom.createElement("div"); |
|
container.parentNode.appendChild(consoleEl); |
|
consoleEl.style.cssText = "position:fixed; bottom:1px; right:0;\ |
|
border:1px solid #baf; zIndex:100"; |
|
|
|
var cmdLine = new layout.singleLineEditor(consoleEl); |
|
cmdLine.editor = env.editor; |
|
env.editor.cmdLine = cmdLine; |
|
env.editor.commands.addCommands([{ |
|
name: "gotoline", |
|
bindKey: {win: "Ctrl-L", mac: "Command-L"}, |
|
exec: function(editor, line) { |
|
if (typeof line == "object") { |
|
var arg = this.name + " " + editor.getCursorPosition().row; |
|
editor.cmdLine.setValue(arg, 1); |
|
editor.cmdLine.focus(); |
|
return; |
|
} |
|
line = parseInt(line, 10); |
|
if (!isNaN(line)) |
|
editor.gotoLine(line); |
|
}, |
|
readOnly: true |
|
}/*, { |
|
name: "find", |
|
bindKey: {win: "Ctrl-F", mac: "Command-F"}, |
|
exec: function(editor, needle) { |
|
if (typeof needle == "object") { |
|
var arg = this.name + " " + editor.getCopyText(); |
|
editor.cmdLine.setValue(arg, 1); |
|
editor.cmdLine.focus(); |
|
return; |
|
} |
|
editor.find(needle); |
|
}, |
|
readOnly: true |
|
}*/, { |
|
name: "focusCommandLine", |
|
bindKey: "shift-esc", |
|
exec: function(editor, needle) { editor.cmdLine.focus(); }, |
|
readOnly: true |
|
}, { |
|
name: "execute", |
|
bindKey: "ctrl+enter", |
|
exec: function(editor) { |
|
try { |
|
var r = eval(editor.getCopyText()||editor.getValue()); |
|
} catch(e) { |
|
r = e; |
|
} |
|
editor.cmdLine.setValue(r + "") |
|
}, |
|
readOnly: true |
|
}]); |
|
|
|
cmdLine.commands.bindKeys({ |
|
"Shift-Return|Ctrl-Return|Alt-Return": function(cmdLine) { cmdLine.insert("\n"); }, |
|
"Esc|Shift-Esc": function(cmdLine){ cmdLine.editor.focus(); }, |
|
"Return": function(cmdLine){ |
|
var command = cmdLine.getValue().split(/\s+/); |
|
var editor = cmdLine.editor; |
|
editor.commands.exec(command[0], editor, command[1]); |
|
editor.focus(); |
|
} |
|
}); |
|
|
|
cmdLine.commands.removeCommands(["find", "gotoline", "findall", "replace", "replaceall"]); |
|
|
|
var commands = env.editor.commands; |
|
commands.addCommand({ |
|
name: "save", |
|
bindKey: {win: "Ctrl-S", mac: "Command-S"}, |
|
exec: function() {alert("Fake Save File");} |
|
}); |
|
|
|
var keybindings = { |
|
ace: null, // Null = use "default" keymapping |
|
vim: require("ace/keyboard/vim").handler, |
|
emacs: "ace/keyboard/emacs", |
|
custom: new HashHandler({ |
|
"gotoright": "Tab", |
|
"indent": "]", |
|
"outdent": "[", |
|
"gotolinestart": "^", |
|
"gotolineend": "$" |
|
}) |
|
}; |
|
var consoleHeight = 20; |
|
function onResize() { |
|
var left = env.split.$container.offsetLeft; |
|
var width = document.documentElement.clientWidth - left; |
|
container.style.width = width + "px"; |
|
container.style.height = document.documentElement.clientHeight - consoleHeight + "px"; |
|
env.split.resize(); |
|
|
|
consoleEl.style.width = width + "px"; |
|
cmdLine.resize(); |
|
} |
|
|
|
window.onresize = onResize; |
|
onResize(); |
|
var docEl = document.getElementById("doc"); |
|
var modeEl = document.getElementById("mode"); |
|
var wrapModeEl = document.getElementById("soft_wrap"); |
|
var themeEl = document.getElementById("theme"); |
|
var foldingEl = document.getElementById("folding"); |
|
var selectStyleEl = document.getElementById("select_style"); |
|
var highlightActiveEl = document.getElementById("highlight_active"); |
|
var showHiddenEl = document.getElementById("show_hidden"); |
|
var showGutterEl = document.getElementById("show_gutter"); |
|
var showPrintMarginEl = document.getElementById("show_print_margin"); |
|
var highlightSelectedWordE = document.getElementById("highlight_selected_word"); |
|
var showHScrollEl = document.getElementById("show_hscroll"); |
|
var animateScrollEl = document.getElementById("animate_scroll"); |
|
var softTabEl = document.getElementById("soft_tab"); |
|
var behavioursEl = document.getElementById("enable_behaviours"); |
|
|
|
fillDropdown(docEl, doclist.all); |
|
|
|
fillDropdown(modeEl, modelist.modes); |
|
var modesByName = modelist.modesByName; |
|
bindDropdown("mode", function(value) { |
|
env.editor.session.setMode(modesByName[value].mode || modesByName.text.mode); |
|
env.editor.session.modeName = value; |
|
}); |
|
|
|
bindDropdown("doc", function(name) { |
|
doclist.loadDoc(name, function(session) { |
|
if (!session) |
|
return; |
|
session = env.split.setSession(session); |
|
updateUIEditorOptions(); |
|
env.editor.focus(); |
|
}); |
|
}); |
|
|
|
function updateUIEditorOptions() { |
|
var editor = env.editor; |
|
var session = editor.session; |
|
|
|
session.setFoldStyle(foldingEl.value); |
|
|
|
saveOption(docEl, session.name); |
|
saveOption(modeEl, session.modeName || "text"); |
|
saveOption(wrapModeEl, session.getUseWrapMode() ? session.getWrapLimitRange().min || "free" : "off"); |
|
|
|
saveOption(selectStyleEl, editor.getSelectionStyle() == "line"); |
|
saveOption(themeEl, editor.getTheme()); |
|
saveOption(highlightActiveEl, editor.getHighlightActiveLine()); |
|
saveOption(showHiddenEl, editor.getShowInvisibles()); |
|
saveOption(showGutterEl, editor.renderer.getShowGutter()); |
|
saveOption(showPrintMarginEl, editor.renderer.getShowPrintMargin()); |
|
saveOption(highlightSelectedWordE, editor.getHighlightSelectedWord()); |
|
saveOption(showHScrollEl, editor.renderer.getHScrollBarAlwaysVisible()); |
|
saveOption(animateScrollEl, editor.getAnimatedScroll()); |
|
saveOption(softTabEl, session.getUseSoftTabs()); |
|
saveOption(behavioursEl, editor.getBehavioursEnabled()); |
|
} |
|
|
|
event.addListener(themeEl, "mouseover", function(e){ |
|
this.desiredValue = e.target.value; |
|
if (!this.$timer) |
|
this.$timer = setTimeout(this.updateTheme); |
|
}); |
|
|
|
event.addListener(themeEl, "mouseout", function(e){ |
|
this.desiredValue = null; |
|
if (!this.$timer) |
|
this.$timer = setTimeout(this.updateTheme, 20); |
|
}); |
|
|
|
themeEl.updateTheme = function(){ |
|
env.split.setTheme(themeEl.desiredValue || themeEl.selectedValue); |
|
themeEl.$timer = null; |
|
}; |
|
|
|
bindDropdown("theme", function(value) { |
|
if (!value) |
|
return; |
|
env.editor.setTheme(value); |
|
themeEl.selectedValue = value; |
|
}); |
|
|
|
bindDropdown("keybinding", function(value) { |
|
env.editor.setKeyboardHandler(keybindings[value]); |
|
}); |
|
|
|
bindDropdown("fontsize", function(value) { |
|
env.split.setFontSize(value); |
|
}); |
|
|
|
bindDropdown("folding", function(value) { |
|
env.editor.session.setFoldStyle(value); |
|
env.editor.setShowFoldWidgets(value !== "manual"); |
|
}); |
|
|
|
bindDropdown("soft_wrap", function(value) { |
|
var session = env.editor.session; |
|
var renderer = env.editor.renderer; |
|
switch (value) { |
|
case "off": |
|
session.setUseWrapMode(false); |
|
renderer.setPrintMarginColumn(80); |
|
break; |
|
case "free": |
|
session.setUseWrapMode(true); |
|
session.setWrapLimitRange(null, null); |
|
renderer.setPrintMarginColumn(80); |
|
break; |
|
default: |
|
session.setUseWrapMode(true); |
|
var col = parseInt(value, 10); |
|
session.setWrapLimitRange(col, col); |
|
renderer.setPrintMarginColumn(col); |
|
} |
|
}); |
|
|
|
bindCheckbox("select_style", function(checked) { |
|
env.editor.setSelectionStyle(checked ? "line" : "text"); |
|
}); |
|
|
|
bindCheckbox("highlight_active", function(checked) { |
|
env.editor.setHighlightActiveLine(checked); |
|
}); |
|
|
|
bindCheckbox("show_hidden", function(checked) { |
|
env.editor.setShowInvisibles(checked); |
|
}); |
|
|
|
bindCheckbox("display_indent_guides", function(checked) { |
|
env.editor.setDisplayIndentGuides(checked); |
|
}); |
|
|
|
bindCheckbox("show_gutter", function(checked) { |
|
env.editor.renderer.setShowGutter(checked); |
|
}); |
|
|
|
bindCheckbox("show_print_margin", function(checked) { |
|
env.editor.renderer.setShowPrintMargin(checked); |
|
}); |
|
|
|
bindCheckbox("highlight_selected_word", function(checked) { |
|
env.editor.setHighlightSelectedWord(checked); |
|
}); |
|
|
|
bindCheckbox("show_hscroll", function(checked) { |
|
env.editor.renderer.setHScrollBarAlwaysVisible(checked); |
|
}); |
|
|
|
bindCheckbox("animate_scroll", function(checked) { |
|
env.editor.setAnimatedScroll(checked); |
|
}); |
|
|
|
bindCheckbox("soft_tab", function(checked) { |
|
env.editor.session.setUseSoftTabs(checked); |
|
}); |
|
|
|
bindCheckbox("enable_behaviours", function(checked) { |
|
env.editor.setBehavioursEnabled(checked); |
|
}); |
|
|
|
bindCheckbox("fade_fold_widgets", function(checked) { |
|
env.editor.setFadeFoldWidgets(checked); |
|
}); |
|
bindCheckbox("read_only", function(checked) { |
|
env.editor.setReadOnly(checked); |
|
}); |
|
|
|
bindDropdown("split", function(value) { |
|
var sp = env.split; |
|
if (value == "none") { |
|
sp.setSplits(1); |
|
} else { |
|
var newEditor = (sp.getSplits() == 1); |
|
sp.setOrientation(value == "below" ? sp.BELOW : sp.BESIDE); |
|
sp.setSplits(2); |
|
|
|
if (newEditor) { |
|
var session = sp.getEditor(0).session; |
|
var newSession = sp.setSession(session, 1); |
|
newSession.name = session.name; |
|
} |
|
} |
|
}); |
|
|
|
|
|
bindCheckbox("elastic_tabstops", function(checked) { |
|
env.editor.setOption("useElasticTabstops", checked); |
|
}); |
|
|
|
|
|
function synchroniseScrolling() { |
|
var s1 = env.split.$editors[0].session; |
|
var s2 = env.split.$editors[1].session; |
|
s1.on('changeScrollTop', function(pos) {s2.setScrollTop(pos)}); |
|
s2.on('changeScrollTop', function(pos) {s1.setScrollTop(pos)}); |
|
s1.on('changeScrollLeft', function(pos) {s2.setScrollLeft(pos)}); |
|
s2.on('changeScrollLeft', function(pos) {s1.setScrollLeft(pos)}); |
|
} |
|
|
|
bindCheckbox("highlight_token", function(checked) { |
|
var editor = env.editor; |
|
if (editor.tokenTooltip && !checked) { |
|
editor.tokenTooltip.destroy(); |
|
delete editor.tokenTooltip; |
|
} else if (checked) { |
|
editor.tokenTooltip = new TokenTooltip(editor); |
|
} |
|
}); |
|
event.addListener(container, "dragover", function(e) { |
|
var types = e.dataTransfer.types; |
|
if (types && Array.prototype.indexOf.call(types, 'Files') !== -1) |
|
return event.preventDefault(e); |
|
}); |
|
|
|
event.addListener(container, "drop", function(e) { |
|
var file; |
|
try { |
|
file = e.dataTransfer.files[0]; |
|
if (window.FileReader) { |
|
var reader = new FileReader(); |
|
reader.onload = function() { |
|
var mode = modelist.getModeFromPath(file.name); |
|
|
|
env.editor.session.doc.setValue(reader.result); |
|
modeEl.value = mode.name; |
|
env.editor.session.setMode(mode.mode); |
|
env.editor.session.modeName = mode.name; |
|
}; |
|
reader.readAsText(file); |
|
} |
|
return event.preventDefault(e); |
|
} catch(err) { |
|
return event.stopEvent(e); |
|
} |
|
}); |
|
|
|
|
|
|
|
var StatusBar = require("./statusbar").StatusBar; |
|
new StatusBar(env.editor, cmdLine.container); |
|
|
|
}); |
|
|
|
define('kitchen-sink/doclist', ['require', 'exports', 'module' , 'ace/edit_session', 'ace/undomanager', 'ace/lib/net', 'kitchen-sink/modelist'], function(require, exports, module) { |
|
|
|
|
|
var EditSession = require("ace/edit_session").EditSession; |
|
var UndoManager = require("ace/undomanager").UndoManager; |
|
var net = require("ace/lib/net"); |
|
|
|
var modelist = require("./modelist"); |
|
var fileCache = {}; |
|
|
|
function initDoc(file, path, doc) { |
|
if (doc.prepare) |
|
file = doc.prepare(file); |
|
|
|
var session = new EditSession(file); |
|
session.setUndoManager(new UndoManager()); |
|
doc.session = session; |
|
doc.path = path; |
|
if (doc.wrapped) { |
|
session.setUseWrapMode(true); |
|
session.setWrapLimitRange(80, 80); |
|
} |
|
var mode = modelist.getModeFromPath(path); |
|
session.modeName = mode.name; |
|
session.setMode(mode.mode); |
|
} |
|
|
|
|
|
function makeHuge(txt) { |
|
for (var i = 0; i < 5; i++) |
|
txt += txt; |
|
return txt; |
|
} |
|
|
|
var docs = { |
|
"docs/AsciiDoc.asciidoc": "AsciiDoc", |
|
"docs/javascript.js": "JavaScript", |
|
"docs/clojure.clj": "Clojure", |
|
"docs/coffeescript.coffee": "CoffeeScript", |
|
"docs/coldfusion.cfm": "ColdFusion", |
|
"docs/cpp.cpp": "C/C++", |
|
"docs/csharp.cs": "C#", |
|
"docs/css.css": "CSS", |
|
"docs/curly.curly": "Curly", |
|
"docs/dart.dart": "Dart", |
|
"docs/diff.diff": "Diff", |
|
"docs/dot.dot": "Dot", |
|
"docs/freemarker.ftl" : "FreeMarker", |
|
"docs/glsl.glsl": "Glsl", |
|
"docs/golang.go": "Go", |
|
"docs/groovy.groovy": "Groovy", |
|
"docs/haml.haml": "Haml", |
|
"docs/Haxe.hx": "haXe", |
|
"docs/html.html": "HTML", |
|
"docs/jade.jade": "Jade", |
|
"docs/java.java": "Java", |
|
"docs/jsp.jsp": "JSP", |
|
"docs/json.json": "JSON", |
|
"docs/jsx.jsx": "JSX", |
|
"docs/latex.tex": {name: "LaTeX", wrapped: true}, |
|
"docs/less.less": "LESS", |
|
"docs/lisp.lisp": "Lisp", |
|
"docs/lsl.lsl": "LSL", |
|
"docs/scheme.scm": "Scheme", |
|
"docs/livescript.ls": "LiveScript", |
|
"docs/liquid.liquid": "Liquid", |
|
"docs/logiql.logic": "LogiQL", |
|
"docs/lua.lua": "Lua", |
|
"docs/lucene.lucene": "Lucene", |
|
"docs/luapage.lp": "LuaPage", |
|
"docs/Makefile": "Makefile", |
|
"docs/markdown.md": {name: "Markdown", wrapped: true}, |
|
"docs/objectivec.m": {name: "Objective-C"}, |
|
"docs/ocaml.ml": "OCaml", |
|
"docs/OpenSCAD.scad": "OpenSCAD", |
|
"docs/pascal.pas": "Pascal", |
|
"docs/perl.pl": "Perl", |
|
"docs/pgsql.pgsql": {name: "pgSQL", wrapped: true}, |
|
"docs/php.php": "PHP", |
|
"docs/plaintext.txt": {name: "Plain Text", prepare: makeHuge, wrapped: true}, |
|
"docs/powershell.ps1": "Powershell", |
|
"docs/python.py": "Python", |
|
"docs/r.r": "R", |
|
"docs/rdoc.Rd": "RDoc", |
|
"docs/rhtml.rhtml": "RHTML", |
|
"docs/ruby.rb": "Ruby", |
|
"docs/abap.abap": "SAP - ABAP", |
|
"docs/scala.scala": "Scala", |
|
"docs/scss.scss": "SCSS", |
|
"docs/sass.sass": "SASS", |
|
"docs/sh.sh": "SH", |
|
"docs/stylus.styl": "Stylus", |
|
"docs/sql.sql": {name: "SQL", wrapped: true}, |
|
"docs/svg.svg": "SVG", |
|
"docs/tcl.tcl": "Tcl", |
|
"docs/tex.tex": "Tex", |
|
"docs/textile.textile": {name: "Textile", wrapped: true}, |
|
"docs/tmSnippet.tmSnippet": "tmSnippet", |
|
"docs/toml.toml": "TOML", |
|
"docs/typescript.ts": "Typescript", |
|
"docs/vbscript.vbs": "VBScript", |
|
"docs/xml.xml": "XML", |
|
"docs/xquery.xq": "XQuery", |
|
"docs/yaml.yaml": "YAML", |
|
"docs/c9search.c9search_results": "C9 Search Results" |
|
}; |
|
|
|
var ownSource = { |
|
}; |
|
|
|
var hugeDocs = { |
|
"src/ace.js": "", |
|
"src-min/ace.js": "" |
|
}; |
|
|
|
if (window.require && window.require.s) try { |
|
for (var path in window.require.s.contexts._.defined) { |
|
if (path.indexOf("!") != -1) |
|
path = path.split("!").pop(); |
|
else |
|
path = path + ".js"; |
|
ownSource[path] = ""; |
|
} |
|
} catch(e) {} |
|
|
|
function prepareDocList(docs) { |
|
var list = []; |
|
for (var path in docs) { |
|
var doc = docs[path]; |
|
if (typeof doc != "object") |
|
doc = {name: doc || path}; |
|
|
|
doc.path = path; |
|
doc.desc = doc.name.replace(/^(ace|docs|demo|build)\//, ""); |
|
if (doc.desc.length > 18) |
|
doc.desc = doc.desc.slice(0, 7) + ".." + doc.desc.slice(-9); |
|
|
|
fileCache[doc.name] = doc; |
|
list.push(doc); |
|
} |
|
|
|
return list; |
|
} |
|
|
|
function loadDoc(name, callback) { |
|
var doc = fileCache[name]; |
|
if (!doc) |
|
return callback(null); |
|
|
|
if (doc.session) |
|
return callback(doc.session); |
|
var path = doc.path; |
|
var parts = path.split("/"); |
|
if (parts[0] == "docs") |
|
path = "kitchen-sink/" + path; |
|
else if (parts[0] == "ace") |
|
path = "lib/" + path; |
|
|
|
net.get(path, function(x) { |
|
initDoc(x, path, doc); |
|
callback(doc.session); |
|
}); |
|
} |
|
|
|
module.exports = { |
|
fileCache: fileCache, |
|
docs: prepareDocList(docs), |
|
ownSource: prepareDocList(ownSource), |
|
hugeDocs: prepareDocList(hugeDocs), |
|
initDoc: initDoc, |
|
loadDoc: loadDoc |
|
}; |
|
module.exports.all = { |
|
"Mode Examples": module.exports.docs, |
|
"Huge documents": module.exports.hugeDocs, |
|
"own source": module.exports.ownSource |
|
}; |
|
|
|
}); |
|
|
|
define('kitchen-sink/modelist', ['require', 'exports', 'module' ], function(require, exports, module) { |
|
var modes = []; |
|
function getModeFromPath(path) { |
|
var mode = modesByName.text; |
|
var fileName = path.split(/[\/\\]/).pop(); |
|
for (var i = 0; i < modes.length; i++) { |
|
if (modes[i].supportsFile(fileName)) { |
|
mode = modes[i]; |
|
break; |
|
} |
|
} |
|
return mode; |
|
} |
|
|
|
var Mode = function(name, desc, extensions) { |
|
this.name = name; |
|
this.desc = desc; |
|
this.mode = "ace/mode/" + name; |
|
if (/\^/.test(extensions)) { |
|
var re = extensions.replace(/\|(\^)?/g, function(a, b){ |
|
return "$|" + (b ? "^" : "^.*\\."); |
|
}) + "$"; |
|
} else { |
|
var re = "^.*\\.(" + extensions + ")$"; |
|
} |
|
|
|
this.extRe = new RegExp(re, "gi"); |
|
}; |
|
|
|
Mode.prototype.supportsFile = function(filename) { |
|
return filename.match(this.extRe); |
|
}; |
|
|
|
var modesByName = { |
|
abap: ["ABAP" , "abap"], |
|
asciidoc: ["AsciiDoc" , "asciidoc"], |
|
c9search: ["C9Search" , "c9search_results"], |
|
coffee: ["CoffeeScript" , "^Cakefile|coffee|cf|cson"], |
|
coldfusion: ["ColdFusion" , "cfm"], |
|
csharp: ["C#" , "cs"], |
|
css: ["CSS" , "css"], |
|
curly: ["Curly" , "curly"], |
|
dart: ["Dart" , "dart"], |
|
diff: ["Diff" , "diff|patch"], |
|
dot: ["Dot" , "dot"], |
|
ftl: ["FreeMarker" , "ftl"], |
|
glsl: ["Glsl" , "glsl|frag|vert"], |
|
golang: ["Go" , "go"], |
|
groovy: ["Groovy" , "groovy"], |
|
haxe: ["haXe" , "hx"], |
|
haml: ["HAML" , "haml"], |
|
html: ["HTML" , "htm|html|xhtml"], |
|
c_cpp: ["C/C++" , "c|cc|cpp|cxx|h|hh|hpp"], |
|
clojure: ["Clojure" , "clj"], |
|
jade: ["Jade" , "jade"], |
|
java: ["Java" , "java"], |
|
jsp: ["JSP" , "jsp"], |
|
javascript: ["JavaScript" , "js"], |
|
json: ["JSON" , "json"], |
|
jsx: ["JSX" , "jsx"], |
|
latex: ["LaTeX" , "latex|tex|ltx|bib"], |
|
less: ["LESS" , "less"], |
|
lisp: ["Lisp" , "lisp"], |
|
scheme: ["Scheme" , "scm|rkt"], |
|
liquid: ["Liquid" , "liquid"], |
|
livescript: ["LiveScript" , "ls"], |
|
logiql: ["LogiQL" , "logic|lql"], |
|
lua: ["Lua" , "lua"], |
|
luapage: ["LuaPage" , "lp"], // http://keplerproject.github.com/cgilua/manual.html#templates |
|
lucene: ["Lucene" , "lucene"], |
|
lsl: ["LSL" , "lsl"], |
|
makefile: ["Makefile" , "^GNUmakefile|^makefile|^Makefile|^OCamlMakefile|make"], |
|
markdown: ["Markdown" , "md|markdown"], |
|
objectivec: ["Objective-C" , "m"], |
|
ocaml: ["OCaml" , "ml|mli"], |
|
pascal: ["Pascal" , "pas|p"], |
|
perl: ["Perl" , "pl|pm"], |
|
pgsql: ["pgSQL" , "pgsql"], |
|
php: ["PHP" , "php|phtml"], |
|
powershell: ["Powershell" , "ps1"], |
|
python: ["Python" , "py"], |
|
r: ["R" , "r"], |
|
rdoc: ["RDoc" , "Rd"], |
|
rhtml: ["RHTML" , "Rhtml"], |
|
ruby: ["Ruby" , "ru|gemspec|rake|rb"], |
|
scad: ["OpenSCAD" , "scad"], |
|
scala: ["Scala" , "scala"], |
|
scss: ["SCSS" , "scss"], |
|
sass: ["SASS" , "sass"], |
|
sh: ["SH" , "sh|bash|bat"], |
|
sql: ["SQL" , "sql"], |
|
stylus: ["Stylus" , "styl|stylus"], |
|
svg: ["SVG" , "svg"], |
|
tcl: ["Tcl" , "tcl"], |
|
tex: ["Tex" , "tex"], |
|
text: ["Text" , "txt"], |
|
textile: ["Textile" , "textile"], |
|
tm_snippet: ["tmSnippet" , "tmSnippet"], |
|
toml: ["toml" , "toml"], |
|
typescript: ["Typescript" , "typescript|ts|str"], |
|
vbscript: ["VBScript" , "vbs"], |
|
xml: ["XML" , "xml|rdf|rss|wsdl|xslt|atom|mathml|mml|xul|xbl"], |
|
xquery: ["XQuery" , "xq"], |
|
yaml: ["YAML" , "yaml"] |
|
}; |
|
|
|
for (var name in modesByName) { |
|
var mode = modesByName[name]; |
|
mode = new Mode(name, mode[0], mode[1]); |
|
modesByName[name] = mode; |
|
modes.push(mode); |
|
} |
|
|
|
module.exports = { |
|
getModeFromPath: getModeFromPath, |
|
modes: modes, |
|
modesByName: modesByName |
|
}; |
|
|
|
}); |
|
|
|
|
|
define('kitchen-sink/layout', ['require', 'exports', 'module' , 'ace/lib/dom', 'ace/lib/event', 'ace/edit_session', 'ace/undomanager', 'ace/virtual_renderer', 'ace/editor', 'ace/multi_select', 'ace/theme/textmate'], function(require, exports, module) { |
|
|
|
|
|
var dom = require("ace/lib/dom"); |
|
var event = require("ace/lib/event"); |
|
|
|
var EditSession = require("ace/edit_session").EditSession; |
|
var UndoManager = require("ace/undomanager").UndoManager; |
|
var Renderer = require("ace/virtual_renderer").VirtualRenderer; |
|
var Editor = require("ace/editor").Editor; |
|
var MultiSelect = require("ace/multi_select").MultiSelect; |
|
|
|
dom.importCssString("\ |
|
splitter {\ |
|
border: 1px solid #C6C6D2;\ |
|
width: 0px;\ |
|
cursor: ew-resize;\ |
|
z-index:10}\ |
|
splitter:hover {\ |
|
margin-left: -2px;\ |
|
width:3px;\ |
|
border-color: #B5B4E0;\ |
|
}\ |
|
", "splitEditor"); |
|
|
|
exports.edit = function(el) { |
|
if (typeof(el) == "string") |
|
el = document.getElementById(el); |
|
|
|
var editor = new Editor(new Renderer(el, require("ace/theme/textmate"))); |
|
|
|
editor.resize(); |
|
event.addListener(window, "resize", function() { |
|
editor.resize(); |
|
}); |
|
return editor; |
|
}; |
|
|
|
|
|
var SplitRoot = function(el, theme, position, getSize) { |
|
el.style.position = position || "relative"; |
|
this.container = el; |
|
this.getSize = getSize || this.getSize; |
|
this.resize = this.$resize.bind(this); |
|
|
|
event.addListener(el.ownerDocument.defaultView, "resize", this.resize); |
|
this.editor = this.createEditor(); |
|
}; |
|
|
|
(function(){ |
|
this.createEditor = function() { |
|
var el = document.createElement("div"); |
|
el.className = this.$editorCSS; |
|
el.style.cssText = "position: absolute; top:0px; bottom:0px"; |
|
this.$container.appendChild(el); |
|
var session = new EditSession(""); |
|
var editor = new Editor(new Renderer(el, this.$theme)); |
|
|
|
this.$editors.push(editor); |
|
editor.setFontSize(this.$fontSize); |
|
return editor; |
|
}; |
|
this.$resize = function() { |
|
var size = this.getSize(this.container); |
|
this.rect = { |
|
x: size.left, |
|
y: size.top, |
|
w: size.width, |
|
h: size.height |
|
}; |
|
this.item.resize(this.rect); |
|
}; |
|
this.getSize = function(el) { |
|
return el.getBoundingClientRect(); |
|
}; |
|
this.destroy = function() { |
|
var win = this.container.ownerDocument.defaultView; |
|
event.removeListener(win, "resize", this.resize); |
|
}; |
|
|
|
|
|
}).call(SplitRoot.prototype); |
|
|
|
|
|
|
|
var Split = function(){ |
|
|
|
}; |
|
(function(){ |
|
this.execute = function(options) { |
|
this.$u.execute(options); |
|
}; |
|
|
|
}).call(Split.prototype); |
|
|
|
|
|
|
|
exports.singleLineEditor = function(el) { |
|
var renderer = new Renderer(el); |
|
el.style.overflow = "hidden"; |
|
renderer.scrollBar.element.style.top = "0"; |
|
renderer.scrollBar.element.style.display = "none"; |
|
renderer.scrollBar.orginalWidth = renderer.scrollBar.width; |
|
renderer.scrollBar.width = 0; |
|
renderer.content.style.height = "auto"; |
|
|
|
renderer.screenToTextCoordinates = function(x, y) { |
|
var pos = this.pixelToScreenCoordinates(x, y); |
|
return this.session.screenToDocumentPosition( |
|
Math.min(this.session.getScreenLength() - 1, Math.max(pos.row, 0)), |
|
Math.max(pos.column, 0) |
|
); |
|
}; |
|
|
|
renderer.maxLines = 4; |
|
renderer.$computeLayerConfigWithScroll = renderer.$computeLayerConfig; |
|
renderer.$computeLayerConfig = function() { |
|
var config = this.layerConfig; |
|
var height = this.session.getScreenLength() * this.lineHeight; |
|
if (config.height != height) { |
|
var vScroll = height > this.maxLines * this.lineHeight; |
|
|
|
if (vScroll != this.$vScroll) { |
|
if (vScroll) { |
|
this.scrollBar.element.style.display = ""; |
|
this.scrollBar.width = this.scrollBar.orginalWidth; |
|
this.container.style.height = config.height + "px"; |
|
height = config.height; |
|
this.scrollTop = height - this.maxLines * this.lineHeight; |
|
} else { |
|
this.scrollBar.element.style.display = "none"; |
|
this.scrollBar.width = 0; |
|
} |
|
|
|
this.onResize(); |
|
this.$vScroll = vScroll; |
|
} |
|
|
|
if (this.$vScroll) |
|
return renderer.$computeLayerConfigWithScroll(); |
|
|
|
this.container.style.height = height + "px"; |
|
this.scroller.style.height = height + "px"; |
|
this.content.style.height = height + "px"; |
|
this._emit("resize"); |
|
} |
|
|
|
var longestLine = this.$getLongestLine(); |
|
var firstRow = 0; |
|
var lastRow = this.session.getLength(); |
|
|
|
this.scrollTop = 0; |
|
config.width = longestLine; |
|
config.padding = this.$padding; |
|
config.firstRow = 0; |
|
config.firstRowScreen = 0; |
|
config.lastRow = lastRow; |
|
config.lineHeight = this.lineHeight; |
|
config.characterWidth = this.characterWidth; |
|
config.minHeight = height; |
|
config.maxHeight = height; |
|
config.offset = 0; |
|
config.height = height; |
|
|
|
this.$gutterLayer.element.style.marginTop = 0 + "px"; |
|
this.content.style.marginTop = 0 + "px"; |
|
this.content.style.width = longestLine + 2 * this.$padding + "px"; |
|
}; |
|
renderer.isScrollableBy=function(){return false}; |
|
|
|
renderer.setStyle("ace_one-line"); |
|
var editor = new Editor(renderer); |
|
new MultiSelect(editor); |
|
editor.session.setUndoManager(new UndoManager()); |
|
|
|
editor.setHighlightActiveLine(false); |
|
editor.setShowPrintMargin(false); |
|
editor.renderer.setShowGutter(false); |
|
editor.renderer.setHighlightGutterLine(false); |
|
|
|
editor.$mouseHandler.$focusWaitTimout = 0; |
|
|
|
return editor; |
|
}; |
|
|
|
|
|
|
|
}); |
|
|
|
define('kitchen-sink/token_tooltip', ['require', 'exports', 'module' , 'ace/lib/dom', 'ace/lib/event', 'ace/range'], function(require, exports, module) { |
|
|
|
|
|
var dom = require("ace/lib/dom"); |
|
var event = require("ace/lib/event"); |
|
var Range = require("ace/range").Range; |
|
|
|
var tooltipNode; |
|
|
|
var TokenTooltip = function(editor) { |
|
if (editor.tokenTooltip) |
|
return; |
|
editor.tokenTooltip = this; |
|
this.editor = editor; |
|
|
|
editor.tooltip = tooltipNode || this.$init(); |
|
|
|
this.update = this.update.bind(this); |
|
this.onMouseMove = this.onMouseMove.bind(this); |
|
this.onMouseOut = this.onMouseOut.bind(this); |
|
event.addListener(editor.renderer.scroller, "mousemove", this.onMouseMove); |
|
event.addListener(editor.renderer.content, "mouseout", this.onMouseOut); |
|
}; |
|
|
|
(function(){ |
|
this.token = {}; |
|
this.range = new Range(); |
|
|
|
this.update = function() { |
|
this.$timer = null; |
|
|
|
var r = this.editor.renderer; |
|
if (this.lastT - (r.timeStamp || 0) > 1000) { |
|
r.rect = null; |
|
r.timeStamp = this.lastT; |
|
this.maxHeight = innerHeight; |
|
this.maxWidth = innerWidth; |
|
} |
|
|
|
var canvasPos = r.rect || (r.rect = r.scroller.getBoundingClientRect()); |
|
var offset = (this.x + r.scrollLeft - canvasPos.left - r.$padding) / r.characterWidth; |
|
var row = Math.floor((this.y + r.scrollTop - canvasPos.top) / r.lineHeight); |
|
var col = Math.round(offset); |
|
|
|
var screenPos = {row: row, column: col, side: offset - col > 0 ? 1 : -1}; |
|
var session = this.editor.session; |
|
var docPos = session.screenToDocumentPosition(screenPos.row, screenPos.column); |
|
var token = session.getTokenAt(docPos.row, docPos.column); |
|
|
|
if (!token && !session.getLine(docPos.row)) { |
|
token = { |
|
type: "", |
|
value: "", |
|
state: session.bgTokenizer.getState(0) |
|
}; |
|
} |
|
if (!token) { |
|
session.removeMarker(this.marker); |
|
tooltipNode.style.display = "none"; |
|
this.isOpen = false; |
|
return; |
|
} |
|
if (!this.isOpen) { |
|
tooltipNode.style.display = ""; |
|
this.isOpen = true; |
|
} |
|
|
|
var tokenText = token.type; |
|
if (token.state) |
|
tokenText += "|" + token.state; |
|
if (token.merge) |
|
tokenText += "\n merge"; |
|
if (token.stateTransitions) |
|
tokenText += "\n " + token.stateTransitions.join("\n "); |
|
|
|
if (this.tokenText != tokenText) { |
|
tooltipNode.textContent = tokenText; |
|
this.tooltipWidth = tooltipNode.offsetWidth; |
|
this.tooltipHeight = tooltipNode.offsetHeight; |
|
this.tokenText = tokenText; |
|
} |
|
|
|
this.updateTooltipPosition(this.x, this.y); |
|
|
|
this.token = token; |
|
session.removeMarker(this.marker); |
|
this.range = new Range(docPos.row, token.start, docPos.row, token.start + token.value.length); |
|
this.marker = session.addMarker(this.range, "ace_bracket", "text"); |
|
}; |
|
|
|
this.onMouseMove = function(e) { |
|
this.x = e.clientX; |
|
this.y = e.clientY; |
|
if (this.isOpen) { |
|
this.lastT = e.timeStamp; |
|
this.updateTooltipPosition(this.x, this.y); |
|
} |
|
if (!this.$timer) |
|
this.$timer = setTimeout(this.update, 100); |
|
}; |
|
|
|
this.onMouseOut = function(e) { |
|
var t = e && e.relatedTarget; |
|
var ct = e && e.currentTarget; |
|
while(t && (t = t.parentNode)) { |
|
if (t == ct) |
|
return; |
|
} |
|
tooltipNode.style.display = "none"; |
|
this.editor.session.removeMarker(this.marker); |
|
this.$timer = clearTimeout(this.$timer); |
|
this.isOpen = false; |
|
}; |
|
|
|
this.updateTooltipPosition = function(x, y) { |
|
var st = tooltipNode.style; |
|
if (x + 10 + this.tooltipWidth > this.maxWidth) |
|
x = innerWidth - this.tooltipWidth - 10; |
|
if (y > innerHeight * 0.75 || y + 20 + this.tooltipHeight > this.maxHeight) |
|
y = y - this.tooltipHeight - 30; |
|
|
|
st.left = x + 10 + "px"; |
|
st.top = y + 20 + "px"; |
|
}; |
|
|
|
this.$init = function() { |
|
tooltipNode = document.documentElement.appendChild(dom.createElement("div")); |
|
var st = tooltipNode.style; |
|
st.position = "fixed"; |
|
st.display = "none"; |
|
st.background = "lightyellow"; |
|
st.borderRadius = ""; |
|
st.border = "1px solid gray"; |
|
st.padding = "1px"; |
|
st.zIndex = 1000; |
|
st.fontFamily = "monospace"; |
|
st.whiteSpace = "pre-line"; |
|
return tooltipNode; |
|
}; |
|
|
|
this.destroy = function() { |
|
this.onMouseOut(); |
|
event.removeListener(this.editor.renderer.scroller, "mousemove", this.onMouseMove); |
|
event.removeListener(this.editor.renderer.content, "mouseout", this.onMouseOut); |
|
delete this.editor.tokenTooltip; |
|
}; |
|
|
|
}).call(TokenTooltip.prototype); |
|
|
|
exports.TokenTooltip = TokenTooltip; |
|
|
|
}); |
|
|
|
define('kitchen-sink/util', ['require', 'exports', 'module' , 'ace/lib/dom', 'ace/lib/event', 'ace/edit_session', 'ace/undomanager', 'ace/virtual_renderer', 'ace/editor', 'ace/multi_select'], function(require, exports, module) { |
|
|
|
|
|
var dom = require("ace/lib/dom"); |
|
var event = require("ace/lib/event"); |
|
|
|
var EditSession = require("ace/edit_session").EditSession; |
|
var UndoManager = require("ace/undomanager").UndoManager; |
|
var Renderer = require("ace/virtual_renderer").VirtualRenderer; |
|
var Editor = require("ace/editor").Editor; |
|
var MultiSelect = require("ace/multi_select").MultiSelect; |
|
|
|
exports.createEditor = function(el) { |
|
return new Editor(new Renderer(el)); |
|
} |
|
|
|
exports.createSplitEditor = function(el) { |
|
if (typeof(el) == "string") |
|
el = document.getElementById(el); |
|
|
|
var e0 = document.createElement("div"); |
|
var s = document.createElement("splitter"); |
|
var e1 = document.createElement("div"); |
|
el.appendChild(e0); |
|
el.appendChild(e1); |
|
el.appendChild(s); |
|
e0.style.position = e1.style.position = s.style.position = "absolute"; |
|
el.style.position = "relative"; |
|
var split = {$container: el}; |
|
|
|
split.editor0 = split[0] = new Editor(new Renderer(e0)); |
|
split.editor1 = split[1] = new Editor(new Renderer(e1)); |
|
split.splitter = s; |
|
|
|
MultiSelect(split.editor0); |
|
MultiSelect(split.editor1); |
|
|
|
s.ratio = 0.5; |
|
|
|
split.resize = function resize(){ |
|
var height = el.parentNode.clientHeight - el.offsetTop; |
|
var total = el.clientWidth; |
|
var w1 = total * s.ratio; |
|
var w2 = total * (1- s.ratio); |
|
s.style.left = w1 - 1 + "px"; |
|
s.style.height = el.style.height = height + "px"; |
|
|
|
var st0 = split[0].container.style; |
|
var st1 = split[1].container.style; |
|
st0.width = w1 + "px"; |
|
st1.width = w2 + "px"; |
|
st0.left = 0 + "px"; |
|
st1.left = w1 + "px"; |
|
|
|
st0.top = st1.top = "0px"; |
|
st0.height = st1.height = height + "px"; |
|
|
|
split[0].resize(); |
|
split[1].resize(); |
|
}; |
|
|
|
split.onMouseDown = function(e) { |
|
var rect = el.getBoundingClientRect(); |
|
var x = e.clientX; |
|
var y = e.clientY; |
|
|
|
var button = e.button; |
|
if (button !== 0) { |
|
return; |
|
} |
|
|
|
var onMouseMove = function(e) { |
|
x = e.clientX; |
|
y = e.clientY; |
|
}; |
|
var onResizeEnd = function(e) { |
|
clearInterval(timerId); |
|
}; |
|
|
|
var onResizeInterval = function() { |
|
s.ratio = (x - rect.left) / rect.width |
|
split.resize() |
|
}; |
|
|
|
event.capture(s, onMouseMove, onResizeEnd); |
|
var timerId = setInterval(onResizeInterval, 40); |
|
|
|
return e.preventDefault(); |
|
}; |
|
|
|
|
|
|
|
event.addListener(s, "mousedown", split.onMouseDown); |
|
event.addListener(window, "resize", split.resize); |
|
split.resize(); |
|
return split; |
|
}; |
|
exports.stripLeadingComments = function(str) { |
|
if(str.slice(0,2)=='/*') { |
|
var j = str.indexOf('*/')+2; |
|
str = str.substr(j); |
|
} |
|
return str.trim() + "\n"; |
|
}; |
|
exports.saveOption = function(el, val) { |
|
if (!el.onchange && !el.onclick) |
|
return; |
|
|
|
if ("checked" in el) { |
|
if (val !== undefined) |
|
el.checked = val; |
|
|
|
localStorage && localStorage.setItem(el.id, el.checked ? 1 : 0); |
|
} |
|
else { |
|
if (val !== undefined) |
|
el.value = val; |
|
|
|
localStorage && localStorage.setItem(el.id, el.value); |
|
} |
|
}; |
|
|
|
exports.bindCheckbox = function(id, callback, noInit) { |
|
if (typeof id == "string") |
|
var el = document.getElementById(id); |
|
else { |
|
var el = id; |
|
id = el.id; |
|
} |
|
var el = document.getElementById(id); |
|
if (localStorage && localStorage.getItem(id)) |
|
el.checked = localStorage.getItem(id) == "1"; |
|
|
|
var onCheck = function() { |
|
callback(!!el.checked); |
|
exports.saveOption(el); |
|
}; |
|
el.onclick = onCheck; |
|
noInit || onCheck(); |
|
}; |
|
|
|
exports.bindDropdown = function(id, callback, noInit) { |
|
if (typeof id == "string") |
|
var el = document.getElementById(id); |
|
else { |
|
var el = id; |
|
id = el.id; |
|
} |
|
if (localStorage && localStorage.getItem(id)) |
|
el.value = localStorage.getItem(id); |
|
|
|
var onChange = function() { |
|
callback(el.value); |
|
exports.saveOption(el); |
|
}; |
|
|
|
el.onchange = onChange; |
|
noInit || onChange(); |
|
}; |
|
|
|
exports.fillDropdown = function(el, values) { |
|
if (typeof el == "string") |
|
el = document.getElementById(el); |
|
|
|
dropdown(values).forEach(function(e) { |
|
el.appendChild(e); |
|
}); |
|
}; |
|
|
|
function elt(tag, attributes, content) { |
|
var el = dom.createElement(tag); |
|
if (typeof content == "string") { |
|
el.textContent = content; |
|
} else if (content) { |
|
content.forEach(function(ch) { |
|
el.appendChild(ch); |
|
}); |
|
} |
|
|
|
for (var i in attributes) |
|
el.setAttribute(i, attributes[i]); |
|
return el; |
|
} |
|
|
|
function optgroup(values) { |
|
return values.map(function(item) { |
|
if (typeof item == "string") |
|
item = {name: item, desc: item}; |
|
return elt("option", {value: item.name}, item.desc); |
|
}); |
|
} |
|
|
|
function dropdown(values) { |
|
if (Array.isArray(values)) |
|
return optgroup(values); |
|
|
|
return Object.keys(values).map(function(i) { |
|
return elt("optgroup", {"label": i}, optgroup(values[i])); |
|
}); |
|
} |
|
|
|
|
|
}); |
|
|
|
define('ace/ext/elastic_tabstops_lite', ['require', 'exports', 'module' , 'ace/editor', 'ace/config'], function(require, exports, module) { |
|
|
|
|
|
var ElasticTabstopsLite = function(editor) { |
|
this.$editor = editor; |
|
var self = this; |
|
var changedRows = []; |
|
var recordChanges = false; |
|
this.onAfterExec = function() { |
|
recordChanges = false; |
|
self.processRows(changedRows); |
|
changedRows = []; |
|
}; |
|
this.onExec = function() { |
|
recordChanges = true; |
|
}; |
|
this.onChange = function(e) { |
|
var range = e.data.range |
|
if (recordChanges) { |
|
if (changedRows.indexOf(range.start.row) == -1) |
|
changedRows.push(range.start.row); |
|
if (range.end.row != range.start.row) |
|
changedRows.push(range.end.row); |
|
} |
|
}; |
|
}; |
|
|
|
(function() { |
|
this.processRows = function(rows) { |
|
this.$inChange = true; |
|
var checkedRows = []; |
|
|
|
for (var r = 0, rowCount = rows.length; r < rowCount; r++) { |
|
var row = rows[r]; |
|
|
|
if (checkedRows.indexOf(row) > -1) |
|
continue; |
|
|
|
var cellWidthObj = this.$findCellWidthsForBlock(row); |
|
var cellWidths = this.$setBlockCellWidthsToMax(cellWidthObj.cellWidths); |
|
var rowIndex = cellWidthObj.firstRow; |
|
|
|
for (var w = 0, l = cellWidths.length; w < l; w++) { |
|
var widths = cellWidths[w]; |
|
checkedRows.push(rowIndex); |
|
this.$adjustRow(rowIndex, widths); |
|
rowIndex++; |
|
} |
|
} |
|
this.$inChange = false; |
|
}; |
|
|
|
this.$findCellWidthsForBlock = function(row) { |
|
var cellWidths = [], widths; |
|
var rowIter = row; |
|
while (rowIter >= 0) { |
|
widths = this.$cellWidthsForRow(rowIter); |
|
if (widths.length == 0) |
|
break; |
|
|
|
cellWidths.unshift(widths); |
|
rowIter--; |
|
} |
|
var firstRow = rowIter + 1; |
|
rowIter = row; |
|
var numRows = this.$editor.session.getLength(); |
|
|
|
while (rowIter < numRows - 1) { |
|
rowIter++; |
|
|
|
widths = this.$cellWidthsForRow(rowIter); |
|
if (widths.length == 0) |
|
break; |
|
|
|
cellWidths.push(widths); |
|
} |
|
|
|
return { cellWidths: cellWidths, firstRow: firstRow }; |
|
}; |
|
|
|
this.$cellWidthsForRow = function(row) { |
|
var selectionColumns = this.$selectionColumnsForRow(row); |
|
|
|
var tabs = [-1].concat(this.$tabsForRow(row)); |
|
var widths = tabs.map(function (el) { return 0; } ).slice(1); |
|
var line = this.$editor.session.getLine(row); |
|
|
|
for (var i = 0, len = tabs.length - 1; i < len; i++) { |
|
var leftEdge = tabs[i]+1; |
|
var rightEdge = tabs[i+1]; |
|
|
|
var rightmostSelection = this.$rightmostSelectionInCell(selectionColumns, rightEdge); |
|
var cell = line.substring(leftEdge, rightEdge); |
|
widths[i] = Math.max(cell.replace(/\s+$/g,'').length, rightmostSelection - leftEdge); |
|
} |
|
|
|
return widths; |
|
}; |
|
|
|
this.$selectionColumnsForRow = function(row) { |
|
var selections = [], cursor = this.$editor.getCursorPosition(); |
|
if (this.$editor.session.getSelection().isEmpty()) { |
|
if (row == cursor.row) |
|
selections.push(cursor.column); |
|
} |
|
|
|
return selections; |
|
}; |
|
|
|
this.$setBlockCellWidthsToMax = function(cellWidths) { |
|
var startingNewBlock = true, blockStartRow, blockEndRow, maxWidth; |
|
var columnInfo = this.$izip_longest(cellWidths); |
|
|
|
for (var c = 0, l = columnInfo.length; c < l; c++) { |
|
var column = columnInfo[c]; |
|
if (!column.push) { |
|
console.error(column); |
|
continue; |
|
} |
|
column.push(NaN); |
|
|
|
for (var r = 0, s = column.length; r < s; r++) { |
|
var width = column[r]; |
|
if (startingNewBlock) { |
|
blockStartRow = r; |
|
maxWidth = 0; |
|
startingNewBlock = false; |
|
} |
|
if (isNaN(width)) { |
|
blockEndRow = r; |
|
|
|
for (var j = blockStartRow; j < blockEndRow; j++) { |
|
cellWidths[j][c] = maxWidth; |
|
} |
|
startingNewBlock = true; |
|
} |
|
|
|
maxWidth = Math.max(maxWidth, width); |
|
} |
|
} |
|
|
|
return cellWidths; |
|
}; |
|
|
|
this.$rightmostSelectionInCell = function(selectionColumns, cellRightEdge) { |
|
var rightmost = 0; |
|
|
|
if (selectionColumns.length) { |
|
var lengths = []; |
|
for (var s = 0, length = selectionColumns.length; s < length; s++) { |
|
if (selectionColumns[s] <= cellRightEdge) |
|
lengths.push(s); |
|
else |
|
lengths.push(0); |
|
} |
|
rightmost = Math.max.apply(Math, lengths); |
|
} |
|
|
|
return rightmost; |
|
}; |
|
|
|
this.$tabsForRow = function(row) { |
|
var rowTabs = [], line = this.$editor.session.getLine(row), |
|
re = /\t/g, match; |
|
|
|
while ((match = re.exec(line)) != null) { |
|
rowTabs.push(match.index); |
|
} |
|
|
|
return rowTabs; |
|
}; |
|
|
|
this.$adjustRow = function(row, widths) { |
|
var rowTabs = this.$tabsForRow(row); |
|
|
|
if (rowTabs.length == 0) |
|
return; |
|
|
|
var bias = 0, location = -1; |
|
var expandedSet = this.$izip(widths, rowTabs); |
|
|
|
for (var i = 0, l = expandedSet.length; i < l; i++) { |
|
var w = expandedSet[i][0], it = expandedSet[i][1]; |
|
location += 1 + w; |
|
it += bias; |
|
var difference = location - it; |
|
|
|
if (difference == 0) |
|
continue; |
|
|
|
var partialLine = this.$editor.session.getLine(row).substr(0, it ); |
|
var strippedPartialLine = partialLine.replace(/\s*$/g, ""); |
|
var ispaces = partialLine.length - strippedPartialLine.length; |
|
|
|
if (difference > 0) { |
|
this.$editor.session.getDocument().insertInLine({row: row, column: it + 1}, Array(difference + 1).join(" ") + "\t"); |
|
this.$editor.session.getDocument().removeInLine(row, it, it + 1); |
|
|
|
bias += difference; |
|
} |
|
|
|
if (difference < 0 && ispaces >= -difference) { |
|
this.$editor.session.getDocument().removeInLine(row, it + difference, it); |
|
bias += difference; |
|
} |
|
} |
|
}; |
|
this.$izip_longest = function(iterables) { |
|
if (!iterables[0]) |
|
return []; |
|
var longest = iterables[0].length; |
|
var iterablesLength = iterables.length; |
|
|
|
for (var i = 1; i < iterablesLength; i++) { |
|
var iLength = iterables[i].length; |
|
if (iLength > longest) |
|
longest = iLength; |
|
} |
|
|
|
var expandedSet = []; |
|
|
|
for (var l = 0; l < longest; l++) { |
|
var set = []; |
|
for (var i = 0; i < iterablesLength; i++) { |
|
if (iterables[i][l] === "") |
|
set.push(NaN); |
|
else |
|
set.push(iterables[i][l]); |
|
} |
|
|
|
expandedSet.push(set); |
|
} |
|
|
|
|
|
return expandedSet; |
|
}; |
|
this.$izip = function(widths, tabs) { |
|
var size = widths.length >= tabs.length ? tabs.length : widths.length; |
|
|
|
var expandedSet = []; |
|
for (var i = 0; i < size; i++) { |
|
var set = [ widths[i], tabs[i] ]; |
|
expandedSet.push(set); |
|
} |
|
return expandedSet; |
|
}; |
|
|
|
}).call(ElasticTabstopsLite.prototype); |
|
|
|
exports.ElasticTabstopsLite = ElasticTabstopsLite; |
|
|
|
var Editor = require("../editor").Editor; |
|
require("../config").defineOptions(Editor.prototype, "editor", { |
|
useElasticTabstops: { |
|
set: function(val) { |
|
if (val) { |
|
if (!this.elasticTabstops) |
|
this.elasticTabstops = new ElasticTabstopsLite(this); |
|
this.commands.on("afterExec", this.elasticTabstops.onAfterExec); |
|
this.commands.on("exec", this.elasticTabstops.onExec); |
|
this.on("change", this.elasticTabstops.onChange); |
|
} else if (this.elasticTabstops) { |
|
this.commands.removeListener("afterExec", this.elasticTabstops.onAfterExec); |
|
this.commands.removeListener("exec", this.elasticTabstops.onExec); |
|
this.removeListener("change", this.elasticTabstops.onChange); |
|
} |
|
} |
|
} |
|
}); |
|
|
|
}); |
|
|
|
define('ace/split', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/lib/lang', 'ace/lib/event_emitter', 'ace/editor', 'ace/virtual_renderer', 'ace/edit_session'], function(require, exports, module) { |
|
|
|
|
|
var oop = require("./lib/oop"); |
|
var lang = require("./lib/lang"); |
|
var EventEmitter = require("./lib/event_emitter").EventEmitter; |
|
|
|
var Editor = require("./editor").Editor; |
|
var Renderer = require("./virtual_renderer").VirtualRenderer; |
|
var EditSession = require("./edit_session").EditSession; |
|
|
|
|
|
var Split = function(container, theme, splits) { |
|
this.BELOW = 1; |
|
this.BESIDE = 0; |
|
|
|
this.$container = container; |
|
this.$theme = theme; |
|
this.$splits = 0; |
|
this.$editorCSS = ""; |
|
this.$editors = []; |
|
this.$orientation = this.BESIDE; |
|
|
|
this.setSplits(splits || 1); |
|
this.$cEditor = this.$editors[0]; |
|
|
|
|
|
this.on("focus", function(editor) { |
|
this.$cEditor = editor; |
|
}.bind(this)); |
|
}; |
|
|
|
(function(){ |
|
|
|
oop.implement(this, EventEmitter); |
|
|
|
this.$createEditor = function() { |
|
var el = document.createElement("div"); |
|
el.className = this.$editorCSS; |
|
el.style.cssText = "position: absolute; top:0px; bottom:0px"; |
|
this.$container.appendChild(el); |
|
var editor = new Editor(new Renderer(el, this.$theme)); |
|
|
|
editor.on("focus", function() { |
|
this._emit("focus", editor); |
|
}.bind(this)); |
|
|
|
this.$editors.push(editor); |
|
editor.setFontSize(this.$fontSize); |
|
return editor; |
|
}; |
|
|
|
this.setSplits = function(splits) { |
|
var editor; |
|
if (splits < 1) { |
|
throw "The number of splits have to be > 0!"; |
|
} |
|
|
|
if (splits == this.$splits) { |
|
return; |
|
} else if (splits > this.$splits) { |
|
while (this.$splits < this.$editors.length && this.$splits < splits) { |
|
editor = this.$editors[this.$splits]; |
|
this.$container.appendChild(editor.container); |
|
editor.setFontSize(this.$fontSize); |
|
this.$splits ++; |
|
} |
|
while (this.$splits < splits) { |
|
this.$createEditor(); |
|
this.$splits ++; |
|
} |
|
} else { |
|
while (this.$splits > splits) { |
|
editor = this.$editors[this.$splits - 1]; |
|
this.$container.removeChild(editor.container); |
|
this.$splits --; |
|
} |
|
} |
|
this.resize(); |
|
}; |
|
this.getSplits = function() { |
|
return this.$splits; |
|
}; |
|
this.getEditor = function(idx) { |
|
return this.$editors[idx]; |
|
}; |
|
this.getCurrentEditor = function() { |
|
return this.$cEditor; |
|
}; |
|
this.focus = function() { |
|
this.$cEditor.focus(); |
|
}; |
|
this.blur = function() { |
|
this.$cEditor.blur(); |
|
}; |
|
this.setTheme = function(theme) { |
|
this.$editors.forEach(function(editor) { |
|
editor.setTheme(theme); |
|
}); |
|
}; |
|
this.setKeyboardHandler = function(keybinding) { |
|
this.$editors.forEach(function(editor) { |
|
editor.setKeyboardHandler(keybinding); |
|
}); |
|
}; |
|
this.forEach = function(callback, scope) { |
|
this.$editors.forEach(callback, scope); |
|
}; |
|
|
|
|
|
this.$fontSize = ""; |
|
this.setFontSize = function(size) { |
|
this.$fontSize = size; |
|
this.forEach(function(editor) { |
|
editor.setFontSize(size); |
|
}); |
|
}; |
|
|
|
this.$cloneSession = function(session) { |
|
var s = new EditSession(session.getDocument(), session.getMode()); |
|
|
|
var undoManager = session.getUndoManager(); |
|
if (undoManager) { |
|
var undoManagerProxy = new UndoManagerProxy(undoManager, s); |
|
s.setUndoManager(undoManagerProxy); |
|
} |
|
s.$informUndoManager = lang.delayedCall(function() { s.$deltas = []; }); |
|
s.setTabSize(session.getTabSize()); |
|
s.setUseSoftTabs(session.getUseSoftTabs()); |
|
s.setOverwrite(session.getOverwrite()); |
|
s.setBreakpoints(session.getBreakpoints()); |
|
s.setUseWrapMode(session.getUseWrapMode()); |
|
s.setUseWorker(session.getUseWorker()); |
|
s.setWrapLimitRange(session.$wrapLimitRange.min, |
|
session.$wrapLimitRange.max); |
|
s.$foldData = session.$cloneFoldData(); |
|
|
|
return s; |
|
}; |
|
this.setSession = function(session, idx) { |
|
var editor; |
|
if (idx == null) { |
|
editor = this.$cEditor; |
|
} else { |
|
editor = this.$editors[idx]; |
|
} |
|
var isUsed = this.$editors.some(function(editor) { |
|
return editor.session === session; |
|
}); |
|
|
|
if (isUsed) { |
|
session = this.$cloneSession(session); |
|
} |
|
editor.setSession(session); |
|
return session; |
|
}; |
|
this.getOrientation = function() { |
|
return this.$orientation; |
|
}; |
|
this.setOrientation = function(orientation) { |
|
if (this.$orientation == orientation) { |
|
return; |
|
} |
|
this.$orientation = orientation; |
|
this.resize(); |
|
}; |
|
this.resize = function() { |
|
var width = this.$container.clientWidth; |
|
var height = this.$container.clientHeight; |
|
var editor; |
|
|
|
if (this.$orientation == this.BESIDE) { |
|
var editorWidth = width / this.$splits; |
|
for (var i = 0; i < this.$splits; i++) { |
|
editor = this.$editors[i]; |
|
editor.container.style.width = editorWidth + "px"; |
|
editor.container.style.top = "0px"; |
|
editor.container.style.left = i * editorWidth + "px"; |
|
editor.container.style.height = height + "px"; |
|
editor.resize(); |
|
} |
|
} else { |
|
var editorHeight = height / this.$splits; |
|
for (var i = 0; i < this.$splits; i++) { |
|
editor = this.$editors[i]; |
|
editor.container.style.width = width + "px"; |
|
editor.container.style.top = i * editorHeight + "px"; |
|
editor.container.style.left = "0px"; |
|
editor.container.style.height = editorHeight + "px"; |
|
editor.resize(); |
|
} |
|
} |
|
}; |
|
|
|
}).call(Split.prototype); |
|
|
|
|
|
function UndoManagerProxy(undoManager, session) { |
|
this.$u = undoManager; |
|
this.$doc = session; |
|
} |
|
|
|
(function() { |
|
this.execute = function(options) { |
|
this.$u.execute(options); |
|
}; |
|
|
|
this.undo = function() { |
|
var selectionRange = this.$u.undo(true); |
|
if (selectionRange) { |
|
this.$doc.selection.setSelectionRange(selectionRange); |
|
} |
|
}; |
|
|
|
this.redo = function() { |
|
var selectionRange = this.$u.redo(true); |
|
if (selectionRange) { |
|
this.$doc.selection.setSelectionRange(selectionRange); |
|
} |
|
}; |
|
|
|
this.reset = function() { |
|
this.$u.reset(); |
|
}; |
|
|
|
this.hasUndo = function() { |
|
return this.$u.hasUndo(); |
|
}; |
|
|
|
this.hasRedo = function() { |
|
return this.$u.hasRedo(); |
|
}; |
|
}).call(UndoManagerProxy.prototype); |
|
|
|
exports.Split = Split; |
|
}); |
|
|
|
define('ace/keyboard/vim', ['require', 'exports', 'module' , 'ace/keyboard/vim/commands', 'ace/keyboard/vim/maps/util', 'ace/lib/useragent'], function(require, exports, module) { |
|
|
|
|
|
var cmds = require("./vim/commands"); |
|
var coreCommands = cmds.coreCommands; |
|
var util = require("./vim/maps/util"); |
|
var useragent = require("../lib/useragent"); |
|
|
|
var startCommands = { |
|
"i": { |
|
command: coreCommands.start |
|
}, |
|
"I": { |
|
command: coreCommands.startBeginning |
|
}, |
|
"a": { |
|
command: coreCommands.append |
|
}, |
|
"A": { |
|
command: coreCommands.appendEnd |
|
}, |
|
"ctrl-f": { |
|
command: "gotopagedown" |
|
}, |
|
"ctrl-b": { |
|
command: "gotopageup" |
|
} |
|
}; |
|
|
|
exports.handler = { |
|
handleMacRepeat: function(data, hashId, key) { |
|
if (hashId == -1) { |
|
data.inputChar = key; |
|
data.lastEvent = "input"; |
|
} else if (data.inputChar && data.$lastHash == hashId && data.$lastKey == key) { |
|
if (data.lastEvent == "input") { |
|
data.lastEvent = "input1"; |
|
} else if (data.lastEvent == "input1") { |
|
return true; |
|
} |
|
} else { |
|
data.$lastHash = hashId; |
|
data.$lastKey = key; |
|
data.lastEvent = "keypress"; |
|
} |
|
}, |
|
|
|
handleKeyboard: function(data, hashId, key, keyCode, e) { |
|
if (hashId != 0 && (key == "" || key == "\x00")) |
|
return null; |
|
|
|
if (hashId == 1) |
|
key = "ctrl-" + key; |
|
|
|
if ((key == "esc" && hashId == 0) || key == "ctrl-[") { |
|
return {command: coreCommands.stop}; |
|
} else if (data.state == "start") { |
|
if (useragent.isMac && this.handleMacRepeat(data, hashId, key)) { |
|
hashId = -1; |
|
key = data.inputChar; |
|
} |
|
|
|
if (hashId == -1 || hashId == 1 || hashId == 0 && key.length > 1) { |
|
if (cmds.inputBuffer.idle && startCommands[key]) |
|
return startCommands[key]; |
|
return { |
|
command: { |
|
exec: function(editor) { |
|
return cmds.inputBuffer.push(editor, key); |
|
} |
|
} |
|
}; |
|
} // if no modifier || shift: wait for input. |
|
else if (key.length == 1 && (hashId == 0 || hashId == 4)) { |
|
return {command: "null", passEvent: true}; |
|
} else if (key == "esc" && hashId == 0) { |
|
return {command: coreCommands.stop}; |
|
} |
|
} else { |
|
if (key == "ctrl-w") { |
|
return {command: "removewordleft"}; |
|
} |
|
} |
|
}, |
|
|
|
attach: function(editor) { |
|
editor.on("click", exports.onCursorMove); |
|
if (util.currentMode !== "insert") |
|
cmds.coreCommands.stop.exec(editor); |
|
editor.$vimModeHandler = this; |
|
}, |
|
|
|
detach: function(editor) { |
|
editor.removeListener("click", exports.onCursorMove); |
|
util.noMode(editor); |
|
util.currentMode = "normal"; |
|
}, |
|
|
|
actions: cmds.actions, |
|
getStatusText: function() { |
|
if (util.currentMode == "insert") |
|
return "INSERT"; |
|
if (util.onVisualMode) |
|
return (util.onVisualLineMode ? "VISUAL LINE " : "VISUAL ") + cmds.inputBuffer.status; |
|
return cmds.inputBuffer.status; |
|
} |
|
}; |
|
|
|
|
|
exports.onCursorMove = function(e) { |
|
cmds.onCursorMove(e.editor, e); |
|
exports.onCursorMove.scheduled = false; |
|
}; |
|
|
|
}); |
|
|
|
define('ace/keyboard/vim/commands', ['require', 'exports', 'module' , 'ace/keyboard/vim/maps/util', 'ace/keyboard/vim/maps/motions', 'ace/keyboard/vim/maps/operators', 'ace/keyboard/vim/maps/aliases', 'ace/keyboard/vim/registers'], function(require, exports, module) { |
|
|
|
"never use strict"; |
|
|
|
var util = require("./maps/util"); |
|
var motions = require("./maps/motions"); |
|
var operators = require("./maps/operators"); |
|
var alias = require("./maps/aliases"); |
|
var registers = require("./registers"); |
|
|
|
var NUMBER = 1; |
|
var OPERATOR = 2; |
|
var MOTION = 3; |
|
var ACTION = 4; |
|
var HMARGIN = 8; // Minimum amount of line separation between margins; |
|
|
|
var repeat = function repeat(fn, count, args) { |
|
while (0 < count--) |
|
fn.apply(this, args); |
|
}; |
|
|
|
var ensureScrollMargin = function(editor) { |
|
var renderer = editor.renderer; |
|
var pos = renderer.$cursorLayer.getPixelPosition(); |
|
|
|
var top = pos.top; |
|
|
|
var margin = HMARGIN * renderer.layerConfig.lineHeight; |
|
if (2 * margin > renderer.$size.scrollerHeight) |
|
margin = renderer.$size.scrollerHeight / 2; |
|
|
|
if (renderer.scrollTop > top - margin) { |
|
renderer.session.setScrollTop(top - margin); |
|
} |
|
|
|
if (renderer.scrollTop + renderer.$size.scrollerHeight < top + margin + renderer.lineHeight) { |
|
renderer.session.setScrollTop(top + margin + renderer.lineHeight - renderer.$size.scrollerHeight); |
|
} |
|
}; |
|
|
|
var actions = exports.actions = { |
|
"z": { |
|
param: true, |
|
fn: function(editor, range, count, param) { |
|
switch (param) { |
|
case "z": |
|
editor.renderer.alignCursor(null, 0.5); |
|
break; |
|
case "t": |
|
editor.renderer.alignCursor(null, 0); |
|
break; |
|
case "b": |
|
editor.renderer.alignCursor(null, 1); |
|
break; |
|
} |
|
} |
|
}, |
|
"r": { |
|
param: true, |
|
fn: function(editor, range, count, param) { |
|
if (param && param.length) { |
|
repeat(function() { editor.insert(param); }, count || 1); |
|
editor.navigateLeft(); |
|
} |
|
} |
|
}, |
|
"R": { |
|
fn: function(editor, range, count, param) { |
|
util.insertMode(editor); |
|
editor.setOverwrite(true); |
|
} |
|
}, |
|
"~": { |
|
fn: function(editor, range, count) { |
|
repeat(function() { |
|
var range = editor.selection.getRange(); |
|
if (range.isEmpty()) |
|
range.end.column++; |
|
var text = editor.session.getTextRange(range); |
|
var toggled = text.toUpperCase(); |
|
if (toggled == text) |
|
editor.navigateRight(); |
|
else |
|
editor.session.replace(range, toggled); |
|
}, count || 1); |
|
} |
|
}, |
|
"*": { |
|
fn: function(editor, range, count, param) { |
|
editor.selection.selectWord(); |
|
editor.findNext(); |
|
ensureScrollMargin(editor); |
|
var r = editor.selection.getRange(); |
|
editor.selection.setSelectionRange(r, true); |
|
} |
|
}, |
|
"#": { |
|
fn: function(editor, range, count, param) { |
|
editor.selection.selectWord(); |
|
editor.findPrevious(); |
|
ensureScrollMargin(editor); |
|
var r = editor.selection.getRange(); |
|
editor.selection.setSelectionRange(r, true); |
|
} |
|
}, |
|
"m": { |
|
param: true, |
|
fn: function(editor, range, count, param) { |
|
var s = editor.session; |
|
var markers = s.vimMarkers || (s.vimMarkers = {}); |
|
var c = editor.getCursorPosition(); |
|
if (!markers[param]) { |
|
markers[param] = editor.session.doc.createAnchor(c); |
|
} |
|
markers[param].setPosition(c.row, c.column, true); |
|
} |
|
}, |
|
"n": { |
|
fn: function(editor, range, count, param) { |
|
var options = editor.getLastSearchOptions(); |
|
options.backwards = false; |
|
|
|
editor.selection.moveCursorRight(); |
|
editor.selection.clearSelection(); |
|
editor.findNext(options); |
|
|
|
ensureScrollMargin(editor); |
|
var r = editor.selection.getRange(); |
|
r.end.row = r.start.row; |
|
r.end.column = r.start.column; |
|
editor.selection.setSelectionRange(r, true); |
|
} |
|
}, |
|
"N": { |
|
fn: function(editor, range, count, param) { |
|
var options = editor.getLastSearchOptions(); |
|
options.backwards = true; |
|
|
|
editor.findPrevious(options); |
|
ensureScrollMargin(editor); |
|
var r = editor.selection.getRange(); |
|
r.end.row = r.start.row; |
|
r.end.column = r.start.column; |
|
editor.selection.setSelectionRange(r, true); |
|
} |
|
}, |
|
"v": { |
|
fn: function(editor, range, count, param) { |
|
editor.selection.selectRight(); |
|
util.visualMode(editor, false); |
|
}, |
|
acceptsMotion: true |
|
}, |
|
"V": { |
|
fn: function(editor, range, count, param) { |
|
var row = editor.getCursorPosition().row; |
|
editor.selection.clearSelection(); |
|
editor.selection.moveCursorTo(row, 0); |
|
editor.selection.selectLineEnd(); |
|
editor.selection.visualLineStart = row; |
|
|
|
util.visualMode(editor, true); |
|
}, |
|
acceptsMotion: true |
|
}, |
|
"Y": { |
|
fn: function(editor, range, count, param) { |
|
util.copyLine(editor); |
|
} |
|
}, |
|
"p": { |
|
fn: function(editor, range, count, param) { |
|
var defaultReg = registers._default; |
|
|
|
editor.setOverwrite(false); |
|
if (defaultReg.isLine) { |
|
var pos = editor.getCursorPosition(); |
|
var lines = defaultReg.text.split("\n"); |
|
editor.session.getDocument().insertLines(pos.row + 1, lines); |
|
editor.moveCursorTo(pos.row + 1, 0); |
|
} |
|
else { |
|
editor.navigateRight(); |
|
editor.insert(defaultReg.text); |
|
editor.navigateLeft(); |
|
} |
|
editor.setOverwrite(true); |
|
editor.selection.clearSelection(); |
|
} |
|
}, |
|
"P": { |
|
fn: function(editor, range, count, param) { |
|
var defaultReg = registers._default; |
|
editor.setOverwrite(false); |
|
|
|
if (defaultReg.isLine) { |
|
var pos = editor.getCursorPosition(); |
|
var lines = defaultReg.text.split("\n"); |
|
editor.session.getDocument().insertLines(pos.row, lines); |
|
editor.moveCursorTo(pos.row, 0); |
|
} |
|
else { |
|
editor.insert(defaultReg.text); |
|
} |
|
editor.setOverwrite(true); |
|
editor.selection.clearSelection(); |
|
} |
|
}, |
|
"J": { |
|
fn: function(editor, range, count, param) { |
|
var session = editor.session; |
|
range = editor.getSelectionRange(); |
|
var pos = {row: range.start.row, column: range.start.column}; |
|
count = count || range.end.row - range.start.row; |
|
var maxRow = Math.min(pos.row + (count || 1), session.getLength() - 1); |
|
|
|
range.start.column = session.getLine(pos.row).length; |
|
range.end.column = session.getLine(maxRow).length; |
|
range.end.row = maxRow; |
|
|
|
var text = ""; |
|
for (var i = pos.row; i < maxRow; i++) { |
|
var nextLine = session.getLine(i + 1); |
|
text += " " + /^\s*(.*)$/.exec(nextLine)[1] || ""; |
|
} |
|
|
|
session.replace(range, text); |
|
editor.moveCursorTo(pos.row, pos.column); |
|
} |
|
}, |
|
"u": { |
|
fn: function(editor, range, count, param) { |
|
count = parseInt(count || 1, 10); |
|
for (var i = 0; i < count; i++) { |
|
editor.undo(); |
|
} |
|
editor.selection.clearSelection(); |
|
} |
|
}, |
|
"ctrl-r": { |
|
fn: function(editor, range, count, param) { |
|
count = parseInt(count || 1, 10); |
|
for (var i = 0; i < count; i++) { |
|
editor.redo(); |
|
} |
|
editor.selection.clearSelection(); |
|
} |
|
}, |
|
":": { |
|
fn: function(editor, range, count, param) { |
|
} |
|
}, |
|
"/": { |
|
fn: function(editor, range, count, param) { |
|
} |
|
}, |
|
"?": { |
|
fn: function(editor, range, count, param) { |
|
} |
|
}, |
|
".": { |
|
fn: function(editor, range, count, param) { |
|
util.onInsertReplaySequence = inputBuffer.lastInsertCommands; |
|
var previous = inputBuffer.previous; |
|
if (previous) // If there is a previous action |
|
inputBuffer.exec(editor, previous.action, previous.param); |
|
} |
|
}, |
|
"ctrl-x": { |
|
fn: function(editor, range, count, param) { |
|
editor.modifyNumber(-(count || 1)); |
|
} |
|
}, |
|
"ctrl-a": { |
|
fn: function(editor, range, count, param) { |
|
editor.modifyNumber(count || 1); |
|
} |
|
} |
|
}; |
|
|
|
var inputBuffer = exports.inputBuffer = { |
|
accepting: [NUMBER, OPERATOR, MOTION, ACTION], |
|
currentCmd: null, |
|
currentCount: "", |
|
status: "", |
|
operator: null, |
|
motion: null, |
|
|
|
lastInsertCommands: [], |
|
|
|
push: function(editor, ch, keyId) { |
|
var isKeyHandled = true; |
|
this.idle = false; |
|
var wObj = this.waitingForParam; |
|
if (wObj) { |
|
this.exec(editor, wObj, ch); |
|
} |
|
else if (!(ch === "0" && !this.currentCount.length) && |
|
(ch.match(/^\d+$/) && this.isAccepting(NUMBER))) { |
|
this.currentCount += ch; |
|
this.currentCmd = NUMBER; |
|
this.accepting = [NUMBER, OPERATOR, MOTION, ACTION]; |
|
} |
|
else if (!this.operator && this.isAccepting(OPERATOR) && operators[ch]) { |
|
this.operator = { |
|
ch: ch, |
|
count: this.getCount() |
|
}; |
|
this.currentCmd = OPERATOR; |
|
this.accepting = [NUMBER, MOTION, ACTION]; |
|
this.exec(editor, { operator: this.operator }); |
|
} |
|
else if (motions[ch] && this.isAccepting(MOTION)) { |
|
this.currentCmd = MOTION; |
|
|
|
var ctx = { |
|
operator: this.operator, |
|
motion: { |
|
ch: ch, |
|
count: this.getCount() |
|
} |
|
}; |
|
|
|
if (motions[ch].param) |
|
this.waitForParam(ctx); |
|
else |
|
this.exec(editor, ctx); |
|
} |
|
else if (alias[ch] && this.isAccepting(MOTION)) { |
|
alias[ch].operator.count = this.getCount(); |
|
this.exec(editor, alias[ch]); |
|
} |
|
else if (actions[ch] && this.isAccepting(ACTION)) { |
|
var actionObj = { |
|
action: { |
|
fn: actions[ch].fn, |
|
count: this.getCount() |
|
} |
|
}; |
|
|
|
if (actions[ch].param) { |
|
this.waitForParam(actionObj); |
|
} |
|
else { |
|
this.exec(editor, actionObj); |
|
} |
|
|
|
if (actions[ch].acceptsMotion) |
|
this.idle = false; |
|
} |
|
else if (this.operator) { |
|
this.exec(editor, { operator: this.operator }, ch); |
|
} |
|
else { |
|
isKeyHandled = ch.length == 1; |
|
this.reset(); |
|
} |
|
|
|
if (this.waitingForParam || this.motion || this.operator) { |
|
this.status += ch; |
|
} else if (this.currentCount) { |
|
this.status = this.currentCount; |
|
} else if (this.status) { |
|
this.status = ""; |
|
} else { |
|
return isKeyHandled; |
|
} |
|
editor._emit("changeStatus"); |
|
return isKeyHandled; |
|
}, |
|
|
|
waitForParam: function(cmd) { |
|
this.waitingForParam = cmd; |
|
}, |
|
|
|
getCount: function() { |
|
var count = this.currentCount; |
|
this.currentCount = ""; |
|
return count && parseInt(count, 10); |
|
}, |
|
|
|
exec: function(editor, action, param) { |
|
var m = action.motion; |
|
var o = action.operator; |
|
var a = action.action; |
|
|
|
if (!param) |
|
param = action.param; |
|
|
|
if (o) { |
|
this.previous = { |
|
action: action, |
|
param: param |
|
}; |
|
} |
|
|
|
if (o && !editor.selection.isEmpty()) { |
|
if (operators[o.ch].selFn) { |
|
operators[o.ch].selFn(editor, editor.getSelectionRange(), o.count, param); |
|
this.reset(); |
|
} |
|
return; |
|
} |
|
else if (!m && !a && o && param) { |
|
operators[o.ch].fn(editor, null, o.count, param); |
|
this.reset(); |
|
} |
|
else if (m) { |
|
var run = function(fn) { |
|
if (fn && typeof fn === "function") { // There should always be a motion |
|
if (m.count && !motionObj.handlesCount) |
|
repeat(fn, m.count, [editor, null, m.count, param]); |
|
else |
|
fn(editor, null, m.count, param); |
|
} |
|
}; |
|
|
|
var motionObj = motions[m.ch]; |
|
var selectable = motionObj.sel; |
|
|
|
if (!o) { |
|
if ((util.onVisualMode || util.onVisualLineMode) && selectable) |
|
run(motionObj.sel); |
|
else |
|
run(motionObj.nav); |
|
} |
|
else if (selectable) { |
|
repeat(function() { |
|
run(motionObj.sel); |
|
operators[o.ch].fn(editor, editor.getSelectionRange(), o.count, param); |
|
}, o.count || 1); |
|
} |
|
this.reset(); |
|
} |
|
else if (a) { |
|
a.fn(editor, editor.getSelectionRange(), a.count, param); |
|
this.reset(); |
|
} |
|
handleCursorMove(editor); |
|
}, |
|
|
|
isAccepting: function(type) { |
|
return this.accepting.indexOf(type) !== -1; |
|
}, |
|
|
|
reset: function() { |
|
this.operator = null; |
|
this.motion = null; |
|
this.currentCount = ""; |
|
this.status = ""; |
|
this.accepting = [NUMBER, OPERATOR, MOTION, ACTION]; |
|
this.idle = true; |
|
this.waitingForParam = null; |
|
} |
|
}; |
|
|
|
function setPreviousCommand(fn) { |
|
inputBuffer.previous = { action: { action: { fn: fn } } }; |
|
} |
|
|
|
exports.coreCommands = { |
|
start: { |
|
exec: function start(editor) { |
|
util.insertMode(editor); |
|
setPreviousCommand(start); |
|
} |
|
}, |
|
startBeginning: { |
|
exec: function startBeginning(editor) { |
|
editor.navigateLineStart(); |
|
util.insertMode(editor); |
|
setPreviousCommand(startBeginning); |
|
} |
|
}, |
|
stop: { |
|
exec: function stop(editor) { |
|
inputBuffer.reset(); |
|
util.onVisualMode = false; |
|
util.onVisualLineMode = false; |
|
inputBuffer.lastInsertCommands = util.normalMode(editor); |
|
} |
|
}, |
|
append: { |
|
exec: function append(editor) { |
|
var pos = editor.getCursorPosition(); |
|
var lineLen = editor.session.getLine(pos.row).length; |
|
if (lineLen) |
|
editor.navigateRight(); |
|
util.insertMode(editor); |
|
setPreviousCommand(append); |
|
} |
|
}, |
|
appendEnd: { |
|
exec: function appendEnd(editor) { |
|
editor.navigateLineEnd(); |
|
util.insertMode(editor); |
|
setPreviousCommand(appendEnd); |
|
} |
|
} |
|
}; |
|
|
|
var handleCursorMove = exports.onCursorMove = function(editor, e) { |
|
if (util.currentMode === 'insert' || handleCursorMove.running) |
|
return; |
|
else if(!editor.selection.isEmpty()) { |
|
handleCursorMove.running = true; |
|
if (util.onVisualLineMode) { |
|
var originRow = editor.selection.visualLineStart; |
|
var cursorRow = editor.getCursorPosition().row; |
|
if(originRow <= cursorRow) { |
|
var endLine = editor.session.getLine(cursorRow); |
|
editor.selection.clearSelection(); |
|
editor.selection.moveCursorTo(originRow, 0); |
|
editor.selection.selectTo(cursorRow, endLine.length); |
|
} else { |
|
var endLine = editor.session.getLine(originRow); |
|
editor.selection.clearSelection(); |
|
editor.selection.moveCursorTo(originRow, endLine.length); |
|
editor.selection.selectTo(cursorRow, 0); |
|
} |
|
} |
|
handleCursorMove.running = false; |
|
return; |
|
} |
|
else { |
|
if (e && (util.onVisualLineMode || util.onVisualMode)) { |
|
editor.selection.clearSelection(); |
|
util.normalMode(editor); |
|
} |
|
|
|
handleCursorMove.running = true; |
|
var pos = editor.getCursorPosition(); |
|
var lineLen = editor.session.getLine(pos.row).length; |
|
|
|
if (lineLen && pos.column === lineLen) |
|
editor.navigateLeft(); |
|
handleCursorMove.running = false; |
|
} |
|
}; |
|
}); |
|
define('ace/keyboard/vim/maps/util', ['require', 'exports', 'module' , 'ace/keyboard/vim/registers', 'ace/lib/dom'], function(require, exports, module) { |
|
var registers = require("../registers"); |
|
|
|
var dom = require("../../../lib/dom"); |
|
dom.importCssString('.insert-mode .ace_cursor{\ |
|
border-left: 2px solid #333333;\ |
|
}\ |
|
.ace_dark.insert-mode .ace_cursor{\ |
|
border-left: 2px solid #eeeeee;\ |
|
}\ |
|
.normal-mode .ace_cursor{\ |
|
border: 0!important;\ |
|
background-color: red;\ |
|
opacity: 0.5;\ |
|
}', 'vimMode'); |
|
|
|
module.exports = { |
|
onVisualMode: false, |
|
onVisualLineMode: false, |
|
currentMode: 'normal', |
|
noMode: function(editor) { |
|
editor.unsetStyle('insert-mode'); |
|
editor.unsetStyle('normal-mode'); |
|
if (editor.commands.recording) |
|
editor.commands.toggleRecording(editor); |
|
editor.setOverwrite(false); |
|
}, |
|
insertMode: function(editor) { |
|
this.currentMode = 'insert'; |
|
editor.setStyle('insert-mode'); |
|
editor.unsetStyle('normal-mode'); |
|
|
|
editor.setOverwrite(false); |
|
editor.keyBinding.$data.buffer = ""; |
|
editor.keyBinding.$data.state = "insertMode"; |
|
this.onVisualMode = false; |
|
this.onVisualLineMode = false; |
|
if(this.onInsertReplaySequence) { |
|
editor.commands.macro = this.onInsertReplaySequence; |
|
editor.commands.replay(editor); |
|
this.onInsertReplaySequence = null; |
|
this.normalMode(editor); |
|
} else { |
|
editor._emit("changeStatus"); |
|
if(!editor.commands.recording) |
|
editor.commands.toggleRecording(editor); |
|
} |
|
}, |
|
normalMode: function(editor) { |
|
this.currentMode = 'normal'; |
|
|
|
editor.unsetStyle('insert-mode'); |
|
editor.setStyle('normal-mode'); |
|
editor.clearSelection(); |
|
|
|
var pos; |
|
if (!editor.getOverwrite()) { |
|
pos = editor.getCursorPosition(); |
|
if (pos.column > 0) |
|
editor.navigateLeft(); |
|
} |
|
|
|
editor.setOverwrite(true); |
|
editor.keyBinding.$data.buffer = ""; |
|
editor.keyBinding.$data.state = "start"; |
|
this.onVisualMode = false; |
|
this.onVisualLineMode = false; |
|
editor._emit("changeStatus"); |
|
if (editor.commands.recording) { |
|
editor.commands.toggleRecording(editor); |
|
return editor.commands.macro; |
|
} |
|
else { |
|
return []; |
|
} |
|
}, |
|
visualMode: function(editor, lineMode) { |
|
if ( |
|
(this.onVisualLineMode && lineMode) |
|
|| (this.onVisualMode && !lineMode) |
|
) { |
|
this.normalMode(editor); |
|
return; |
|
} |
|
|
|
editor.setStyle('insert-mode'); |
|
editor.unsetStyle('normal-mode'); |
|
|
|
editor._emit("changeStatus"); |
|
if (lineMode) { |
|
this.onVisualLineMode = true; |
|
} else { |
|
this.onVisualMode = true; |
|
this.onVisualLineMode = false; |
|
} |
|
}, |
|
getRightNthChar: function(editor, cursor, ch, n) { |
|
var line = editor.getSession().getLine(cursor.row); |
|
var matches = line.substr(cursor.column + 1).split(ch); |
|
|
|
return n < matches.length ? matches.slice(0, n).join(ch).length : null; |
|
}, |
|
getLeftNthChar: function(editor, cursor, ch, n) { |
|
var line = editor.getSession().getLine(cursor.row); |
|
var matches = line.substr(0, cursor.column).split(ch); |
|
|
|
return n < matches.length ? matches.slice(-1 * n).join(ch).length : null; |
|
}, |
|
toRealChar: function(ch) { |
|
if (ch.length === 1) |
|
return ch; |
|
|
|
if (/^shift-./.test(ch)) |
|
return ch[ch.length - 1].toUpperCase(); |
|
else |
|
return ""; |
|
}, |
|
copyLine: function(editor) { |
|
var pos = editor.getCursorPosition(); |
|
editor.selection.clearSelection(); |
|
editor.moveCursorTo(pos.row, pos.column); |
|
editor.selection.selectLine(); |
|
registers._default.isLine = true; |
|
registers._default.text = editor.getCopyText().replace(/\n$/, ""); |
|
editor.selection.clearSelection(); |
|
editor.moveCursorTo(pos.row, pos.column); |
|
} |
|
}; |
|
}); |
|
|
|
define('ace/keyboard/vim/registers', ['require', 'exports', 'module' ], function(require, exports, module) { |
|
|
|
"never use strict"; |
|
|
|
module.exports = { |
|
_default: { |
|
text: "", |
|
isLine: false |
|
} |
|
}; |
|
|
|
}); |
|
|
|
|
|
define('ace/keyboard/vim/maps/motions', ['require', 'exports', 'module' , 'ace/keyboard/vim/maps/util', 'ace/search', 'ace/range'], function(require, exports, module) { |
|
|
|
|
|
var util = require("./util"); |
|
|
|
var keepScrollPosition = function(editor, fn) { |
|
var scrollTopRow = editor.renderer.getScrollTopRow(); |
|
var initialRow = editor.getCursorPosition().row; |
|
var diff = initialRow - scrollTopRow; |
|
fn && fn.call(editor); |
|
editor.renderer.scrollToRow(editor.getCursorPosition().row - diff); |
|
}; |
|
|
|
function Motion(m) { |
|
if (typeof m == "function") { |
|
var getPos = m; |
|
m = this; |
|
} else { |
|
var getPos = m.getPos; |
|
} |
|
m.nav = function(editor, range, count, param) { |
|
var a = getPos(editor, range, count, param, false); |
|
if (!a) |
|
return; |
|
editor.clearSelection(); |
|
editor.moveCursorTo(a.row, a.column); |
|
}; |
|
m.sel = function(editor, range, count, param) { |
|
var a = getPos(editor, range, count, param, true); |
|
if (!a) |
|
return; |
|
editor.selection.selectTo(a.row, a.column); |
|
}; |
|
return m; |
|
} |
|
|
|
var nonWordRe = /[\s.\/\\()\"'-:,.;<>~!@#$%^&*|+=\[\]{}`~?]/; |
|
var wordSeparatorRe = /[.\/\\()\"'-:,.;<>~!@#$%^&*|+=\[\]{}`~?]/; |
|
var whiteRe = /\s/; |
|
var StringStream = function(editor, cursor) { |
|
var sel = editor.selection; |
|
this.range = sel.getRange(); |
|
cursor = cursor || sel.selectionLead; |
|
this.row = cursor.row; |
|
this.col = cursor.column; |
|
var line = editor.session.getLine(this.row); |
|
var maxRow = editor.session.getLength(); |
|
this.ch = line[this.col] || '\n'; |
|
this.skippedLines = 0; |
|
|
|
this.next = function() { |
|
this.ch = line[++this.col] || this.handleNewLine(1); |
|
return this.ch; |
|
}; |
|
this.prev = function() { |
|
this.ch = line[--this.col] || this.handleNewLine(-1); |
|
return this.ch; |
|
}; |
|
this.peek = function(dir) { |
|
var ch = line[this.col + dir]; |
|
if (ch) |
|
return ch; |
|
if (dir == -1) |
|
return '\n'; |
|
if (this.col == line.length - 1) |
|
return '\n'; |
|
return editor.session.getLine(this.row + 1)[0] || '\n'; |
|
}; |
|
|
|
this.handleNewLine = function(dir) { |
|
if (dir == 1){ |
|
if (this.col == line.length) |
|
return '\n'; |
|
if (this.row == maxRow - 1) |
|
return ''; |
|
this.col = 0; |
|
this.row ++; |
|
line = editor.session.getLine(this.row); |
|
this.skippedLines++; |
|
return line[0] || '\n'; |
|
} |
|
if (dir == -1) { |
|
if (this.row === 0) |
|
return ''; |
|
this.row --; |
|
line = editor.session.getLine(this.row); |
|
this.col = line.length; |
|
this.skippedLines--; |
|
return '\n'; |
|
} |
|
}; |
|
this.debug = function() { |
|
console.log(line.substring(0, this.col)+'|'+this.ch+'\''+this.col+'\''+line.substr(this.col+1)); |
|
}; |
|
}; |
|
|
|
var Search = require("../../../search").Search; |
|
var search = new Search(); |
|
|
|
function find(editor, needle, dir) { |
|
search.$options.needle = needle; |
|
search.$options.backwards = dir == -1; |
|
return search.find(editor.session); |
|
} |
|
|
|
var Range = require("../../../range").Range; |
|
|
|
module.exports = { |
|
"w": new Motion(function(editor) { |
|
var str = new StringStream(editor); |
|
|
|
if (str.ch && wordSeparatorRe.test(str.ch)) { |
|
while (str.ch && wordSeparatorRe.test(str.ch)) |
|
str.next(); |
|
} else { |
|
while (str.ch && !nonWordRe.test(str.ch)) |
|
str.next(); |
|
} |
|
while (str.ch && whiteRe.test(str.ch) && str.skippedLines < 2) |
|
str.next(); |
|
|
|
str.skippedLines == 2 && str.prev(); |
|
return {column: str.col, row: str.row}; |
|
}), |
|
"W": new Motion(function(editor) { |
|
var str = new StringStream(editor); |
|
while(str.ch && !(whiteRe.test(str.ch) && !whiteRe.test(str.peek(1))) && str.skippedLines < 2) |
|
str.next(); |
|
if (str.skippedLines == 2) |
|
str.prev(); |
|
else |
|
str.next(); |
|
|
|
return {column: str.col, row: str.row}; |
|
}), |
|
"b": new Motion(function(editor) { |
|
var str = new StringStream(editor); |
|
|
|
str.prev(); |
|
while (str.ch && whiteRe.test(str.ch) && str.skippedLines > -2) |
|
str.prev(); |
|
|
|
if (str.ch && wordSeparatorRe.test(str.ch)) { |
|
while (str.ch && wordSeparatorRe.test(str.ch)) |
|
str.prev(); |
|
} else { |
|
while (str.ch && !nonWordRe.test(str.ch)) |
|
str.prev(); |
|
} |
|
str.ch && str.next(); |
|
return {column: str.col, row: str.row}; |
|
}), |
|
"B": new Motion(function(editor) { |
|
var str = new StringStream(editor); |
|
str.prev(); |
|
while(str.ch && !(!whiteRe.test(str.ch) && whiteRe.test(str.peek(-1))) && str.skippedLines > -2) |
|
str.prev(); |
|
|
|
if (str.skippedLines == -2) |
|
str.next(); |
|
|
|
return {column: str.col, row: str.row}; |
|
}), |
|
"e": new Motion(function(editor) { |
|
var str = new StringStream(editor); |
|
|
|
str.next(); |
|
while (str.ch && whiteRe.test(str.ch)) |
|
str.next(); |
|
|
|
if (str.ch && wordSeparatorRe.test(str.ch)) { |
|
while (str.ch && wordSeparatorRe.test(str.ch)) |
|
str.next(); |
|
} else { |
|
while (str.ch && !nonWordRe.test(str.ch)) |
|
str.next(); |
|
} |
|
str.ch && str.prev(); |
|
return {column: str.col, row: str.row}; |
|
}), |
|
"E": new Motion(function(editor) { |
|
var str = new StringStream(editor); |
|
str.next(); |
|
while(str.ch && !(!whiteRe.test(str.ch) && whiteRe.test(str.peek(1)))) |
|
str.next(); |
|
|
|
return {column: str.col, row: str.row}; |
|
}), |
|
|
|
"l": { |
|
nav: function(editor) { |
|
var pos = editor.getCursorPosition(); |
|
var col = pos.column; |
|
var lineLen = editor.session.getLine(pos.row).length; |
|
if (lineLen && col !== lineLen) |
|
editor.navigateRight(); |
|
}, |
|
sel: function(editor) { |
|
var pos = editor.getCursorPosition(); |
|
var col = pos.column; |
|
var lineLen = editor.session.getLine(pos.row).length; |
|
if (lineLen && col !== lineLen) //In selection mode you can select the newline |
|
editor.selection.selectRight(); |
|
} |
|
}, |
|
"h": { |
|
nav: function(editor) { |
|
var pos = editor.getCursorPosition(); |
|
if (pos.column > 0) |
|
editor.navigateLeft(); |
|
}, |
|
sel: function(editor) { |
|
var pos = editor.getCursorPosition(); |
|
if (pos.column > 0) |
|
editor.selection.selectLeft(); |
|
} |
|
}, |
|
"H": { |
|
nav: function(editor) { |
|
var row = editor.renderer.getScrollTopRow(); |
|
editor.moveCursorTo(row); |
|
}, |
|
sel: function(editor) { |
|
var row = editor.renderer.getScrollTopRow(); |
|
editor.selection.selectTo(row); |
|
} |
|
}, |
|
"M": { |
|
nav: function(editor) { |
|
var topRow = editor.renderer.getScrollTopRow(); |
|
var bottomRow = editor.renderer.getScrollBottomRow(); |
|
var row = topRow + ((bottomRow - topRow) / 2); |
|
editor.moveCursorTo(row); |
|
}, |
|
sel: function(editor) { |
|
var topRow = editor.renderer.getScrollTopRow(); |
|
var bottomRow = editor.renderer.getScrollBottomRow(); |
|
var row = topRow + ((bottomRow - topRow) / 2); |
|
editor.selection.selectTo(row); |
|
} |
|
}, |
|
"L": { |
|
nav: function(editor) { |
|
var row = editor.renderer.getScrollBottomRow(); |
|
editor.moveCursorTo(row); |
|
}, |
|
sel: function(editor) { |
|
var row = editor.renderer.getScrollBottomRow(); |
|
editor.selection.selectTo(row); |
|
} |
|
}, |
|
"k": { |
|
nav: function(editor) { |
|
editor.navigateUp(); |
|
}, |
|
sel: function(editor) { |
|
editor.selection.selectUp(); |
|
} |
|
}, |
|
"j": { |
|
nav: function(editor) { |
|
editor.navigateDown(); |
|
}, |
|
sel: function(editor) { |
|
editor.selection.selectDown(); |
|
} |
|
}, |
|
|
|
"i": { |
|
param: true, |
|
sel: function(editor, range, count, param) { |
|
switch (param) { |
|
case "w": |
|
editor.selection.selectWord(); |
|
break; |
|
case "W": |
|
editor.selection.selectAWord(); |
|
break; |
|
case "(": |
|
case "{": |
|
case "[": |
|
var cursor = editor.getCursorPosition(); |
|
var end = editor.session.$findClosingBracket(param, cursor, /paren/); |
|
if (!end) |
|
return; |
|
var start = editor.session.$findOpeningBracket(editor.session.$brackets[param], cursor, /paren/); |
|
if (!start) |
|
return; |
|
start.column ++; |
|
editor.selection.setSelectionRange(Range.fromPoints(start, end)); |
|
break; |
|
case "'": |
|
case '"': |
|
case "/": |
|
var end = find(editor, param, 1); |
|
if (!end) |
|
return; |
|
var start = find(editor, param, -1); |
|
if (!start) |
|
return; |
|
editor.selection.setSelectionRange(Range.fromPoints(start.end, end.start)); |
|
break; |
|
} |
|
} |
|
}, |
|
"a": { |
|
param: true, |
|
sel: function(editor, range, count, param) { |
|
switch (param) { |
|
case "w": |
|
editor.selection.selectAWord(); |
|
break; |
|
case "W": |
|
editor.selection.selectAWord(); |
|
break; |
|
case "(": |
|
case "{": |
|
case "[": |
|
var cursor = editor.getCursorPosition(); |
|
var end = editor.session.$findClosingBracket(param, cursor, /paren/); |
|
if (!end) |
|
return; |
|
var start = editor.session.$findOpeningBracket(editor.session.$brackets[param], cursor, /paren/); |
|
if (!start) |
|
return; |
|
end.column ++; |
|
editor.selection.setSelectionRange(Range.fromPoints(start, end)); |
|
break; |
|
case "'": |
|
case "\"": |
|
case "/": |
|
var end = find(editor, param, 1); |
|
if (!end) |
|
return; |
|
var start = find(editor, param, -1); |
|
if (!start) |
|
return; |
|
end.column ++; |
|
editor.selection.setSelectionRange(Range.fromPoints(start.start, end.end)); |
|
break; |
|
} |
|
} |
|
}, |
|
|
|
"f": new Motion({ |
|
param: true, |
|
handlesCount: true, |
|
getPos: function(editor, range, count, param, isSel) { |
|
var cursor = editor.getCursorPosition(); |
|
var column = util.getRightNthChar(editor, cursor, param, count || 1); |
|
|
|
if (typeof column === "number") { |
|
cursor.column += column + (isSel ? 2 : 1); |
|
return cursor; |
|
} |
|
} |
|
}), |
|
"F": new Motion({ |
|
param: true, |
|
handlesCount: true, |
|
getPos: function(editor, range, count, param, isSel) { |
|
var cursor = editor.getCursorPosition(); |
|
var column = util.getLeftNthChar(editor, cursor, param, count || 1); |
|
|
|
if (typeof column === "number") { |
|
cursor.column -= column + 1; |
|
return cursor; |
|
} |
|
} |
|
}), |
|
"t": new Motion({ |
|
param: true, |
|
handlesCount: true, |
|
getPos: function(editor, range, count, param, isSel) { |
|
var cursor = editor.getCursorPosition(); |
|
var column = util.getRightNthChar(editor, cursor, param, count || 1); |
|
|
|
if (typeof column === "number") { |
|
cursor.column += column + (isSel ? 1 : 0); |
|
return cursor; |
|
} |
|
} |
|
}), |
|
"T": new Motion({ |
|
param: true, |
|
handlesCount: true, |
|
getPos: function(editor, range, count, param, isSel) { |
|
var cursor = editor.getCursorPosition(); |
|
var column = util.getLeftNthChar(editor, cursor, param, count || 1); |
|
|
|
if (typeof column === "number") { |
|
cursor.column -= column; |
|
return cursor; |
|
} |
|
} |
|
}), |
|
|
|
"^": { |
|
nav: function(editor) { |
|
editor.navigateLineStart(); |
|
}, |
|
sel: function(editor) { |
|
editor.selection.selectLineStart(); |
|
} |
|
}, |
|
"$": { |
|
nav: function(editor) { |
|
editor.navigateLineEnd(); |
|
}, |
|
sel: function(editor) { |
|
editor.selection.selectLineEnd(); |
|
} |
|
}, |
|
"0": new Motion(function(ed) { |
|
return {row: ed.selection.lead.row, column: 0}; |
|
}), |
|
"G": { |
|
nav: function(editor, range, count, param) { |
|
if (!count && count !== 0) { // Stupid JS |
|
count = editor.session.getLength(); |
|
} |
|
editor.gotoLine(count); |
|
}, |
|
sel: function(editor, range, count, param) { |
|
if (!count && count !== 0) { // Stupid JS |
|
count = editor.session.getLength(); |
|
} |
|
editor.selection.selectTo(count, 0); |
|
} |
|
}, |
|
"g": { |
|
param: true, |
|
nav: function(editor, range, count, param) { |
|
switch(param) { |
|
case "m": |
|
console.log("Middle line"); |
|
break; |
|
case "e": |
|
console.log("End of prev word"); |
|
break; |
|
case "g": |
|
editor.gotoLine(count || 0); |
|
case "u": |
|
editor.gotoLine(count || 0); |
|
case "U": |
|
editor.gotoLine(count || 0); |
|
} |
|
}, |
|
sel: function(editor, range, count, param) { |
|
switch(param) { |
|
case "m": |
|
console.log("Middle line"); |
|
break; |
|
case "e": |
|
console.log("End of prev word"); |
|
break; |
|
case "g": |
|
editor.selection.selectTo(count || 0, 0); |
|
} |
|
} |
|
}, |
|
"o": { |
|
nav: function(editor, range, count, param) { |
|
count = count || 1; |
|
var content = ""; |
|
while (0 < count--) |
|
content += "\n"; |
|
|
|
if (content.length) { |
|
editor.navigateLineEnd() |
|
editor.insert(content); |
|
util.insertMode(editor); |
|
} |
|
} |
|
}, |
|
"O": { |
|
nav: function(editor, range, count, param) { |
|
var row = editor.getCursorPosition().row; |
|
count = count || 1; |
|
var content = ""; |
|
while (0 < count--) |
|
content += "\n"; |
|
|
|
if (content.length) { |
|
if(row > 0) { |
|
editor.navigateUp(); |
|
editor.navigateLineEnd() |
|
editor.insert(content); |
|
} else { |
|
editor.session.insert({row: 0, column: 0}, content); |
|
editor.navigateUp(); |
|
} |
|
util.insertMode(editor); |
|
} |
|
} |
|
}, |
|
"%": new Motion(function(editor){ |
|
var brRe = /[\[\]{}()]/g; |
|
var cursor = editor.getCursorPosition(); |
|
var ch = editor.session.getLine(cursor.row)[cursor.column]; |
|
if (!brRe.test(ch)) { |
|
var range = find(editor, brRe); |
|
if (!range) |
|
return; |
|
cursor = range.start; |
|
} |
|
var match = editor.session.findMatchingBracket({ |
|
row: cursor.row, |
|
column: cursor.column + 1 |
|
}); |
|
|
|
return match; |
|
}), |
|
"{": new Motion(function(ed) { |
|
var session = ed.session; |
|
var row = session.selection.lead.row; |
|
while(row > 0 && !/\S/.test(session.getLine(row))) |
|
row--; |
|
while(/\S/.test(session.getLine(row))) |
|
row--; |
|
return {column: 0, row: row}; |
|
}), |
|
"}": new Motion(function(ed) { |
|
var session = ed.session; |
|
var l = session.getLength(); |
|
var row = session.selection.lead.row; |
|
while(row < l && !/\S/.test(session.getLine(row))) |
|
row++; |
|
while(/\S/.test(session.getLine(row))) |
|
row++; |
|
return {column: 0, row: row}; |
|
}), |
|
"ctrl-d": { |
|
nav: function(editor, range, count, param) { |
|
editor.selection.clearSelection(); |
|
keepScrollPosition(editor, editor.gotoPageDown); |
|
}, |
|
sel: function(editor, range, count, param) { |
|
keepScrollPosition(editor, editor.selectPageDown); |
|
} |
|
}, |
|
"ctrl-u": { |
|
nav: function(editor, range, count, param) { |
|
editor.selection.clearSelection(); |
|
keepScrollPosition(editor, editor.gotoPageUp); |
|
}, |
|
sel: function(editor, range, count, param) { |
|
keepScrollPosition(editor, editor.selectPageUp); |
|
} |
|
}, |
|
"`": new Motion({ |
|
param: true, |
|
handlesCount: true, |
|
getPos: function(editor, range, count, param, isSel) { |
|
var s = editor.session; |
|
var marker = s.vimMarkers && s.vimMarkers[param]; |
|
if (marker) { |
|
return marker.getPosition(); |
|
} |
|
} |
|
}), |
|
"'": new Motion({ |
|
param: true, |
|
handlesCount: true, |
|
getPos: function(editor, range, count, param, isSel) { |
|
var s = editor.session; |
|
var marker = s.vimMarkers && s.vimMarkers[param]; |
|
if (marker) { |
|
var pos = marker.getPosition(); |
|
var line = editor.session.getLine(pos.row); |
|
pos.column = line.search(/\S/); |
|
if (pos.column == -1) |
|
pos.column = line.length; |
|
return pos; |
|
} |
|
} |
|
}), |
|
}; |
|
|
|
module.exports.backspace = module.exports.left = module.exports.h; |
|
module.exports.right = module.exports.l; |
|
module.exports.up = module.exports.k; |
|
module.exports.down = module.exports.j; |
|
module.exports.pagedown = module.exports["ctrl-d"]; |
|
module.exports.pageup = module.exports["ctrl-u"]; |
|
|
|
}); |
|
|
|
define('ace/keyboard/vim/maps/operators', ['require', 'exports', 'module' , 'ace/keyboard/vim/maps/util', 'ace/keyboard/vim/registers'], function(require, exports, module) { |
|
|
|
"never use strict"; |
|
|
|
var util = require("./util"); |
|
var registers = require("../registers"); |
|
|
|
module.exports = { |
|
"d": { |
|
selFn: function(editor, range, count, param) { |
|
registers._default.text = editor.getCopyText(); |
|
registers._default.isLine = util.onVisualLineMode; |
|
if(util.onVisualLineMode) |
|
editor.removeLines(); |
|
else |
|
editor.session.remove(range); |
|
util.normalMode(editor); |
|
}, |
|
fn: function(editor, range, count, param) { |
|
count = count || 1; |
|
switch (param) { |
|
case "d": |
|
registers._default.text = ""; |
|
registers._default.isLine = true; |
|
for (var i = 0; i < count; i++) { |
|
editor.selection.selectLine(); |
|
registers._default.text += editor.getCopyText(); |
|
var selRange = editor.getSelectionRange(); |
|
if (!selRange.isMultiLine()) { |
|
lastLineReached = true |
|
var row = selRange.start.row - 1; |
|
var col = editor.session.getLine(row).length |
|
selRange.setStart(row, col); |
|
editor.session.remove(selRange); |
|
editor.selection.clearSelection(); |
|
break; |
|
} |
|
editor.session.remove(selRange); |
|
editor.selection.clearSelection(); |
|
} |
|
registers._default.text = registers._default.text.replace(/\n$/, ""); |
|
break; |
|
default: |
|
if (range) { |
|
editor.selection.setSelectionRange(range); |
|
registers._default.text = editor.getCopyText(); |
|
registers._default.isLine = false; |
|
editor.session.remove(range); |
|
editor.selection.clearSelection(); |
|
} |
|
} |
|
} |
|
}, |
|
"c": { |
|
selFn: function(editor, range, count, param) { |
|
editor.session.remove(range); |
|
util.insertMode(editor); |
|
}, |
|
fn: function(editor, range, count, param) { |
|
count = count || 1; |
|
switch (param) { |
|
case "c": |
|
for (var i = 0; i < count; i++) { |
|
editor.removeLines(); |
|
util.insertMode(editor); |
|
} |
|
|
|
break; |
|
default: |
|
if (range) { |
|
editor.session.remove(range); |
|
util.insertMode(editor); |
|
} |
|
} |
|
} |
|
}, |
|
"y": { |
|
selFn: function(editor, range, count, param) { |
|
registers._default.text = editor.getCopyText(); |
|
registers._default.isLine = util.onVisualLineMode; |
|
editor.selection.clearSelection(); |
|
util.normalMode(editor); |
|
}, |
|
fn: function(editor, range, count, param) { |
|
count = count || 1; |
|
switch (param) { |
|
case "y": |
|
var pos = editor.getCursorPosition(); |
|
editor.selection.selectLine(); |
|
for (var i = 0; i < count - 1; i++) { |
|
editor.selection.moveCursorDown(); |
|
} |
|
registers._default.text = editor.getCopyText().replace(/\n$/, ""); |
|
editor.selection.clearSelection(); |
|
registers._default.isLine = true; |
|
editor.moveCursorToPosition(pos); |
|
break; |
|
default: |
|
if (range) { |
|
var pos = editor.getCursorPosition(); |
|
editor.selection.setSelectionRange(range); |
|
registers._default.text = editor.getCopyText(); |
|
registers._default.isLine = false; |
|
editor.selection.clearSelection(); |
|
editor.moveCursorTo(pos.row, pos.column); |
|
} |
|
} |
|
} |
|
}, |
|
">": { |
|
selFn: function(editor, range, count, param) { |
|
count = count || 1; |
|
for (var i = 0; i < count; i++) { |
|
editor.indent(); |
|
} |
|
util.normalMode(editor); |
|
}, |
|
fn: function(editor, range, count, param) { |
|
count = parseInt(count || 1, 10); |
|
switch (param) { |
|
case ">": |
|
var pos = editor.getCursorPosition(); |
|
editor.selection.selectLine(); |
|
for (var i = 0; i < count - 1; i++) { |
|
editor.selection.moveCursorDown(); |
|
} |
|
editor.indent(); |
|
editor.selection.clearSelection(); |
|
editor.moveCursorToPosition(pos); |
|
editor.navigateLineEnd(); |
|
editor.navigateLineStart(); |
|
break; |
|
} |
|
} |
|
}, |
|
"<": { |
|
selFn: function(editor, range, count, param) { |
|
count = count || 1; |
|
for (var i = 0; i < count; i++) { |
|
editor.blockOutdent(); |
|
} |
|
util.normalMode(editor); |
|
}, |
|
fn: function(editor, range, count, param) { |
|
count = count || 1; |
|
switch (param) { |
|
case "<": |
|
var pos = editor.getCursorPosition(); |
|
editor.selection.selectLine(); |
|
for (var i = 0; i < count - 1; i++) { |
|
editor.selection.moveCursorDown(); |
|
} |
|
editor.blockOutdent(); |
|
editor.selection.clearSelection(); |
|
editor.moveCursorToPosition(pos); |
|
editor.navigateLineEnd(); |
|
editor.navigateLineStart(); |
|
break; |
|
} |
|
} |
|
} |
|
}; |
|
}); |
|
|
|
"use strict" |
|
|
|
define('ace/keyboard/vim/maps/aliases', ['require', 'exports', 'module' ], function(require, exports, module) { |
|
module.exports = { |
|
"x": { |
|
operator: { |
|
ch: "d", |
|
count: 1 |
|
}, |
|
motion: { |
|
ch: "l", |
|
count: 1 |
|
} |
|
}, |
|
"X": { |
|
operator: { |
|
ch: "d", |
|
count: 1 |
|
}, |
|
motion: { |
|
ch: "h", |
|
count: 1 |
|
} |
|
}, |
|
"D": { |
|
operator: { |
|
ch: "d", |
|
count: 1 |
|
}, |
|
motion: { |
|
ch: "$", |
|
count: 1 |
|
} |
|
}, |
|
"C": { |
|
operator: { |
|
ch: "c", |
|
count: 1 |
|
}, |
|
motion: { |
|
ch: "$", |
|
count: 1 |
|
} |
|
}, |
|
"s": { |
|
operator: { |
|
ch: "c", |
|
count: 1 |
|
}, |
|
motion: { |
|
ch: "l", |
|
count: 1 |
|
} |
|
}, |
|
"S": { |
|
operator: { |
|
ch: "c", |
|
count: 1 |
|
}, |
|
param: "c" |
|
} |
|
}; |
|
}); |
|
|
|
define('kitchen-sink/statusbar', ['require', 'exports', 'module' , 'ace/lib/dom', 'ace/lib/lang'], function(require, exports, module) { |
|
|
|
var dom = require("ace/lib/dom"); |
|
var lang = require("ace/lib/lang"); |
|
|
|
var StatusBar = function(editor, parentNode) { |
|
this.element = dom.createElement("div"); |
|
this.element.style.cssText = "color: gray; position:absolute; right:0; border-left:1px solid"; |
|
parentNode.appendChild(this.element); |
|
|
|
var statusUpdate = lang.delayedCall(function(){ |
|
this.updateStatus(editor) |
|
}.bind(this)); |
|
editor.on("changeStatus", function() { |
|
statusUpdate.schedule(100); |
|
}); |
|
editor.on("changeSelection", function() { |
|
statusUpdate.schedule(100); |
|
}); |
|
}; |
|
|
|
(function(){ |
|
this.updateStatus = function(editor) { |
|
var status = []; |
|
function add(str, separator) { |
|
str && status.push(str, separator || "|"); |
|
} |
|
|
|
if (editor.$vimModeHandler) |
|
add(editor.$vimModeHandler.getStatusText()); |
|
else if (editor.commands.recording) |
|
add("REC"); |
|
|
|
var c = editor.selection.lead; |
|
add(c.row + ":" + c.column, " "); |
|
if (!editor.selection.isEmpty()) { |
|
var r = editor.getSelectionRange(); |
|
add("(" + (r.end.row - r.start.row) + ":" +(r.end.column - r.start.column) + ")"); |
|
} |
|
status.pop(); |
|
this.element.textContent = status.join(""); |
|
}; |
|
}).call(StatusBar.prototype); |
|
|
|
exports.StatusBar = StatusBar; |
|
}); |