You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7185 lines
225 KiB
JavaScript
7185 lines
225 KiB
JavaScript
define("ace/ext/spellcheck",["require","exports","module","ace/lib/event","ace/editor","ace/config"], function(require, exports, module) {
|
|
"use strict";
|
|
var event = require("../lib/event");
|
|
|
|
exports.contextMenuHandler = function(e){
|
|
var host = e.target;
|
|
var text = host.textInput.getElement();
|
|
if (!host.selection.isEmpty())
|
|
return;
|
|
var c = host.getCursorPosition();
|
|
var r = host.session.getWordRange(c.row, c.column);
|
|
var w = host.session.getTextRange(r);
|
|
|
|
host.session.tokenRe.lastIndex = 0;
|
|
if (!host.session.tokenRe.test(w))
|
|
return;
|
|
var PLACEHOLDER = "\x01\x01";
|
|
var value = w + " " + PLACEHOLDER;
|
|
text.value = value;
|
|
text.setSelectionRange(w.length, w.length + 1);
|
|
text.setSelectionRange(0, 0);
|
|
text.setSelectionRange(0, w.length);
|
|
|
|
var afterKeydown = false;
|
|
event.addListener(text, "keydown", function onKeydown() {
|
|
event.removeListener(text, "keydown", onKeydown);
|
|
afterKeydown = true;
|
|
});
|
|
|
|
host.textInput.setInputHandler(function(newVal) {
|
|
console.log(newVal , value, text.selectionStart, text.selectionEnd)
|
|
if (newVal == value)
|
|
return '';
|
|
if (newVal.lastIndexOf(value, 0) === 0)
|
|
return newVal.slice(value.length);
|
|
if (newVal.substr(text.selectionEnd) == value)
|
|
return newVal.slice(0, -value.length);
|
|
if (newVal.slice(-2) == PLACEHOLDER) {
|
|
var val = newVal.slice(0, -2);
|
|
if (val.slice(-1) == " ") {
|
|
if (afterKeydown)
|
|
return val.substring(0, text.selectionEnd);
|
|
val = val.slice(0, -1);
|
|
host.session.replace(r, val);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
return newVal;
|
|
});
|
|
};
|
|
var Editor = require("../editor").Editor;
|
|
require("../config").defineOptions(Editor.prototype, "editor", {
|
|
spellcheck: {
|
|
set: function(val) {
|
|
var text = this.textInput.getElement();
|
|
text.spellcheck = !!val;
|
|
if (!val)
|
|
this.removeListener("nativecontextmenu", exports.contextMenuHandler);
|
|
else
|
|
this.on("nativecontextmenu", exports.contextMenuHandler);
|
|
},
|
|
value: true
|
|
}
|
|
});
|
|
|
|
});
|
|
|
|
define("kitchen-sink/inline_editor",["require","exports","module","ace/line_widgets","ace/editor","ace/virtual_renderer","ace/lib/dom","ace/commands/default_commands"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var LineWidgets = require("ace/line_widgets").LineWidgets;
|
|
var Editor = require("ace/editor").Editor;
|
|
var Renderer = require("ace/virtual_renderer").VirtualRenderer;
|
|
var dom = require("ace/lib/dom");
|
|
|
|
|
|
require("ace/commands/default_commands").commands.push({
|
|
name: "openInlineEditor",
|
|
bindKey: "F3",
|
|
exec: function(editor) {
|
|
var split = window.env.split;
|
|
var s = editor.session;
|
|
var inlineEditor = new Editor(new Renderer());
|
|
var splitSession = split.$cloneSession(s);
|
|
|
|
var row = editor.getCursorPosition().row;
|
|
if (editor.session.lineWidgets && editor.session.lineWidgets[row]) {
|
|
editor.session.lineWidgets[row].destroy();
|
|
return;
|
|
}
|
|
|
|
var rowCount = 10;
|
|
var w = {
|
|
row: row,
|
|
fixedWidth: true,
|
|
el: dom.createElement("div"),
|
|
editor: editor
|
|
};
|
|
var el = w.el;
|
|
el.appendChild(inlineEditor.container);
|
|
|
|
if (!editor.session.widgetManager) {
|
|
editor.session.widgetManager = new LineWidgets(editor.session);
|
|
editor.session.widgetManager.attach(editor);
|
|
}
|
|
|
|
var h = rowCount*editor.renderer.layerConfig.lineHeight;
|
|
inlineEditor.container.style.height = h + "px";
|
|
|
|
el.style.position = "absolute";
|
|
el.style.zIndex = "4";
|
|
el.style.borderTop = "solid blue 2px";
|
|
el.style.borderBottom = "solid blue 2px";
|
|
|
|
inlineEditor.setSession(splitSession);
|
|
editor.session.widgetManager.addLineWidget(w);
|
|
|
|
var kb = {
|
|
handleKeyboard:function(_,hashId, keyString) {
|
|
if (hashId === 0 && keyString === "esc") {
|
|
w.destroy();
|
|
return true;
|
|
}
|
|
}
|
|
};
|
|
|
|
w.destroy = function() {
|
|
editor.keyBinding.removeKeyboardHandler(kb);
|
|
s.widgetManager.removeLineWidget(w);
|
|
};
|
|
|
|
editor.keyBinding.addKeyboardHandler(kb);
|
|
inlineEditor.keyBinding.addKeyboardHandler(kb);
|
|
editor.on("changeSession", function(e) {
|
|
w.el.parentNode && w.el.parentNode.removeChild(w.el);
|
|
});
|
|
inlineEditor.setTheme("ace/theme/solarized_light");
|
|
}
|
|
});
|
|
});
|
|
|
|
define("kitchen-sink/dev_util",["require","exports","module"], function(require, exports, module) {
|
|
function isStrict() {
|
|
try { return !arguments.callee.caller.caller.caller}
|
|
catch(e){ return true }
|
|
}
|
|
function warn() {
|
|
if (isStrict()) {
|
|
console.error("trying to access to global variable");
|
|
}
|
|
}
|
|
function def(o, key, get) {
|
|
try {
|
|
Object.defineProperty(o, key, {
|
|
configurable: true,
|
|
get: get,
|
|
set: function(val) {
|
|
delete o[key];
|
|
o[key] = val;
|
|
}
|
|
});
|
|
} catch(e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
def(window, "ace", function(){ warn(); return window.env.editor });
|
|
def(window, "editor", function(){ warn(); return window.env.editor });
|
|
def(window, "session", function(){ warn(); return window.env.editor.session });
|
|
def(window, "split", function(){ warn(); return window.env.split });
|
|
|
|
});
|
|
|
|
define("ace/ext/modelist",["require","exports","module"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var modes = [];
|
|
function getModeForPath(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, caption, extensions) {
|
|
this.name = name;
|
|
this.caption = caption;
|
|
this.mode = "ace/mode/" + name;
|
|
this.extensions = extensions;
|
|
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 supportedModes = {
|
|
ABAP: ["abap"],
|
|
ActionScript:["as"],
|
|
ADA: ["ada|adb"],
|
|
Apache_Conf: ["^htaccess|^htgroups|^htpasswd|^conf|htaccess|htgroups|htpasswd"],
|
|
AsciiDoc: ["asciidoc"],
|
|
Assembly_x86:["asm"],
|
|
AutoHotKey: ["ahk"],
|
|
BatchFile: ["bat|cmd"],
|
|
C9Search: ["c9search_results"],
|
|
C_Cpp: ["cpp|c|cc|cxx|h|hh|hpp"],
|
|
Cirru: ["cirru|cr"],
|
|
Clojure: ["clj|cljs"],
|
|
Cobol: ["CBL|COB"],
|
|
coffee: ["coffee|cf|cson|^Cakefile"],
|
|
ColdFusion: ["cfm"],
|
|
CSharp: ["cs"],
|
|
CSS: ["css"],
|
|
Curly: ["curly"],
|
|
D: ["d|di"],
|
|
Dart: ["dart"],
|
|
Diff: ["diff|patch"],
|
|
Dockerfile: ["^Dockerfile"],
|
|
Dot: ["dot"],
|
|
Eiffel: ["e"],
|
|
Erlang: ["erl|hrl"],
|
|
EJS: ["ejs"],
|
|
Forth: ["frt|fs|ldr"],
|
|
FTL: ["ftl"],
|
|
Gcode: ["gcode"],
|
|
Gherkin: ["feature"],
|
|
Gitignore: ["^.gitignore"],
|
|
Glsl: ["glsl|frag|vert"],
|
|
golang: ["go"],
|
|
Groovy: ["groovy"],
|
|
HAML: ["haml"],
|
|
Handlebars: ["hbs|handlebars|tpl|mustache"],
|
|
Haskell: ["hs"],
|
|
haXe: ["hx"],
|
|
HTML: ["html|htm|xhtml"],
|
|
HTML_Ruby: ["erb|rhtml|html.erb"],
|
|
INI: ["ini|conf|cfg|prefs"],
|
|
Jack: ["jack"],
|
|
Jade: ["jade"],
|
|
Java: ["java"],
|
|
JavaScript: ["js|jsm"],
|
|
JSON: ["json"],
|
|
JSONiq: ["jq"],
|
|
JSP: ["jsp"],
|
|
JSX: ["jsx"],
|
|
Julia: ["jl"],
|
|
LaTeX: ["tex|latex|ltx|bib"],
|
|
LESS: ["less"],
|
|
Liquid: ["liquid"],
|
|
Lisp: ["lisp"],
|
|
LiveScript: ["ls"],
|
|
LogiQL: ["logic|lql"],
|
|
LSL: ["lsl"],
|
|
Lua: ["lua"],
|
|
LuaPage: ["lp"],
|
|
Lucene: ["lucene"],
|
|
Makefile: ["^Makefile|^GNUmakefile|^makefile|^OCamlMakefile|make"],
|
|
MATLAB: ["matlab"],
|
|
Markdown: ["md|markdown"],
|
|
MEL: ["mel"],
|
|
MySQL: ["mysql"],
|
|
MUSHCode: ["mc|mush"],
|
|
Nix: ["nix"],
|
|
ObjectiveC: ["m|mm"],
|
|
OCaml: ["ml|mli"],
|
|
Pascal: ["pas|p"],
|
|
Perl: ["pl|pm"],
|
|
pgSQL: ["pgsql"],
|
|
PHP: ["php|phtml"],
|
|
Powershell: ["ps1"],
|
|
Praat: ["praat|praatscript|psc|proc"],
|
|
Prolog: ["plg|prolog"],
|
|
Properties: ["properties"],
|
|
Protobuf: ["proto"],
|
|
Python: ["py"],
|
|
R: ["r"],
|
|
RDoc: ["Rd"],
|
|
RHTML: ["Rhtml"],
|
|
Ruby: ["rb|ru|gemspec|rake|^Guardfile|^Rakefile|^Gemfile"],
|
|
Rust: ["rs"],
|
|
SASS: ["sass"],
|
|
SCAD: ["scad"],
|
|
Scala: ["scala"],
|
|
Smarty: ["smarty|tpl"],
|
|
Scheme: ["scm|rkt"],
|
|
SCSS: ["scss"],
|
|
SH: ["sh|bash|^.bashrc"],
|
|
SJS: ["sjs"],
|
|
Space: ["space"],
|
|
snippets: ["snippets"],
|
|
Soy_Template:["soy"],
|
|
SQL: ["sql"],
|
|
Stylus: ["styl|stylus"],
|
|
SVG: ["svg"],
|
|
Tcl: ["tcl"],
|
|
Tex: ["tex"],
|
|
Text: ["txt"],
|
|
Textile: ["textile"],
|
|
Toml: ["toml"],
|
|
Twig: ["twig"],
|
|
Typescript: ["ts|typescript|str"],
|
|
Vala: ["vala"],
|
|
VBScript: ["vbs|vb"],
|
|
Velocity: ["vm"],
|
|
Verilog: ["v|vh|sv|svh"],
|
|
XML: ["xml|rdf|rss|wsdl|xslt|atom|mathml|mml|xul|xbl"],
|
|
XQuery: ["xq"],
|
|
YAML: ["yaml|yml"]
|
|
};
|
|
|
|
var nameOverrides = {
|
|
ObjectiveC: "Objective-C",
|
|
CSharp: "C#",
|
|
golang: "Go",
|
|
C_Cpp: "C and C++",
|
|
coffee: "CoffeeScript",
|
|
HTML_Ruby: "HTML (Ruby)",
|
|
FTL: "FreeMarker"
|
|
};
|
|
var modesByName = {};
|
|
for (var name in supportedModes) {
|
|
var data = supportedModes[name];
|
|
var displayName = (nameOverrides[name] || name).replace(/_/g, " ");
|
|
var filename = name.toLowerCase();
|
|
var mode = new Mode(filename, displayName, data[0]);
|
|
modesByName[filename] = mode;
|
|
modes.push(mode);
|
|
}
|
|
|
|
module.exports = {
|
|
getModeForPath: getModeForPath,
|
|
modes: modes,
|
|
modesByName: modesByName
|
|
};
|
|
|
|
});
|
|
|
|
define("kitchen-sink/file_drop",["require","exports","module","ace/config","ace/lib/event","ace/ext/modelist","ace/editor"], function(require, exports, module) {
|
|
|
|
var config = require("ace/config");
|
|
var event = require("ace/lib/event");
|
|
var modelist = require("ace/ext/modelist");
|
|
|
|
module.exports = function(editor) {
|
|
event.addListener(editor.container, "dragover", function(e) {
|
|
var types = e.dataTransfer.types;
|
|
if (types && Array.prototype.indexOf.call(types, 'Files') !== -1)
|
|
return event.preventDefault(e);
|
|
});
|
|
|
|
event.addListener(editor.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.getModeForPath(file.name);
|
|
editor.session.doc.setValue(reader.result);
|
|
editor.session.setMode(mode.mode);
|
|
editor.session.modeName = mode.name;
|
|
};
|
|
reader.readAsText(file);
|
|
}
|
|
return event.preventDefault(e);
|
|
} catch(err) {
|
|
return event.stopEvent(e);
|
|
}
|
|
});
|
|
};
|
|
|
|
var Editor = require("ace/editor").Editor;
|
|
config.defineOptions(Editor.prototype, "editor", {
|
|
loadDroppedFile: {
|
|
set: function() { module.exports(this); },
|
|
value: true
|
|
}
|
|
});
|
|
|
|
});
|
|
|
|
define("ace/theme/textmate",["require","exports","module","ace/lib/dom"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
exports.isDark = false;
|
|
exports.cssClass = "ace-tm";
|
|
exports.cssText = ".ace-tm .ace_gutter {\
|
|
background: #f0f0f0;\
|
|
color: #333;\
|
|
}\
|
|
.ace-tm .ace_print-margin {\
|
|
width: 1px;\
|
|
background: #e8e8e8;\
|
|
}\
|
|
.ace-tm .ace_fold {\
|
|
background-color: #6B72E6;\
|
|
}\
|
|
.ace-tm {\
|
|
background-color: #FFFFFF;\
|
|
color: black;\
|
|
}\
|
|
.ace-tm .ace_cursor {\
|
|
color: black;\
|
|
}\
|
|
.ace-tm .ace_invisible {\
|
|
color: rgb(191, 191, 191);\
|
|
}\
|
|
.ace-tm .ace_storage,\
|
|
.ace-tm .ace_keyword {\
|
|
color: blue;\
|
|
}\
|
|
.ace-tm .ace_constant {\
|
|
color: rgb(197, 6, 11);\
|
|
}\
|
|
.ace-tm .ace_constant.ace_buildin {\
|
|
color: rgb(88, 72, 246);\
|
|
}\
|
|
.ace-tm .ace_constant.ace_language {\
|
|
color: rgb(88, 92, 246);\
|
|
}\
|
|
.ace-tm .ace_constant.ace_library {\
|
|
color: rgb(6, 150, 14);\
|
|
}\
|
|
.ace-tm .ace_invalid {\
|
|
background-color: rgba(255, 0, 0, 0.1);\
|
|
color: red;\
|
|
}\
|
|
.ace-tm .ace_support.ace_function {\
|
|
color: rgb(60, 76, 114);\
|
|
}\
|
|
.ace-tm .ace_support.ace_constant {\
|
|
color: rgb(6, 150, 14);\
|
|
}\
|
|
.ace-tm .ace_support.ace_type,\
|
|
.ace-tm .ace_support.ace_class {\
|
|
color: rgb(109, 121, 222);\
|
|
}\
|
|
.ace-tm .ace_keyword.ace_operator {\
|
|
color: rgb(104, 118, 135);\
|
|
}\
|
|
.ace-tm .ace_string {\
|
|
color: rgb(3, 106, 7);\
|
|
}\
|
|
.ace-tm .ace_comment {\
|
|
color: rgb(76, 136, 107);\
|
|
}\
|
|
.ace-tm .ace_comment.ace_doc {\
|
|
color: rgb(0, 102, 255);\
|
|
}\
|
|
.ace-tm .ace_comment.ace_doc.ace_tag {\
|
|
color: rgb(128, 159, 191);\
|
|
}\
|
|
.ace-tm .ace_constant.ace_numeric {\
|
|
color: rgb(0, 0, 205);\
|
|
}\
|
|
.ace-tm .ace_variable {\
|
|
color: rgb(49, 132, 149);\
|
|
}\
|
|
.ace-tm .ace_xml-pe {\
|
|
color: rgb(104, 104, 91);\
|
|
}\
|
|
.ace-tm .ace_entity.ace_name.ace_function {\
|
|
color: #0000A2;\
|
|
}\
|
|
.ace-tm .ace_heading {\
|
|
color: rgb(12, 7, 255);\
|
|
}\
|
|
.ace-tm .ace_list {\
|
|
color:rgb(185, 6, 144);\
|
|
}\
|
|
.ace-tm .ace_meta.ace_tag {\
|
|
color:rgb(0, 22, 142);\
|
|
}\
|
|
.ace-tm .ace_string.ace_regex {\
|
|
color: rgb(255, 0, 0)\
|
|
}\
|
|
.ace-tm .ace_marker-layer .ace_selection {\
|
|
background: rgb(181, 213, 255);\
|
|
}\
|
|
.ace-tm.ace_multiselect .ace_selection.ace_start {\
|
|
box-shadow: 0 0 3px 0px white;\
|
|
border-radius: 2px;\
|
|
}\
|
|
.ace-tm .ace_marker-layer .ace_step {\
|
|
background: rgb(252, 255, 0);\
|
|
}\
|
|
.ace-tm .ace_marker-layer .ace_stack {\
|
|
background: rgb(164, 229, 101);\
|
|
}\
|
|
.ace-tm .ace_marker-layer .ace_bracket {\
|
|
margin: -1px 0 0 -1px;\
|
|
border: 1px solid rgb(192, 192, 192);\
|
|
}\
|
|
.ace-tm .ace_marker-layer .ace_active-line {\
|
|
background: rgba(0, 0, 0, 0.07);\
|
|
}\
|
|
.ace-tm .ace_gutter-active-line {\
|
|
background-color : #dcdcdc;\
|
|
}\
|
|
.ace-tm .ace_marker-layer .ace_selected-word {\
|
|
background: rgb(250, 250, 255);\
|
|
border: 1px solid rgb(200, 200, 250);\
|
|
}\
|
|
.ace-tm .ace_indent-guide {\
|
|
background: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==\") right repeat-y;\
|
|
}\
|
|
";
|
|
|
|
var dom = require("../lib/dom");
|
|
dom.importCssString(exports.cssText, exports.cssClass);
|
|
});
|
|
|
|
define("ace/ext/whitespace",["require","exports","module","ace/lib/lang"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var lang = require("../lib/lang");
|
|
exports.$detectIndentation = function(lines, fallback) {
|
|
var stats = [];
|
|
var changes = [];
|
|
var tabIndents = 0;
|
|
var prevSpaces = 0;
|
|
var max = Math.min(lines.length, 1000);
|
|
for (var i = 0; i < max; i++) {
|
|
var line = lines[i];
|
|
if (!/^\s*[^*+\-\s]/.test(line))
|
|
continue;
|
|
|
|
if (line[0] == "\t")
|
|
tabIndents++;
|
|
|
|
var spaces = line.match(/^ */)[0].length;
|
|
if (spaces && line[spaces] != "\t") {
|
|
var diff = spaces - prevSpaces;
|
|
if (diff > 0 && !(prevSpaces%diff) && !(spaces%diff))
|
|
changes[diff] = (changes[diff] || 0) + 1;
|
|
|
|
stats[spaces] = (stats[spaces] || 0) + 1;
|
|
}
|
|
prevSpaces = spaces;
|
|
while (i < max && line[line.length - 1] == "\\")
|
|
line = lines[i++];
|
|
}
|
|
|
|
function getScore(indent) {
|
|
var score = 0;
|
|
for (var i = indent; i < stats.length; i += indent)
|
|
score += stats[i] || 0;
|
|
return score;
|
|
}
|
|
|
|
var changesTotal = changes.reduce(function(a,b){return a+b}, 0);
|
|
|
|
var first = {score: 0, length: 0};
|
|
var spaceIndents = 0;
|
|
for (var i = 1; i < 12; i++) {
|
|
var score = getScore(i);
|
|
if (i == 1) {
|
|
spaceIndents = score;
|
|
score = stats[1] ? 0.9 : 0.8;
|
|
if (!stats.length)
|
|
score = 0
|
|
} else
|
|
score /= spaceIndents;
|
|
|
|
if (changes[i])
|
|
score += changes[i] / changesTotal;
|
|
|
|
if (score > first.score)
|
|
first = {score: score, length: i};
|
|
}
|
|
|
|
if (first.score && first.score > 1.4)
|
|
var tabLength = first.length;
|
|
|
|
if (tabIndents > spaceIndents + 1)
|
|
return {ch: "\t", length: tabLength};
|
|
|
|
if (spaceIndents > tabIndents + 1)
|
|
return {ch: " ", length: tabLength};
|
|
};
|
|
|
|
exports.detectIndentation = function(session) {
|
|
var lines = session.getLines(0, 1000);
|
|
var indent = exports.$detectIndentation(lines) || {};
|
|
|
|
if (indent.ch)
|
|
session.setUseSoftTabs(indent.ch == " ");
|
|
|
|
if (indent.length)
|
|
session.setTabSize(indent.length);
|
|
return indent;
|
|
};
|
|
|
|
exports.trimTrailingSpace = function(session, trimEmpty) {
|
|
var doc = session.getDocument();
|
|
var lines = doc.getAllLines();
|
|
|
|
var min = trimEmpty ? -1 : 0;
|
|
|
|
for (var i = 0, l=lines.length; i < l; i++) {
|
|
var line = lines[i];
|
|
var index = line.search(/\s+$/);
|
|
|
|
if (index > min)
|
|
doc.removeInLine(i, index, line.length);
|
|
}
|
|
};
|
|
|
|
exports.convertIndentation = function(session, ch, len) {
|
|
var oldCh = session.getTabString()[0];
|
|
var oldLen = session.getTabSize();
|
|
if (!len) len = oldLen;
|
|
if (!ch) ch = oldCh;
|
|
|
|
var tab = ch == "\t" ? ch: lang.stringRepeat(ch, len);
|
|
|
|
var doc = session.doc;
|
|
var lines = doc.getAllLines();
|
|
|
|
var cache = {};
|
|
var spaceCache = {};
|
|
for (var i = 0, l=lines.length; i < l; i++) {
|
|
var line = lines[i];
|
|
var match = line.match(/^\s*/)[0];
|
|
if (match) {
|
|
var w = session.$getStringScreenWidth(match)[0];
|
|
var tabCount = Math.floor(w/oldLen);
|
|
var reminder = w%oldLen;
|
|
var toInsert = cache[tabCount] || (cache[tabCount] = lang.stringRepeat(tab, tabCount));
|
|
toInsert += spaceCache[reminder] || (spaceCache[reminder] = lang.stringRepeat(" ", reminder));
|
|
|
|
if (toInsert != match) {
|
|
doc.removeInLine(i, 0, match.length);
|
|
doc.insertInLine({row: i, column: 0}, toInsert);
|
|
}
|
|
}
|
|
}
|
|
session.setTabSize(len);
|
|
session.setUseSoftTabs(ch == " ");
|
|
};
|
|
|
|
exports.$parseStringArg = function(text) {
|
|
var indent = {};
|
|
if (/t/.test(text))
|
|
indent.ch = "\t";
|
|
else if (/s/.test(text))
|
|
indent.ch = " ";
|
|
var m = text.match(/\d+/);
|
|
if (m)
|
|
indent.length = parseInt(m[0], 10);
|
|
return indent;
|
|
};
|
|
|
|
exports.$parseArg = function(arg) {
|
|
if (!arg)
|
|
return {};
|
|
if (typeof arg == "string")
|
|
return exports.$parseStringArg(arg);
|
|
if (typeof arg.text == "string")
|
|
return exports.$parseStringArg(arg.text);
|
|
return arg;
|
|
};
|
|
|
|
exports.commands = [{
|
|
name: "detectIndentation",
|
|
exec: function(editor) {
|
|
exports.detectIndentation(editor.session);
|
|
}
|
|
}, {
|
|
name: "trimTrailingSpace",
|
|
exec: function(editor) {
|
|
exports.trimTrailingSpace(editor.session);
|
|
}
|
|
}, {
|
|
name: "convertIndentation",
|
|
exec: function(editor, arg) {
|
|
var indent = exports.$parseArg(arg);
|
|
exports.convertIndentation(editor.session, indent.ch, indent.length);
|
|
}
|
|
}, {
|
|
name: "setIndentation",
|
|
exec: function(editor, arg) {
|
|
var indent = exports.$parseArg(arg);
|
|
indent.length && editor.session.setTabSize(indent.length);
|
|
indent.ch && editor.session.setUseSoftTabs(indent.ch == " ");
|
|
}
|
|
}];
|
|
|
|
});
|
|
|
|
define("kitchen-sink/doclist",["require","exports","module","ace/edit_session","ace/undomanager","ace/lib/net","ace/ext/modelist"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var EditSession = require("ace/edit_session").EditSession;
|
|
var UndoManager = require("ace/undomanager").UndoManager;
|
|
var net = require("ace/lib/net");
|
|
|
|
var modelist = require("ace/ext/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;
|
|
session.name = doc.name;
|
|
if (doc.wrapped) {
|
|
session.setUseWrapMode(true);
|
|
session.setWrapLimitRange(80, 80);
|
|
}
|
|
var mode = modelist.getModeForPath(path);
|
|
session.modeName = mode.name;
|
|
session.setMode(mode.mode);
|
|
return session;
|
|
}
|
|
|
|
|
|
function makeHuge(txt) {
|
|
for (var i = 0; i < 5; i++)
|
|
txt += txt;
|
|
return txt;
|
|
}
|
|
|
|
var docs = {
|
|
"docs/javascript.js": {order: 1, name: "JavaScript"},
|
|
|
|
"docs/latex.tex": {name: "LaTeX", wrapped: true},
|
|
"docs/markdown.md": {name: "Markdown", wrapped: true},
|
|
"docs/mushcode.mc": {name: "MUSHCode", wrapped: true},
|
|
"docs/pgsql.pgsql": {name: "pgSQL", wrapped: true},
|
|
"docs/plaintext.txt": {name: "Plain Text", prepare: makeHuge, wrapped: true},
|
|
"docs/sql.sql": {name: "SQL", wrapped: true},
|
|
|
|
"docs/textile.textile": {name: "Textile", wrapped: true},
|
|
|
|
"docs/c9search.c9search_results": "C9 Search Results",
|
|
"docs/mel.mel": "MEL",
|
|
"docs/Nix.nix": "Nix"
|
|
};
|
|
|
|
var ownSource = {
|
|
};
|
|
|
|
var hugeDocs = {
|
|
"build/src/ace.js": "",
|
|
"build/src-min/ace.js": ""
|
|
};
|
|
|
|
modelist.modes.forEach(function(m) {
|
|
var ext = m.extensions.split("|")[0];
|
|
if (ext[0] === "^") {
|
|
path = ext.substr(1);
|
|
} else {
|
|
var path = m.name + "." + ext;
|
|
}
|
|
path = "docs/" + path;
|
|
if (!docs[path]) {
|
|
docs[path] = {name: m.caption};
|
|
} else if (typeof docs[path] == "object" && !docs[path].name) {
|
|
docs[path].name = m.caption;
|
|
}
|
|
});
|
|
|
|
|
|
|
|
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 sort(list) {
|
|
return list.sort(function(a, b) {
|
|
var cmp = (b.order || 0) - (a.order || 0);
|
|
return cmp || a.name && a.name.localeCompare(b.name);
|
|
});
|
|
}
|
|
|
|
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 = "demo/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: sort(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("ace/ext/themelist",["require","exports","module","ace/lib/fixoldbrowsers"], function(require, exports, module) {
|
|
"use strict";
|
|
require("ace/lib/fixoldbrowsers");
|
|
|
|
var themeData = [
|
|
["Chrome" ],
|
|
["Clouds" ],
|
|
["Crimson Editor" ],
|
|
["Dawn" ],
|
|
["Dreamweaver" ],
|
|
["Eclipse" ],
|
|
["GitHub" ],
|
|
["Solarized Light"],
|
|
["TextMate" ],
|
|
["Tomorrow" ],
|
|
["XCode" ],
|
|
["Kuroir"],
|
|
["KatzenMilch"],
|
|
["Ambiance" ,"ambiance" , "dark"],
|
|
["Chaos" ,"chaos" , "dark"],
|
|
["Clouds Midnight" ,"clouds_midnight" , "dark"],
|
|
["Cobalt" ,"cobalt" , "dark"],
|
|
["idle Fingers" ,"idle_fingers" , "dark"],
|
|
["krTheme" ,"kr_theme" , "dark"],
|
|
["Merbivore" ,"merbivore" , "dark"],
|
|
["Merbivore Soft" ,"merbivore_soft" , "dark"],
|
|
["Mono Industrial" ,"mono_industrial" , "dark"],
|
|
["Monokai" ,"monokai" , "dark"],
|
|
["Pastel on dark" ,"pastel_on_dark" , "dark"],
|
|
["Solarized Dark" ,"solarized_dark" , "dark"],
|
|
["Terminal" ,"terminal" , "dark"],
|
|
["Tomorrow Night" ,"tomorrow_night" , "dark"],
|
|
["Tomorrow Night Blue" ,"tomorrow_night_blue" , "dark"],
|
|
["Tomorrow Night Bright","tomorrow_night_bright" , "dark"],
|
|
["Tomorrow Night 80s" ,"tomorrow_night_eighties" , "dark"],
|
|
["Twilight" ,"twilight" , "dark"],
|
|
["Vibrant Ink" ,"vibrant_ink" , "dark"]
|
|
];
|
|
|
|
|
|
exports.themesByName = {};
|
|
exports.themes = themeData.map(function(data) {
|
|
var name = data[1] || data[0].replace(/ /g, "_").toLowerCase();
|
|
var theme = {
|
|
caption: data[0],
|
|
theme: "ace/theme/" + name,
|
|
isDark: data[2] == "dark",
|
|
name: name
|
|
};
|
|
exports.themesByName[name] = theme;
|
|
return theme;
|
|
});
|
|
|
|
});
|
|
|
|
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) {
|
|
"use strict";
|
|
|
|
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.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.setStyle("ace_one-line");
|
|
var editor = new Editor(renderer);
|
|
new MultiSelect(editor);
|
|
editor.session.setUndoManager(new UndoManager());
|
|
|
|
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/oop","ace/lib/event","ace/range","ace/tooltip"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var dom = require("ace/lib/dom");
|
|
var oop = require("ace/lib/oop");
|
|
var event = require("ace/lib/event");
|
|
var Range = require("ace/range").Range;
|
|
var Tooltip = require("ace/tooltip").Tooltip;
|
|
|
|
function TokenTooltip (editor) {
|
|
if (editor.tokenTooltip)
|
|
return;
|
|
Tooltip.call(this, editor.container);
|
|
editor.tokenTooltip = this;
|
|
this.editor = editor;
|
|
|
|
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);
|
|
}
|
|
|
|
oop.inherits(TokenTooltip, Tooltip);
|
|
|
|
(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 = window.innerHeight;
|
|
this.maxWidth = window.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);
|
|
this.hide();
|
|
return;
|
|
}
|
|
|
|
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) {
|
|
this.setText(tokenText);
|
|
this.width = this.getWidth();
|
|
this.height = this.getHeight();
|
|
this.tokenText = tokenText;
|
|
}
|
|
|
|
this.show(null, 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.setPosition(this.x, this.y);
|
|
}
|
|
if (!this.$timer)
|
|
this.$timer = setTimeout(this.update, 100);
|
|
};
|
|
|
|
this.onMouseOut = function(e) {
|
|
if (e && e.currentTarget.contains(e.relatedTarget))
|
|
return;
|
|
this.hide();
|
|
this.editor.session.removeMarker(this.marker);
|
|
this.$timer = clearTimeout(this.$timer);
|
|
};
|
|
|
|
this.setPosition = function(x, y) {
|
|
if (x + 10 + this.width > this.maxWidth)
|
|
x = window.innerWidth - this.width - 10;
|
|
if (y > window.innerHeight * 0.75 || y + 20 + this.height > this.maxHeight)
|
|
y = y - this.height - 30;
|
|
|
|
Tooltip.prototype.setPosition.call(this, x + 10, y + 20);
|
|
};
|
|
|
|
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) {
|
|
"use strict";
|
|
|
|
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;
|
|
|
|
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();
|
|
return el;
|
|
};
|
|
|
|
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.appendChild(document.createTextNode(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, caption: item};
|
|
return elt("option", {value: item.value || item.name}, item.caption || 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) {
|
|
"use strict";
|
|
|
|
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/occur",["require","exports","module","ace/lib/oop","ace/range","ace/search","ace/edit_session","ace/search_highlight","ace/lib/dom"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var oop = require("./lib/oop");
|
|
var Range = require("./range").Range;
|
|
var Search = require("./search").Search;
|
|
var EditSession = require("./edit_session").EditSession;
|
|
var SearchHighlight = require("./search_highlight").SearchHighlight;
|
|
function Occur() {}
|
|
|
|
oop.inherits(Occur, Search);
|
|
|
|
(function() {
|
|
this.enter = function(editor, options) {
|
|
if (!options.needle) return false;
|
|
var pos = editor.getCursorPosition();
|
|
this.displayOccurContent(editor, options);
|
|
var translatedPos = this.originalToOccurPosition(editor.session, pos);
|
|
editor.moveCursorToPosition(translatedPos);
|
|
return true;
|
|
}
|
|
this.exit = function(editor, options) {
|
|
var pos = options.translatePosition && editor.getCursorPosition();
|
|
var translatedPos = pos && this.occurToOriginalPosition(editor.session, pos);
|
|
this.displayOriginalContent(editor);
|
|
if (translatedPos)
|
|
editor.moveCursorToPosition(translatedPos);
|
|
return true;
|
|
}
|
|
|
|
this.highlight = function(sess, regexp) {
|
|
var hl = sess.$occurHighlight = sess.$occurHighlight || sess.addDynamicMarker(
|
|
new SearchHighlight(null, "ace_occur-highlight", "text"));
|
|
hl.setRegexp(regexp);
|
|
sess._emit("changeBackMarker"); // force highlight layer redraw
|
|
}
|
|
|
|
this.displayOccurContent = function(editor, options) {
|
|
this.$originalSession = editor.session;
|
|
var found = this.matchingLines(editor.session, options);
|
|
var lines = found.map(function(foundLine) { return foundLine.content; });
|
|
var occurSession = new EditSession(lines.join('\n'));
|
|
occurSession.$occur = this;
|
|
occurSession.$occurMatchingLines = found;
|
|
editor.setSession(occurSession);
|
|
this.$useEmacsStyleLineStart = this.$originalSession.$useEmacsStyleLineStart;
|
|
occurSession.$useEmacsStyleLineStart = this.$useEmacsStyleLineStart;
|
|
this.highlight(occurSession, options.re);
|
|
occurSession._emit('changeBackMarker');
|
|
}
|
|
|
|
this.displayOriginalContent = function(editor) {
|
|
editor.setSession(this.$originalSession);
|
|
this.$originalSession.$useEmacsStyleLineStart = this.$useEmacsStyleLineStart;
|
|
}
|
|
this.originalToOccurPosition = function(session, pos) {
|
|
var lines = session.$occurMatchingLines;
|
|
var nullPos = {row: 0, column: 0};
|
|
if (!lines) return nullPos;
|
|
for (var i = 0; i < lines.length; i++) {
|
|
if (lines[i].row === pos.row)
|
|
return {row: i, column: pos.column};
|
|
}
|
|
return nullPos;
|
|
}
|
|
this.occurToOriginalPosition = function(session, pos) {
|
|
var lines = session.$occurMatchingLines;
|
|
if (!lines || !lines[pos.row])
|
|
return pos;
|
|
return {row: lines[pos.row].row, column: pos.column};
|
|
}
|
|
|
|
this.matchingLines = function(session, options) {
|
|
options = oop.mixin({}, options);
|
|
if (!session || !options.needle) return [];
|
|
var search = new Search();
|
|
search.set(options);
|
|
return search.findAll(session).reduce(function(lines, range) {
|
|
var row = range.start.row;
|
|
var last = lines[lines.length-1];
|
|
return last && last.row === row ?
|
|
lines :
|
|
lines.concat({row: row, content: session.getLine(row)});
|
|
}, []);
|
|
}
|
|
|
|
}).call(Occur.prototype);
|
|
|
|
var dom = require('./lib/dom');
|
|
dom.importCssString(".ace_occur-highlight {\n\
|
|
border-radius: 4px;\n\
|
|
background-color: rgba(87, 255, 8, 0.25);\n\
|
|
position: absolute;\n\
|
|
z-index: 4;\n\
|
|
-moz-box-sizing: border-box;\n\
|
|
-webkit-box-sizing: border-box;\n\
|
|
box-sizing: border-box;\n\
|
|
box-shadow: 0 0 4px rgb(91, 255, 50);\n\
|
|
}\n\
|
|
.ace_dark .ace_occur-highlight {\n\
|
|
background-color: rgb(80, 140, 85);\n\
|
|
box-shadow: 0 0 4px rgb(60, 120, 70);\n\
|
|
}\n", "incremental-occur-highlighting");
|
|
|
|
exports.Occur = Occur;
|
|
|
|
});
|
|
|
|
define("ace/commands/occur_commands",["require","exports","module","ace/config","ace/occur","ace/keyboard/hash_handler","ace/lib/oop"], function(require, exports, module) {
|
|
|
|
var config = require("../config"),
|
|
Occur = require("../occur").Occur;
|
|
var occurStartCommand = {
|
|
name: "occur",
|
|
exec: function(editor, options) {
|
|
var alreadyInOccur = !!editor.session.$occur;
|
|
var occurSessionActive = new Occur().enter(editor, options);
|
|
if (occurSessionActive && !alreadyInOccur)
|
|
OccurKeyboardHandler.installIn(editor);
|
|
},
|
|
readOnly: true
|
|
};
|
|
|
|
var occurCommands = [{
|
|
name: "occurexit",
|
|
bindKey: 'esc|Ctrl-G',
|
|
exec: function(editor) {
|
|
var occur = editor.session.$occur;
|
|
if (!occur) return;
|
|
occur.exit(editor, {});
|
|
if (!editor.session.$occur) OccurKeyboardHandler.uninstallFrom(editor);
|
|
},
|
|
readOnly: true
|
|
}, {
|
|
name: "occuraccept",
|
|
bindKey: 'enter',
|
|
exec: function(editor) {
|
|
var occur = editor.session.$occur;
|
|
if (!occur) return;
|
|
occur.exit(editor, {translatePosition: true});
|
|
if (!editor.session.$occur) OccurKeyboardHandler.uninstallFrom(editor);
|
|
},
|
|
readOnly: true
|
|
}];
|
|
|
|
var HashHandler = require("../keyboard/hash_handler").HashHandler;
|
|
var oop = require("../lib/oop");
|
|
|
|
|
|
function OccurKeyboardHandler() {}
|
|
|
|
oop.inherits(OccurKeyboardHandler, HashHandler);
|
|
|
|
;(function() {
|
|
|
|
this.isOccurHandler = true;
|
|
|
|
this.attach = function(editor) {
|
|
HashHandler.call(this, occurCommands, editor.commands.platform);
|
|
this.$editor = editor;
|
|
}
|
|
|
|
var handleKeyboard$super = this.handleKeyboard;
|
|
this.handleKeyboard = function(data, hashId, key, keyCode) {
|
|
var cmd = handleKeyboard$super.call(this, data, hashId, key, keyCode);
|
|
return (cmd && cmd.command) ? cmd : undefined;
|
|
}
|
|
|
|
}).call(OccurKeyboardHandler.prototype);
|
|
|
|
OccurKeyboardHandler.installIn = function(editor) {
|
|
var handler = new this();
|
|
editor.keyBinding.addKeyboardHandler(handler);
|
|
editor.commands.addCommands(occurCommands);
|
|
}
|
|
|
|
OccurKeyboardHandler.uninstallFrom = function(editor) {
|
|
editor.commands.removeCommands(occurCommands);
|
|
var handler = editor.getKeyboardHandler();
|
|
if (handler.isOccurHandler)
|
|
editor.keyBinding.removeKeyboardHandler(handler);
|
|
}
|
|
|
|
exports.occurStartCommand = occurStartCommand;
|
|
|
|
});
|
|
|
|
define("ace/commands/incremental_search_commands",["require","exports","module","ace/config","ace/lib/oop","ace/keyboard/hash_handler","ace/commands/occur_commands"], function(require, exports, module) {
|
|
|
|
var config = require("../config");
|
|
var oop = require("../lib/oop");
|
|
var HashHandler = require("../keyboard/hash_handler").HashHandler;
|
|
var occurStartCommand = require("./occur_commands").occurStartCommand;
|
|
exports.iSearchStartCommands = [{
|
|
name: "iSearch",
|
|
bindKey: {win: "Ctrl-F", mac: "Command-F"},
|
|
exec: function(editor, options) {
|
|
config.loadModule(["core", "ace/incremental_search"], function(e) {
|
|
var iSearch = e.iSearch = e.iSearch || new e.IncrementalSearch();
|
|
iSearch.activate(editor, options.backwards);
|
|
if (options.jumpToFirstMatch) iSearch.next(options);
|
|
});
|
|
},
|
|
readOnly: true
|
|
}, {
|
|
name: "iSearchBackwards",
|
|
exec: function(editor, jumpToNext) { editor.execCommand('iSearch', {backwards: true}); },
|
|
readOnly: true
|
|
}, {
|
|
name: "iSearchAndGo",
|
|
bindKey: {win: "Ctrl-K", mac: "Command-G"},
|
|
exec: function(editor, jumpToNext) { editor.execCommand('iSearch', {jumpToFirstMatch: true, useCurrentOrPrevSearch: true}); },
|
|
readOnly: true
|
|
}, {
|
|
name: "iSearchBackwardsAndGo",
|
|
bindKey: {win: "Ctrl-Shift-K", mac: "Command-Shift-G"},
|
|
exec: function(editor) { editor.execCommand('iSearch', {jumpToFirstMatch: true, backwards: true, useCurrentOrPrevSearch: true}); },
|
|
readOnly: true
|
|
}];
|
|
exports.iSearchCommands = [{
|
|
name: "restartSearch",
|
|
bindKey: {win: "Ctrl-F", mac: "Command-F"},
|
|
exec: function(iSearch) {
|
|
iSearch.cancelSearch(true);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "searchForward",
|
|
bindKey: {win: "Ctrl-S|Ctrl-K", mac: "Ctrl-S|Command-G"},
|
|
exec: function(iSearch, options) {
|
|
options.useCurrentOrPrevSearch = true;
|
|
iSearch.next(options);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "searchBackward",
|
|
bindKey: {win: "Ctrl-R|Ctrl-Shift-K", mac: "Ctrl-R|Command-Shift-G"},
|
|
exec: function(iSearch, options) {
|
|
options.useCurrentOrPrevSearch = true;
|
|
options.backwards = true;
|
|
iSearch.next(options);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "extendSearchTerm",
|
|
exec: function(iSearch, string) {
|
|
iSearch.addString(string);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "extendSearchTermSpace",
|
|
bindKey: "space",
|
|
exec: function(iSearch) { iSearch.addString(' '); },
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "shrinkSearchTerm",
|
|
bindKey: "backspace",
|
|
exec: function(iSearch) {
|
|
iSearch.removeChar();
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: 'confirmSearch',
|
|
bindKey: 'return',
|
|
exec: function(iSearch) { iSearch.deactivate(); },
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: 'cancelSearch',
|
|
bindKey: 'esc|Ctrl-G',
|
|
exec: function(iSearch) { iSearch.deactivate(true); },
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: 'occurisearch',
|
|
bindKey: 'Ctrl-O',
|
|
exec: function(iSearch) {
|
|
var options = oop.mixin({}, iSearch.$options);
|
|
iSearch.deactivate();
|
|
occurStartCommand.exec(iSearch.$editor, options);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "yankNextWord",
|
|
bindKey: "Ctrl-w",
|
|
exec: function(iSearch) {
|
|
var ed = iSearch.$editor,
|
|
range = ed.selection.getRangeOfMovements(function(sel) { sel.moveCursorWordRight(); }),
|
|
string = ed.session.getTextRange(range);
|
|
iSearch.addString(string);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: "yankNextChar",
|
|
bindKey: "Ctrl-Alt-y",
|
|
exec: function(iSearch) {
|
|
var ed = iSearch.$editor,
|
|
range = ed.selection.getRangeOfMovements(function(sel) { sel.moveCursorRight(); }),
|
|
string = ed.session.getTextRange(range);
|
|
iSearch.addString(string);
|
|
},
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}, {
|
|
name: 'recenterTopBottom',
|
|
bindKey: 'Ctrl-l',
|
|
exec: function(iSearch) { iSearch.$editor.execCommand('recenterTopBottom'); },
|
|
readOnly: true,
|
|
isIncrementalSearchCommand: true
|
|
}];
|
|
|
|
function IncrementalSearchKeyboardHandler(iSearch) {
|
|
this.$iSearch = iSearch;
|
|
}
|
|
|
|
oop.inherits(IncrementalSearchKeyboardHandler, HashHandler);
|
|
|
|
;(function() {
|
|
|
|
this.attach = function(editor) {
|
|
var iSearch = this.$iSearch;
|
|
HashHandler.call(this, exports.iSearchCommands, editor.commands.platform);
|
|
this.$commandExecHandler = editor.commands.addEventListener('exec', function(e) {
|
|
if (!e.command.isIncrementalSearchCommand) return undefined;
|
|
e.stopPropagation();
|
|
e.preventDefault();
|
|
return e.command.exec(iSearch, e.args || {});
|
|
});
|
|
}
|
|
|
|
this.detach = function(editor) {
|
|
if (!this.$commandExecHandler) return;
|
|
editor.commands.removeEventListener('exec', this.$commandExecHandler);
|
|
delete this.$commandExecHandler;
|
|
}
|
|
|
|
var handleKeyboard$super = this.handleKeyboard;
|
|
this.handleKeyboard = function(data, hashId, key, keyCode) {
|
|
if (((hashId === 1/*ctrl*/ || hashId === 8/*command*/) && key === 'v')
|
|
|| (hashId === 1/*ctrl*/ && key === 'y')) return null;
|
|
var cmd = handleKeyboard$super.call(this, data, hashId, key, keyCode);
|
|
if (cmd.command) { return cmd; }
|
|
if (hashId == -1) {
|
|
var extendCmd = this.commands.extendSearchTerm;
|
|
if (extendCmd) { return {command: extendCmd, args: key}; }
|
|
}
|
|
return {command: "null", passEvent: hashId == 0 || hashId == 4};
|
|
}
|
|
|
|
}).call(IncrementalSearchKeyboardHandler.prototype);
|
|
|
|
|
|
exports.IncrementalSearchKeyboardHandler = IncrementalSearchKeyboardHandler;
|
|
|
|
});
|
|
|
|
define("ace/incremental_search",["require","exports","module","ace/lib/oop","ace/range","ace/search","ace/search_highlight","ace/commands/incremental_search_commands","ace/lib/dom","ace/commands/command_manager","ace/editor","ace/config"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var oop = require("./lib/oop");
|
|
var Range = require("./range").Range;
|
|
var Search = require("./search").Search;
|
|
var SearchHighlight = require("./search_highlight").SearchHighlight;
|
|
var iSearchCommandModule = require("./commands/incremental_search_commands");
|
|
var ISearchKbd = iSearchCommandModule.IncrementalSearchKeyboardHandler;
|
|
function IncrementalSearch() {
|
|
this.$options = {wrap: false, skipCurrent: false};
|
|
this.$keyboardHandler = new ISearchKbd(this);
|
|
}
|
|
|
|
oop.inherits(IncrementalSearch, Search);
|
|
|
|
;(function() {
|
|
|
|
this.activate = function(ed, backwards) {
|
|
this.$editor = ed;
|
|
this.$startPos = this.$currentPos = ed.getCursorPosition();
|
|
this.$options.needle = '';
|
|
this.$options.backwards = backwards;
|
|
ed.keyBinding.addKeyboardHandler(this.$keyboardHandler);
|
|
this.$originalEditorOnPaste = ed.onPaste; ed.onPaste = this.onPaste.bind(this);
|
|
this.$mousedownHandler = ed.addEventListener('mousedown', this.onMouseDown.bind(this));
|
|
this.selectionFix(ed);
|
|
this.statusMessage(true);
|
|
}
|
|
|
|
this.deactivate = function(reset) {
|
|
this.cancelSearch(reset);
|
|
var ed = this.$editor;
|
|
ed.keyBinding.removeKeyboardHandler(this.$keyboardHandler);
|
|
if (this.$mousedownHandler) {
|
|
ed.removeEventListener('mousedown', this.$mousedownHandler);
|
|
delete this.$mousedownHandler;
|
|
}
|
|
ed.onPaste = this.$originalEditorOnPaste;
|
|
this.message('');
|
|
}
|
|
|
|
this.selectionFix = function(editor) {
|
|
if (editor.selection.isEmpty() && !editor.session.$emacsMark) {
|
|
editor.clearSelection();
|
|
}
|
|
}
|
|
|
|
this.highlight = function(regexp) {
|
|
var sess = this.$editor.session,
|
|
hl = sess.$isearchHighlight = sess.$isearchHighlight || sess.addDynamicMarker(
|
|
new SearchHighlight(null, "ace_isearch-result", "text"));
|
|
hl.setRegexp(regexp);
|
|
sess._emit("changeBackMarker"); // force highlight layer redraw
|
|
}
|
|
|
|
this.cancelSearch = function(reset) {
|
|
var e = this.$editor;
|
|
this.$prevNeedle = this.$options.needle;
|
|
this.$options.needle = '';
|
|
if (reset) {
|
|
e.moveCursorToPosition(this.$startPos);
|
|
this.$currentPos = this.$startPos;
|
|
} else {
|
|
e.pushEmacsMark && e.pushEmacsMark(this.$startPos, false);
|
|
}
|
|
this.highlight(null);
|
|
return Range.fromPoints(this.$currentPos, this.$currentPos);
|
|
}
|
|
|
|
this.highlightAndFindWithNeedle = function(moveToNext, needleUpdateFunc) {
|
|
if (!this.$editor) return null;
|
|
var options = this.$options;
|
|
if (needleUpdateFunc) {
|
|
options.needle = needleUpdateFunc.call(this, options.needle || '') || '';
|
|
}
|
|
if (options.needle.length === 0) {
|
|
this.statusMessage(true);
|
|
return this.cancelSearch(true);
|
|
};
|
|
options.start = this.$currentPos;
|
|
var session = this.$editor.session,
|
|
found = this.find(session);
|
|
if (found) {
|
|
if (options.backwards) found = Range.fromPoints(found.end, found.start);
|
|
this.$editor.moveCursorToPosition(found.end);
|
|
if (moveToNext) this.$currentPos = found.end;
|
|
this.highlight(options.re)
|
|
}
|
|
|
|
this.statusMessage(found);
|
|
|
|
return found;
|
|
}
|
|
|
|
this.addString = function(s) {
|
|
return this.highlightAndFindWithNeedle(false, function(needle) {
|
|
return needle + s;
|
|
});
|
|
}
|
|
|
|
this.removeChar = function(c) {
|
|
return this.highlightAndFindWithNeedle(false, function(needle) {
|
|
return needle.length > 0 ? needle.substring(0, needle.length-1) : needle;
|
|
});
|
|
}
|
|
|
|
this.next = function(options) {
|
|
options = options || {};
|
|
this.$options.backwards = !!options.backwards;
|
|
this.$currentPos = this.$editor.getCursorPosition();
|
|
return this.highlightAndFindWithNeedle(true, function(needle) {
|
|
return options.useCurrentOrPrevSearch && needle.length === 0 ?
|
|
this.$prevNeedle || '' : needle;
|
|
});
|
|
}
|
|
|
|
this.onMouseDown = function(evt) {
|
|
this.deactivate();
|
|
return true;
|
|
}
|
|
|
|
this.onPaste = function(text) {
|
|
this.addString(text);
|
|
}
|
|
|
|
this.statusMessage = function(found) {
|
|
var options = this.$options, msg = '';
|
|
msg += options.backwards ? 'reverse-' : '';
|
|
msg += 'isearch: ' + options.needle;
|
|
msg += found ? '' : ' (not found)';
|
|
this.message(msg);
|
|
}
|
|
|
|
this.message = function(msg) {
|
|
if (this.$editor.showCommandLine) {
|
|
this.$editor.showCommandLine(msg);
|
|
this.$editor.focus();
|
|
} else {
|
|
console.log(msg);
|
|
}
|
|
}
|
|
|
|
}).call(IncrementalSearch.prototype);
|
|
|
|
|
|
exports.IncrementalSearch = IncrementalSearch;
|
|
|
|
var dom = require('./lib/dom');
|
|
dom.importCssString && dom.importCssString("\
|
|
.ace_marker-layer .ace_isearch-result {\
|
|
position: absolute;\
|
|
z-index: 6;\
|
|
-moz-box-sizing: border-box;\
|
|
-webkit-box-sizing: border-box;\
|
|
box-sizing: border-box;\
|
|
}\
|
|
div.ace_isearch-result {\
|
|
border-radius: 4px;\
|
|
background-color: rgba(255, 200, 0, 0.5);\
|
|
box-shadow: 0 0 4px rgb(255, 200, 0);\
|
|
}\
|
|
.ace_dark div.ace_isearch-result {\
|
|
background-color: rgb(100, 110, 160);\
|
|
box-shadow: 0 0 4px rgb(80, 90, 140);\
|
|
}", "incremental-search-highlighting");
|
|
var commands = require("./commands/command_manager");
|
|
(function() {
|
|
this.setupIncrementalSearch = function(editor, val) {
|
|
if (this.usesIncrementalSearch == val) return;
|
|
this.usesIncrementalSearch = val;
|
|
var iSearchCommands = iSearchCommandModule.iSearchStartCommands;
|
|
var method = val ? 'addCommands' : 'removeCommands';
|
|
this[method](iSearchCommands);
|
|
};
|
|
}).call(commands.CommandManager.prototype);
|
|
var Editor = require("./editor").Editor;
|
|
require("./config").defineOptions(Editor.prototype, "editor", {
|
|
useIncrementalSearch: {
|
|
set: function(val) {
|
|
this.keyBinding.$handlers.forEach(function(handler) {
|
|
if (handler.setupIncrementalSearch) {
|
|
handler.setupIncrementalSearch(this, val);
|
|
}
|
|
});
|
|
this._emit('incrementalSearchSettingChanged', {isEnabled: val});
|
|
}
|
|
}
|
|
});
|
|
|
|
});
|
|
|
|
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) {
|
|
"use strict";
|
|
|
|
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/registers",["require","exports","module"], function(require, exports, module) {
|
|
|
|
"never use strict";
|
|
|
|
module.exports = {
|
|
_default: {
|
|
text: "",
|
|
isLine: 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.vimState = "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.vimState = "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.moveTo(pos.row, pos.column);
|
|
editor.selection.selectLine();
|
|
registers._default.isLine = true;
|
|
registers._default.text = editor.getCopyText().replace(/\n$/, "");
|
|
editor.selection.moveTo(pos.row, pos.column);
|
|
}
|
|
};
|
|
});
|
|
|
|
define("ace/keyboard/vim/maps/motions",["require","exports","module","ace/keyboard/vim/maps/util","ace/search","ace/range"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
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.selection.moveTo(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;
|
|
|
|
var LAST_SEARCH_MOTION = {};
|
|
|
|
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 "]":
|
|
param = editor.session.$brackets[param];
|
|
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, isRepeat) {
|
|
if (param == "space") param = " ";
|
|
if (!isRepeat)
|
|
LAST_SEARCH_MOTION = {ch: "f", param: param};
|
|
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, isRepeat) {
|
|
if (param == "space") param = " ";
|
|
if (!isRepeat)
|
|
LAST_SEARCH_MOTION = {ch: "F", param: param};
|
|
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, isRepeat) {
|
|
if (param == "space") param = " ";
|
|
if (!isRepeat)
|
|
LAST_SEARCH_MOTION = {ch: "t", param: param};
|
|
var cursor = editor.getCursorPosition();
|
|
var column = util.getRightNthChar(editor, cursor, param, count || 1);
|
|
|
|
if (isRepeat && column == 0 && !(count > 1))
|
|
column = util.getRightNthChar(editor, cursor, param, 2);
|
|
|
|
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, isRepeat) {
|
|
if (param == "space") param = " ";
|
|
if (!isRepeat)
|
|
LAST_SEARCH_MOTION = {ch: "T", param: param};
|
|
var cursor = editor.getCursorPosition();
|
|
var column = util.getLeftNthChar(editor, cursor, param, count || 1);
|
|
|
|
if (isRepeat && column === 0 && !(count > 1))
|
|
column = util.getLeftNthChar(editor, cursor, param, 2);
|
|
|
|
if (typeof column === "number") {
|
|
cursor.column -= column;
|
|
return cursor;
|
|
}
|
|
}
|
|
}),
|
|
";": new Motion({
|
|
handlesCount: true,
|
|
getPos: function(editor, range, count, param, isSel) {
|
|
var ch = LAST_SEARCH_MOTION.ch;
|
|
if (!ch)
|
|
return;
|
|
return module.exports[ch].getPos(
|
|
editor, range, count, LAST_SEARCH_MOTION.param, isSel, true
|
|
);
|
|
}
|
|
}),
|
|
",": new Motion({
|
|
handlesCount: true,
|
|
getPos: function(editor, range, count, param, isSel) {
|
|
var ch = LAST_SEARCH_MOTION.ch;
|
|
if (!ch)
|
|
return;
|
|
var up = ch.toUpperCase();
|
|
ch = ch === up ? ch.toLowerCase() : up;
|
|
|
|
return module.exports[ch].getPos(
|
|
editor, range, count, LAST_SEARCH_MOTION.param, isSel, true
|
|
);
|
|
}
|
|
}),
|
|
|
|
"^": {
|
|
nav: function(editor) {
|
|
editor.navigateLineStart();
|
|
},
|
|
sel: function(editor) {
|
|
editor.selection.selectLineStart();
|
|
}
|
|
},
|
|
"$": {
|
|
handlesCount: true,
|
|
nav: function(editor, range, count, param) {
|
|
if (count > 1) {
|
|
editor.navigateDown(count-1);
|
|
}
|
|
editor.navigateLineEnd();
|
|
},
|
|
sel: function(editor, range, count, param) {
|
|
if (count > 1) {
|
|
editor.selection.moveCursorBy(count-1, 0);
|
|
}
|
|
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;
|
|
}
|
|
},
|
|
isLine: true
|
|
})
|
|
};
|
|
|
|
module.exports.backspace = module.exports.left = module.exports.h;
|
|
module.exports.space = module.exports['return'] = 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"];
|
|
module.exports.home = module.exports["0"];
|
|
module.exports.end = module.exports["$"];
|
|
|
|
});
|
|
|
|
define("ace/keyboard/vim/maps/operators",["require","exports","module","ace/keyboard/vim/maps/util","ace/keyboard/vim/registers","ace/range"], function(require, exports, module) {
|
|
|
|
"use strict";
|
|
|
|
var util = require("./util");
|
|
var registers = require("../registers");
|
|
var Range = require("../../../range").Range;
|
|
|
|
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()) {
|
|
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":
|
|
editor.$blockScrolling++;
|
|
editor.selection.$moveSelection(function() {
|
|
editor.selection.moveCursorBy(count - 1, 0);
|
|
});
|
|
var rows = editor.$getSelectedRows();
|
|
range = new Range(rows.first, 0, rows.last, Infinity);
|
|
editor.session.remove(range);
|
|
editor.$blockScrolling--;
|
|
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;
|
|
if (param && param.isLine)
|
|
param = "y";
|
|
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("ace/keyboard/vim/commands",["require","exports","module","ace/lib/lang","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 lang = require("../../lib/lang");
|
|
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;
|
|
case "c":
|
|
editor.session.onFoldWidgetClick(range.start.row, {domEvent:{target :{}}});
|
|
break;
|
|
case "o":
|
|
editor.session.onFoldWidgetClick(range.start.row, {domEvent:{target :{}}});
|
|
break;
|
|
case "C":
|
|
editor.session.foldAll();
|
|
break;
|
|
case "O":
|
|
editor.session.unfold();
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
"r": {
|
|
param: true,
|
|
fn: function(editor, range, count, param) {
|
|
if (param && param.length) {
|
|
if (param.length > 1)
|
|
param = param == "return" ? "\n" : param == "tab" ? "\t" : param;
|
|
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.session.replace(range, toggled);
|
|
else if (text.toLowerCase() != text)
|
|
editor.session.replace(range, text.toLowerCase())
|
|
else
|
|
editor.navigateRight();
|
|
}, 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;
|
|
options.start = null;
|
|
|
|
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;
|
|
options.start = null;
|
|
|
|
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.moveTo(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();
|
|
pos.column = editor.session.getLine(pos.row).length;
|
|
var text = lang.stringRepeat("\n" + defaultReg.text, count || 1);
|
|
editor.session.insert(pos, text);
|
|
editor.moveCursorTo(pos.row + 1, 0);
|
|
}
|
|
else {
|
|
editor.navigateRight();
|
|
editor.insert(lang.stringRepeat(defaultReg.text, count || 1));
|
|
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();
|
|
pos.column = 0;
|
|
var text = lang.stringRepeat(defaultReg.text + "\n", count || 1);
|
|
editor.session.insert(pos, text);
|
|
editor.moveCursorToPosition(pos);
|
|
}
|
|
else {
|
|
editor.insert(lang.stringRepeat(defaultReg.text, count || 1));
|
|
}
|
|
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) {
|
|
var val = ":";
|
|
if (count > 1)
|
|
val = ".,.+" + count + val;
|
|
if (editor.showCommandLine)
|
|
editor.showCommandLine(val);
|
|
}
|
|
},
|
|
"/": {
|
|
fn: function(editor, range, count, param) {
|
|
if (editor.showCommandLine)
|
|
editor.showCommandLine("/");
|
|
}
|
|
},
|
|
"?": {
|
|
fn: function(editor, range, count, param) {
|
|
if (editor.showCommandLine)
|
|
editor.showCommandLine("?");
|
|
}
|
|
},
|
|
".": {
|
|
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: "",
|
|
pendingCount: "",
|
|
status: "",
|
|
operator: null,
|
|
motion: null,
|
|
|
|
lastInsertCommands: [],
|
|
|
|
push: function(editor, ch, keyId) {
|
|
var status = this.status;
|
|
var isKeyHandled = true;
|
|
this.idle = false;
|
|
var wObj = this.waitingForParam;
|
|
if (/^numpad\d+$/i.test(ch))
|
|
ch = ch.substr(6);
|
|
|
|
if (wObj) {
|
|
this.exec(editor, wObj, ch);
|
|
}
|
|
else if (!(ch === "0" && !this.currentCount.length) &&
|
|
(/^\d+$/.test(ch) && 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.operator.count = this.getCount();
|
|
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 = "";
|
|
}
|
|
if (this.status != status)
|
|
editor._emit("changeStatus");
|
|
return isKeyHandled;
|
|
},
|
|
|
|
waitForParam: function(cmd) {
|
|
this.waitingForParam = cmd;
|
|
},
|
|
|
|
getCount: function() {
|
|
var count = this.currentCount || this.pendingCount;
|
|
this.currentCount = "";
|
|
this.pendingCount = count;
|
|
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, motionObj.param ? motionObj : 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.pendingCount = "";
|
|
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.moveTo(originRow, 0);
|
|
editor.selection.selectTo(cursorRow, endLine.length);
|
|
} else {
|
|
var endLine = editor.session.getLine(originRow);
|
|
editor.selection.moveTo(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",["require","exports","module","ace/keyboard/vim/commands","ace/keyboard/vim/maps/util","ace/lib/useragent"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
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 = {
|
|
$id: "ace/keyboard/vim",
|
|
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";
|
|
}
|
|
},
|
|
updateMacCompositionHandlers: function(editor, enable) {
|
|
var onCompositionUpdateOverride = function(text) {
|
|
if (util.currentMode !== "insert") {
|
|
var el = this.textInput.getElement();
|
|
el.blur();
|
|
el.focus();
|
|
el.value = text;
|
|
} else {
|
|
this.onCompositionUpdateOrig(text);
|
|
}
|
|
};
|
|
var onCompositionStartOverride = function(text) {
|
|
if (util.currentMode === "insert") {
|
|
this.onCompositionStartOrig(text);
|
|
}
|
|
};
|
|
if (enable) {
|
|
if (!editor.onCompositionUpdateOrig) {
|
|
editor.onCompositionUpdateOrig = editor.onCompositionUpdate;
|
|
editor.onCompositionUpdate = onCompositionUpdateOverride;
|
|
editor.onCompositionStartOrig = editor.onCompositionStart;
|
|
editor.onCompositionStart = onCompositionStartOverride;
|
|
}
|
|
} else {
|
|
if (editor.onCompositionUpdateOrig) {
|
|
editor.onCompositionUpdate = editor.onCompositionUpdateOrig;
|
|
editor.onCompositionUpdateOrig = null;
|
|
editor.onCompositionStart = editor.onCompositionStartOrig;
|
|
editor.onCompositionStartOrig = null;
|
|
}
|
|
}
|
|
},
|
|
|
|
handleKeyboard: function(data, hashId, key, keyCode, e) {
|
|
if (hashId !== 0 && (!key || keyCode == -1))
|
|
return null;
|
|
|
|
var editor = data.editor;
|
|
var vimState = data.vimState || "start";
|
|
|
|
if (hashId == 1)
|
|
key = "ctrl-" + key;
|
|
if (key == "ctrl-c") {
|
|
if (!useragent.isMac && editor.getCopyText()) {
|
|
editor.once("copy", function() {
|
|
if (vimState == "start")
|
|
coreCommands.stop.exec(editor);
|
|
else
|
|
editor.selection.clearSelection();
|
|
});
|
|
return {command: "null", passEvent: true};
|
|
}
|
|
return {command: coreCommands.stop};
|
|
} else if ((key == "esc" && hashId === 0) || key == "ctrl-[") {
|
|
return {command: coreCommands.stop};
|
|
} else if (vimState == "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];
|
|
var isHandled = cmds.inputBuffer.push(editor, key);
|
|
if (!isHandled && hashId !== -1)
|
|
return;
|
|
return {command: "null", passEvent: !isHandled};
|
|
} else if (key == "esc" && hashId === 0) {
|
|
return {command: coreCommands.stop};
|
|
}
|
|
else if (hashId === 0 || hashId == 4) {
|
|
return {command: "null", passEvent: true};
|
|
}
|
|
} 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;
|
|
|
|
this.updateMacCompositionHandlers(editor, true);
|
|
},
|
|
|
|
detach: function(editor) {
|
|
editor.removeListener("click", exports.onCursorMove);
|
|
util.noMode(editor);
|
|
util.currentMode = "normal";
|
|
this.updateMacCompositionHandlers(editor, false);
|
|
},
|
|
|
|
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/ext/statusbar",["require","exports","module","ace/lib/dom","ace/lib/lang"], function(require, exports, module) {
|
|
"use strict";
|
|
var dom = require("ace/lib/dom");
|
|
var lang = require("ace/lib/lang");
|
|
|
|
var StatusBar = function(editor, parentNode) {
|
|
this.element = dom.createElement("div");
|
|
this.element.className = "ace_status-indicator";
|
|
this.element.style.cssText = "display: inline-block;";
|
|
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;
|
|
|
|
});
|
|
|
|
define("ace/snippets",["require","exports","module","ace/lib/oop","ace/lib/event_emitter","ace/lib/lang","ace/range","ace/anchor","ace/keyboard/hash_handler","ace/tokenizer","ace/lib/dom","ace/editor"], function(require, exports, module) {
|
|
"use strict";
|
|
var oop = require("./lib/oop");
|
|
var EventEmitter = require("./lib/event_emitter").EventEmitter;
|
|
var lang = require("./lib/lang");
|
|
var Range = require("./range").Range;
|
|
var Anchor = require("./anchor").Anchor;
|
|
var HashHandler = require("./keyboard/hash_handler").HashHandler;
|
|
var Tokenizer = require("./tokenizer").Tokenizer;
|
|
var comparePoints = Range.comparePoints;
|
|
|
|
var SnippetManager = function() {
|
|
this.snippetMap = {};
|
|
this.snippetNameMap = {};
|
|
};
|
|
|
|
(function() {
|
|
oop.implement(this, EventEmitter);
|
|
|
|
this.getTokenizer = function() {
|
|
function TabstopToken(str, _, stack) {
|
|
str = str.substr(1);
|
|
if (/^\d+$/.test(str) && !stack.inFormatString)
|
|
return [{tabstopId: parseInt(str, 10)}];
|
|
return [{text: str}];
|
|
}
|
|
function escape(ch) {
|
|
return "(?:[^\\\\" + ch + "]|\\\\.)";
|
|
}
|
|
SnippetManager.$tokenizer = new Tokenizer({
|
|
start: [
|
|
{regex: /:/, onMatch: function(val, state, stack) {
|
|
if (stack.length && stack[0].expectIf) {
|
|
stack[0].expectIf = false;
|
|
stack[0].elseBranch = stack[0];
|
|
return [stack[0]];
|
|
}
|
|
return ":";
|
|
}},
|
|
{regex: /\\./, onMatch: function(val, state, stack) {
|
|
var ch = val[1];
|
|
if (ch == "}" && stack.length) {
|
|
val = ch;
|
|
}else if ("`$\\".indexOf(ch) != -1) {
|
|
val = ch;
|
|
} else if (stack.inFormatString) {
|
|
if (ch == "n")
|
|
val = "\n";
|
|
else if (ch == "t")
|
|
val = "\n";
|
|
else if ("ulULE".indexOf(ch) != -1) {
|
|
val = {changeCase: ch, local: ch > "a"};
|
|
}
|
|
}
|
|
|
|
return [val];
|
|
}},
|
|
{regex: /}/, onMatch: function(val, state, stack) {
|
|
return [stack.length ? stack.shift() : val];
|
|
}},
|
|
{regex: /\$(?:\d+|\w+)/, onMatch: TabstopToken},
|
|
{regex: /\$\{[\dA-Z_a-z]+/, onMatch: function(str, state, stack) {
|
|
var t = TabstopToken(str.substr(1), state, stack);
|
|
stack.unshift(t[0]);
|
|
return t;
|
|
}, next: "snippetVar"},
|
|
{regex: /\n/, token: "newline", merge: false}
|
|
],
|
|
snippetVar: [
|
|
{regex: "\\|" + escape("\\|") + "*\\|", onMatch: function(val, state, stack) {
|
|
stack[0].choices = val.slice(1, -1).split(",");
|
|
}, next: "start"},
|
|
{regex: "/(" + escape("/") + "+)/(?:(" + escape("/") + "*)/)(\\w*):?",
|
|
onMatch: function(val, state, stack) {
|
|
var ts = stack[0];
|
|
ts.fmtString = val;
|
|
|
|
val = this.splitRegex.exec(val);
|
|
ts.guard = val[1];
|
|
ts.fmt = val[2];
|
|
ts.flag = val[3];
|
|
return "";
|
|
}, next: "start"},
|
|
{regex: "`" + escape("`") + "*`", onMatch: function(val, state, stack) {
|
|
stack[0].code = val.splice(1, -1);
|
|
return "";
|
|
}, next: "start"},
|
|
{regex: "\\?", onMatch: function(val, state, stack) {
|
|
if (stack[0])
|
|
stack[0].expectIf = true;
|
|
}, next: "start"},
|
|
{regex: "([^:}\\\\]|\\\\.)*:?", token: "", next: "start"}
|
|
],
|
|
formatString: [
|
|
{regex: "/(" + escape("/") + "+)/", token: "regex"},
|
|
{regex: "", onMatch: function(val, state, stack) {
|
|
stack.inFormatString = true;
|
|
}, next: "start"}
|
|
]
|
|
});
|
|
SnippetManager.prototype.getTokenizer = function() {
|
|
return SnippetManager.$tokenizer;
|
|
};
|
|
return SnippetManager.$tokenizer;
|
|
};
|
|
|
|
this.tokenizeTmSnippet = function(str, startState) {
|
|
return this.getTokenizer().getLineTokens(str, startState).tokens.map(function(x) {
|
|
return x.value || x;
|
|
});
|
|
};
|
|
|
|
this.$getDefaultValue = function(editor, name) {
|
|
if (/^[A-Z]\d+$/.test(name)) {
|
|
var i = name.substr(1);
|
|
return (this.variables[name[0] + "__"] || {})[i];
|
|
}
|
|
if (/^\d+$/.test(name)) {
|
|
return (this.variables.__ || {})[name];
|
|
}
|
|
name = name.replace(/^TM_/, "");
|
|
|
|
if (!editor)
|
|
return;
|
|
var s = editor.session;
|
|
switch(name) {
|
|
case "CURRENT_WORD":
|
|
var r = s.getWordRange();
|
|
case "SELECTION":
|
|
case "SELECTED_TEXT":
|
|
return s.getTextRange(r);
|
|
case "CURRENT_LINE":
|
|
return s.getLine(editor.getCursorPosition().row);
|
|
case "PREV_LINE": // not possible in textmate
|
|
return s.getLine(editor.getCursorPosition().row - 1);
|
|
case "LINE_INDEX":
|
|
return editor.getCursorPosition().column;
|
|
case "LINE_NUMBER":
|
|
return editor.getCursorPosition().row + 1;
|
|
case "SOFT_TABS":
|
|
return s.getUseSoftTabs() ? "YES" : "NO";
|
|
case "TAB_SIZE":
|
|
return s.getTabSize();
|
|
case "FILENAME":
|
|
case "FILEPATH":
|
|
return "";
|
|
case "FULLNAME":
|
|
return "Ace";
|
|
}
|
|
};
|
|
this.variables = {};
|
|
this.getVariableValue = function(editor, varName) {
|
|
if (this.variables.hasOwnProperty(varName))
|
|
return this.variables[varName](editor, varName) || "";
|
|
return this.$getDefaultValue(editor, varName) || "";
|
|
};
|
|
this.tmStrFormat = function(str, ch, editor) {
|
|
var flag = ch.flag || "";
|
|
var re = ch.guard;
|
|
re = new RegExp(re, flag.replace(/[^gi]/, ""));
|
|
var fmtTokens = this.tokenizeTmSnippet(ch.fmt, "formatString");
|
|
var _self = this;
|
|
var formatted = str.replace(re, function() {
|
|
_self.variables.__ = arguments;
|
|
var fmtParts = _self.resolveVariables(fmtTokens, editor);
|
|
var gChangeCase = "E";
|
|
for (var i = 0; i < fmtParts.length; i++) {
|
|
var ch = fmtParts[i];
|
|
if (typeof ch == "object") {
|
|
fmtParts[i] = "";
|
|
if (ch.changeCase && ch.local) {
|
|
var next = fmtParts[i + 1];
|
|
if (next && typeof next == "string") {
|
|
if (ch.changeCase == "u")
|
|
fmtParts[i] = next[0].toUpperCase();
|
|
else
|
|
fmtParts[i] = next[0].toLowerCase();
|
|
fmtParts[i + 1] = next.substr(1);
|
|
}
|
|
} else if (ch.changeCase) {
|
|
gChangeCase = ch.changeCase;
|
|
}
|
|
} else if (gChangeCase == "U") {
|
|
fmtParts[i] = ch.toUpperCase();
|
|
} else if (gChangeCase == "L") {
|
|
fmtParts[i] = ch.toLowerCase();
|
|
}
|
|
}
|
|
return fmtParts.join("");
|
|
});
|
|
this.variables.__ = null;
|
|
return formatted;
|
|
};
|
|
|
|
this.resolveVariables = function(snippet, editor) {
|
|
var result = [];
|
|
for (var i = 0; i < snippet.length; i++) {
|
|
var ch = snippet[i];
|
|
if (typeof ch == "string") {
|
|
result.push(ch);
|
|
} else if (typeof ch != "object") {
|
|
continue;
|
|
} else if (ch.skip) {
|
|
gotoNext(ch);
|
|
} else if (ch.processed < i) {
|
|
continue;
|
|
} else if (ch.text) {
|
|
var value = this.getVariableValue(editor, ch.text);
|
|
if (value && ch.fmtString)
|
|
value = this.tmStrFormat(value, ch);
|
|
ch.processed = i;
|
|
if (ch.expectIf == null) {
|
|
if (value) {
|
|
result.push(value);
|
|
gotoNext(ch);
|
|
}
|
|
} else {
|
|
if (value) {
|
|
ch.skip = ch.elseBranch;
|
|
} else
|
|
gotoNext(ch);
|
|
}
|
|
} else if (ch.tabstopId != null) {
|
|
result.push(ch);
|
|
} else if (ch.changeCase != null) {
|
|
result.push(ch);
|
|
}
|
|
}
|
|
function gotoNext(ch) {
|
|
var i1 = snippet.indexOf(ch, i + 1);
|
|
if (i1 != -1)
|
|
i = i1;
|
|
}
|
|
return result;
|
|
};
|
|
|
|
this.insertSnippetForSelection = function(editor, snippetText) {
|
|
var cursor = editor.getCursorPosition();
|
|
var line = editor.session.getLine(cursor.row);
|
|
var tabString = editor.session.getTabString();
|
|
var indentString = line.match(/^\s*/)[0];
|
|
|
|
if (cursor.column < indentString.length)
|
|
indentString = indentString.slice(0, cursor.column);
|
|
|
|
var tokens = this.tokenizeTmSnippet(snippetText);
|
|
tokens = this.resolveVariables(tokens, editor);
|
|
tokens = tokens.map(function(x) {
|
|
if (x == "\n")
|
|
return x + indentString;
|
|
if (typeof x == "string")
|
|
return x.replace(/\t/g, tabString);
|
|
return x;
|
|
});
|
|
var tabstops = [];
|
|
tokens.forEach(function(p, i) {
|
|
if (typeof p != "object")
|
|
return;
|
|
var id = p.tabstopId;
|
|
var ts = tabstops[id];
|
|
if (!ts) {
|
|
ts = tabstops[id] = [];
|
|
ts.index = id;
|
|
ts.value = "";
|
|
}
|
|
if (ts.indexOf(p) !== -1)
|
|
return;
|
|
ts.push(p);
|
|
var i1 = tokens.indexOf(p, i + 1);
|
|
if (i1 === -1)
|
|
return;
|
|
|
|
var value = tokens.slice(i + 1, i1);
|
|
var isNested = value.some(function(t) {return typeof t === "object"});
|
|
if (isNested && !ts.value) {
|
|
ts.value = value;
|
|
} else if (value.length && (!ts.value || typeof ts.value !== "string")) {
|
|
ts.value = value.join("");
|
|
}
|
|
});
|
|
tabstops.forEach(function(ts) {ts.length = 0});
|
|
var expanding = {};
|
|
function copyValue(val) {
|
|
var copy = [];
|
|
for (var i = 0; i < val.length; i++) {
|
|
var p = val[i];
|
|
if (typeof p == "object") {
|
|
if (expanding[p.tabstopId])
|
|
continue;
|
|
var j = val.lastIndexOf(p, i - 1);
|
|
p = copy[j] || {tabstopId: p.tabstopId};
|
|
}
|
|
copy[i] = p;
|
|
}
|
|
return copy;
|
|
}
|
|
for (var i = 0; i < tokens.length; i++) {
|
|
var p = tokens[i];
|
|
if (typeof p != "object")
|
|
continue;
|
|
var id = p.tabstopId;
|
|
var i1 = tokens.indexOf(p, i + 1);
|
|
if (expanding[id]) {
|
|
if (expanding[id] === p)
|
|
expanding[id] = null;
|
|
continue;
|
|
}
|
|
|
|
var ts = tabstops[id];
|
|
var arg = typeof ts.value == "string" ? [ts.value] : copyValue(ts.value);
|
|
arg.unshift(i + 1, Math.max(0, i1 - i));
|
|
arg.push(p);
|
|
expanding[id] = p;
|
|
tokens.splice.apply(tokens, arg);
|
|
|
|
if (ts.indexOf(p) === -1)
|
|
ts.push(p);
|
|
}
|
|
var row = 0, column = 0;
|
|
var text = "";
|
|
tokens.forEach(function(t) {
|
|
if (typeof t === "string") {
|
|
if (t[0] === "\n"){
|
|
column = t.length - 1;
|
|
row ++;
|
|
} else
|
|
column += t.length;
|
|
text += t;
|
|
} else {
|
|
if (!t.start)
|
|
t.start = {row: row, column: column};
|
|
else
|
|
t.end = {row: row, column: column};
|
|
}
|
|
});
|
|
var range = editor.getSelectionRange();
|
|
var end = editor.session.replace(range, text);
|
|
|
|
var tabstopManager = new TabstopManager(editor);
|
|
var selectionId = editor.inVirtualSelectionMode && editor.selection.index;
|
|
tabstopManager.addTabstops(tabstops, range.start, end, selectionId);
|
|
};
|
|
|
|
this.insertSnippet = function(editor, snippetText) {
|
|
var self = this;
|
|
if (editor.inVirtualSelectionMode)
|
|
return self.insertSnippetForSelection(editor, snippetText);
|
|
|
|
editor.forEachSelection(function() {
|
|
self.insertSnippetForSelection(editor, snippetText);
|
|
}, null, {keepOrder: true});
|
|
|
|
if (editor.tabstopManager)
|
|
editor.tabstopManager.tabNext();
|
|
};
|
|
|
|
this.$getScope = function(editor) {
|
|
var scope = editor.session.$mode.$id || "";
|
|
scope = scope.split("/").pop();
|
|
if (scope === "html" || scope === "php") {
|
|
if (scope === "php" && !editor.session.$mode.inlinePhp)
|
|
scope = "html";
|
|
var c = editor.getCursorPosition();
|
|
var state = editor.session.getState(c.row);
|
|
if (typeof state === "object") {
|
|
state = state[0];
|
|
}
|
|
if (state.substring) {
|
|
if (state.substring(0, 3) == "js-")
|
|
scope = "javascript";
|
|
else if (state.substring(0, 4) == "css-")
|
|
scope = "css";
|
|
else if (state.substring(0, 4) == "php-")
|
|
scope = "php";
|
|
}
|
|
}
|
|
|
|
return scope;
|
|
};
|
|
|
|
this.getActiveScopes = function(editor) {
|
|
var scope = this.$getScope(editor);
|
|
var scopes = [scope];
|
|
var snippetMap = this.snippetMap;
|
|
if (snippetMap[scope] && snippetMap[scope].includeScopes) {
|
|
scopes.push.apply(scopes, snippetMap[scope].includeScopes);
|
|
}
|
|
scopes.push("_");
|
|
return scopes;
|
|
};
|
|
|
|
this.expandWithTab = function(editor, options) {
|
|
var self = this;
|
|
var result = editor.forEachSelection(function() {
|
|
return self.expandSnippetForSelection(editor, options);
|
|
}, null, {keepOrder: true});
|
|
if (result && editor.tabstopManager)
|
|
editor.tabstopManager.tabNext();
|
|
return result;
|
|
};
|
|
|
|
this.expandSnippetForSelection = function(editor, options) {
|
|
var cursor = editor.getCursorPosition();
|
|
var line = editor.session.getLine(cursor.row);
|
|
var before = line.substring(0, cursor.column);
|
|
var after = line.substr(cursor.column);
|
|
|
|
var snippetMap = this.snippetMap;
|
|
var snippet;
|
|
this.getActiveScopes(editor).some(function(scope) {
|
|
var snippets = snippetMap[scope];
|
|
if (snippets)
|
|
snippet = this.findMatchingSnippet(snippets, before, after);
|
|
return !!snippet;
|
|
}, this);
|
|
if (!snippet)
|
|
return false;
|
|
if (options && options.dryRun)
|
|
return true;
|
|
editor.session.doc.removeInLine(cursor.row,
|
|
cursor.column - snippet.replaceBefore.length,
|
|
cursor.column + snippet.replaceAfter.length
|
|
);
|
|
|
|
this.variables.M__ = snippet.matchBefore;
|
|
this.variables.T__ = snippet.matchAfter;
|
|
this.insertSnippetForSelection(editor, snippet.content);
|
|
|
|
this.variables.M__ = this.variables.T__ = null;
|
|
return true;
|
|
};
|
|
|
|
this.findMatchingSnippet = function(snippetList, before, after) {
|
|
for (var i = snippetList.length; i--;) {
|
|
var s = snippetList[i];
|
|
if (s.startRe && !s.startRe.test(before))
|
|
continue;
|
|
if (s.endRe && !s.endRe.test(after))
|
|
continue;
|
|
if (!s.startRe && !s.endRe)
|
|
continue;
|
|
|
|
s.matchBefore = s.startRe ? s.startRe.exec(before) : [""];
|
|
s.matchAfter = s.endRe ? s.endRe.exec(after) : [""];
|
|
s.replaceBefore = s.triggerRe ? s.triggerRe.exec(before)[0] : "";
|
|
s.replaceAfter = s.endTriggerRe ? s.endTriggerRe.exec(after)[0] : "";
|
|
return s;
|
|
}
|
|
};
|
|
|
|
this.snippetMap = {};
|
|
this.snippetNameMap = {};
|
|
this.register = function(snippets, scope) {
|
|
var snippetMap = this.snippetMap;
|
|
var snippetNameMap = this.snippetNameMap;
|
|
var self = this;
|
|
|
|
if (!snippets)
|
|
snippets = [];
|
|
|
|
function wrapRegexp(src) {
|
|
if (src && !/^\^?\(.*\)\$?$|^\\b$/.test(src))
|
|
src = "(?:" + src + ")";
|
|
|
|
return src || "";
|
|
}
|
|
function guardedRegexp(re, guard, opening) {
|
|
re = wrapRegexp(re);
|
|
guard = wrapRegexp(guard);
|
|
if (opening) {
|
|
re = guard + re;
|
|
if (re && re[re.length - 1] != "$")
|
|
re = re + "$";
|
|
} else {
|
|
re = re + guard;
|
|
if (re && re[0] != "^")
|
|
re = "^" + re;
|
|
}
|
|
return new RegExp(re);
|
|
}
|
|
|
|
function addSnippet(s) {
|
|
if (!s.scope)
|
|
s.scope = scope || "_";
|
|
scope = s.scope;
|
|
if (!snippetMap[scope]) {
|
|
snippetMap[scope] = [];
|
|
snippetNameMap[scope] = {};
|
|
}
|
|
|
|
var map = snippetNameMap[scope];
|
|
if (s.name) {
|
|
var old = map[s.name];
|
|
if (old)
|
|
self.unregister(old);
|
|
map[s.name] = s;
|
|
}
|
|
snippetMap[scope].push(s);
|
|
|
|
if (s.tabTrigger && !s.trigger) {
|
|
if (!s.guard && /^\w/.test(s.tabTrigger))
|
|
s.guard = "\\b";
|
|
s.trigger = lang.escapeRegExp(s.tabTrigger);
|
|
}
|
|
|
|
s.startRe = guardedRegexp(s.trigger, s.guard, true);
|
|
s.triggerRe = new RegExp(s.trigger, "", true);
|
|
|
|
s.endRe = guardedRegexp(s.endTrigger, s.endGuard, true);
|
|
s.endTriggerRe = new RegExp(s.endTrigger, "", true);
|
|
}
|
|
|
|
if (snippets && snippets.content)
|
|
addSnippet(snippets);
|
|
else if (Array.isArray(snippets))
|
|
snippets.forEach(addSnippet);
|
|
|
|
this._signal("registerSnippets", {scope: scope});
|
|
};
|
|
this.unregister = function(snippets, scope) {
|
|
var snippetMap = this.snippetMap;
|
|
var snippetNameMap = this.snippetNameMap;
|
|
|
|
function removeSnippet(s) {
|
|
var nameMap = snippetNameMap[s.scope||scope];
|
|
if (nameMap && nameMap[s.name]) {
|
|
delete nameMap[s.name];
|
|
var map = snippetMap[s.scope||scope];
|
|
var i = map && map.indexOf(s);
|
|
if (i >= 0)
|
|
map.splice(i, 1);
|
|
}
|
|
}
|
|
if (snippets.content)
|
|
removeSnippet(snippets);
|
|
else if (Array.isArray(snippets))
|
|
snippets.forEach(removeSnippet);
|
|
};
|
|
this.parseSnippetFile = function(str) {
|
|
str = str.replace(/\r/g, "");
|
|
var list = [], snippet = {};
|
|
var re = /^#.*|^({[\s\S]*})\s*$|^(\S+) (.*)$|^((?:\n*\t.*)+)/gm;
|
|
var m;
|
|
while (m = re.exec(str)) {
|
|
if (m[1]) {
|
|
try {
|
|
snippet = JSON.parse(m[1]);
|
|
list.push(snippet);
|
|
} catch (e) {}
|
|
} if (m[4]) {
|
|
snippet.content = m[4].replace(/^\t/gm, "");
|
|
list.push(snippet);
|
|
snippet = {};
|
|
} else {
|
|
var key = m[2], val = m[3];
|
|
if (key == "regex") {
|
|
var guardRe = /\/((?:[^\/\\]|\\.)*)|$/g;
|
|
snippet.guard = guardRe.exec(val)[1];
|
|
snippet.trigger = guardRe.exec(val)[1];
|
|
snippet.endTrigger = guardRe.exec(val)[1];
|
|
snippet.endGuard = guardRe.exec(val)[1];
|
|
} else if (key == "snippet") {
|
|
snippet.tabTrigger = val.match(/^\S*/)[0];
|
|
if (!snippet.name)
|
|
snippet.name = val;
|
|
} else {
|
|
snippet[key] = val;
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
};
|
|
this.getSnippetByName = function(name, editor) {
|
|
var snippetMap = this.snippetNameMap;
|
|
var snippet;
|
|
this.getActiveScopes(editor).some(function(scope) {
|
|
var snippets = snippetMap[scope];
|
|
if (snippets)
|
|
snippet = snippets[name];
|
|
return !!snippet;
|
|
}, this);
|
|
return snippet;
|
|
};
|
|
|
|
}).call(SnippetManager.prototype);
|
|
|
|
|
|
var TabstopManager = function(editor) {
|
|
if (editor.tabstopManager)
|
|
return editor.tabstopManager;
|
|
editor.tabstopManager = this;
|
|
this.$onChange = this.onChange.bind(this);
|
|
this.$onChangeSelection = lang.delayedCall(this.onChangeSelection.bind(this)).schedule;
|
|
this.$onChangeSession = this.onChangeSession.bind(this);
|
|
this.$onAfterExec = this.onAfterExec.bind(this);
|
|
this.attach(editor);
|
|
};
|
|
(function() {
|
|
this.attach = function(editor) {
|
|
this.index = 0;
|
|
this.ranges = [];
|
|
this.tabstops = [];
|
|
this.$openTabstops = null;
|
|
this.selectedTabstop = null;
|
|
|
|
this.editor = editor;
|
|
this.editor.on("change", this.$onChange);
|
|
this.editor.on("changeSelection", this.$onChangeSelection);
|
|
this.editor.on("changeSession", this.$onChangeSession);
|
|
this.editor.commands.on("afterExec", this.$onAfterExec);
|
|
this.editor.keyBinding.addKeyboardHandler(this.keyboardHandler);
|
|
};
|
|
this.detach = function() {
|
|
this.tabstops.forEach(this.removeTabstopMarkers, this);
|
|
this.ranges = null;
|
|
this.tabstops = null;
|
|
this.selectedTabstop = null;
|
|
this.editor.removeListener("change", this.$onChange);
|
|
this.editor.removeListener("changeSelection", this.$onChangeSelection);
|
|
this.editor.removeListener("changeSession", this.$onChangeSession);
|
|
this.editor.commands.removeListener("afterExec", this.$onAfterExec);
|
|
this.editor.keyBinding.removeKeyboardHandler(this.keyboardHandler);
|
|
this.editor.tabstopManager = null;
|
|
this.editor = null;
|
|
};
|
|
|
|
this.onChange = function(e) {
|
|
var changeRange = e.data.range;
|
|
var isRemove = e.data.action[0] == "r";
|
|
var start = changeRange.start;
|
|
var end = changeRange.end;
|
|
var startRow = start.row;
|
|
var endRow = end.row;
|
|
var lineDif = endRow - startRow;
|
|
var colDiff = end.column - start.column;
|
|
|
|
if (isRemove) {
|
|
lineDif = -lineDif;
|
|
colDiff = -colDiff;
|
|
}
|
|
if (!this.$inChange && isRemove) {
|
|
var ts = this.selectedTabstop;
|
|
var changedOutside = ts && !ts.some(function(r) {
|
|
return comparePoints(r.start, start) <= 0 && comparePoints(r.end, end) >= 0;
|
|
});
|
|
if (changedOutside)
|
|
return this.detach();
|
|
}
|
|
var ranges = this.ranges;
|
|
for (var i = 0; i < ranges.length; i++) {
|
|
var r = ranges[i];
|
|
if (r.end.row < start.row)
|
|
continue;
|
|
|
|
if (isRemove && comparePoints(start, r.start) < 0 && comparePoints(end, r.end) > 0) {
|
|
this.removeRange(r);
|
|
i--;
|
|
continue;
|
|
}
|
|
|
|
if (r.start.row == startRow && r.start.column > start.column)
|
|
r.start.column += colDiff;
|
|
if (r.end.row == startRow && r.end.column >= start.column)
|
|
r.end.column += colDiff;
|
|
if (r.start.row >= startRow)
|
|
r.start.row += lineDif;
|
|
if (r.end.row >= startRow)
|
|
r.end.row += lineDif;
|
|
|
|
if (comparePoints(r.start, r.end) > 0)
|
|
this.removeRange(r);
|
|
}
|
|
if (!ranges.length)
|
|
this.detach();
|
|
};
|
|
this.updateLinkedFields = function() {
|
|
var ts = this.selectedTabstop;
|
|
if (!ts || !ts.hasLinkedRanges)
|
|
return;
|
|
this.$inChange = true;
|
|
var session = this.editor.session;
|
|
var text = session.getTextRange(ts.firstNonLinked);
|
|
for (var i = ts.length; i--;) {
|
|
var range = ts[i];
|
|
if (!range.linked)
|
|
continue;
|
|
var fmt = exports.snippetManager.tmStrFormat(text, range.original);
|
|
session.replace(range, fmt);
|
|
}
|
|
this.$inChange = false;
|
|
};
|
|
this.onAfterExec = function(e) {
|
|
if (e.command && !e.command.readOnly)
|
|
this.updateLinkedFields();
|
|
};
|
|
this.onChangeSelection = function() {
|
|
if (!this.editor)
|
|
return;
|
|
var lead = this.editor.selection.lead;
|
|
var anchor = this.editor.selection.anchor;
|
|
var isEmpty = this.editor.selection.isEmpty();
|
|
for (var i = this.ranges.length; i--;) {
|
|
if (this.ranges[i].linked)
|
|
continue;
|
|
var containsLead = this.ranges[i].contains(lead.row, lead.column);
|
|
var containsAnchor = isEmpty || this.ranges[i].contains(anchor.row, anchor.column);
|
|
if (containsLead && containsAnchor)
|
|
return;
|
|
}
|
|
this.detach();
|
|
};
|
|
this.onChangeSession = function() {
|
|
this.detach();
|
|
};
|
|
this.tabNext = function(dir) {
|
|
var max = this.tabstops.length;
|
|
var index = this.index + (dir || 1);
|
|
index = Math.min(Math.max(index, 1), max);
|
|
if (index == max)
|
|
index = 0;
|
|
this.selectTabstop(index);
|
|
if (index === 0)
|
|
this.detach();
|
|
};
|
|
this.selectTabstop = function(index) {
|
|
this.$openTabstops = null;
|
|
var ts = this.tabstops[this.index];
|
|
if (ts)
|
|
this.addTabstopMarkers(ts);
|
|
this.index = index;
|
|
ts = this.tabstops[this.index];
|
|
if (!ts || !ts.length)
|
|
return;
|
|
|
|
this.selectedTabstop = ts;
|
|
if (!this.editor.inVirtualSelectionMode) {
|
|
var sel = this.editor.multiSelect;
|
|
sel.toSingleRange(ts.firstNonLinked.clone());
|
|
for (var i = ts.length; i--;) {
|
|
if (ts.hasLinkedRanges && ts[i].linked)
|
|
continue;
|
|
sel.addRange(ts[i].clone(), true);
|
|
}
|
|
if (sel.ranges[0])
|
|
sel.addRange(sel.ranges[0].clone());
|
|
} else {
|
|
this.editor.selection.setRange(ts.firstNonLinked);
|
|
}
|
|
|
|
this.editor.keyBinding.addKeyboardHandler(this.keyboardHandler);
|
|
};
|
|
this.addTabstops = function(tabstops, start, end) {
|
|
if (!this.$openTabstops)
|
|
this.$openTabstops = [];
|
|
if (!tabstops[0]) {
|
|
var p = Range.fromPoints(end, end);
|
|
moveRelative(p.start, start);
|
|
moveRelative(p.end, start);
|
|
tabstops[0] = [p];
|
|
tabstops[0].index = 0;
|
|
}
|
|
|
|
var i = this.index;
|
|
var arg = [i + 1, 0];
|
|
var ranges = this.ranges;
|
|
tabstops.forEach(function(ts, index) {
|
|
var dest = this.$openTabstops[index] || ts;
|
|
|
|
for (var i = ts.length; i--;) {
|
|
var p = ts[i];
|
|
var range = Range.fromPoints(p.start, p.end || p.start);
|
|
movePoint(range.start, start);
|
|
movePoint(range.end, start);
|
|
range.original = p;
|
|
range.tabstop = dest;
|
|
ranges.push(range);
|
|
if (dest != ts)
|
|
dest.unshift(range);
|
|
else
|
|
dest[i] = range;
|
|
if (p.fmtString) {
|
|
range.linked = true;
|
|
dest.hasLinkedRanges = true;
|
|
} else if (!dest.firstNonLinked)
|
|
dest.firstNonLinked = range;
|
|
}
|
|
if (!dest.firstNonLinked)
|
|
dest.hasLinkedRanges = false;
|
|
if (dest === ts) {
|
|
arg.push(dest);
|
|
this.$openTabstops[index] = dest;
|
|
}
|
|
this.addTabstopMarkers(dest);
|
|
}, this);
|
|
|
|
if (arg.length > 2) {
|
|
if (this.tabstops.length)
|
|
arg.push(arg.splice(2, 1)[0]);
|
|
this.tabstops.splice.apply(this.tabstops, arg);
|
|
}
|
|
};
|
|
|
|
this.addTabstopMarkers = function(ts) {
|
|
var session = this.editor.session;
|
|
ts.forEach(function(range) {
|
|
if (!range.markerId)
|
|
range.markerId = session.addMarker(range, "ace_snippet-marker", "text");
|
|
});
|
|
};
|
|
this.removeTabstopMarkers = function(ts) {
|
|
var session = this.editor.session;
|
|
ts.forEach(function(range) {
|
|
session.removeMarker(range.markerId);
|
|
range.markerId = null;
|
|
});
|
|
};
|
|
this.removeRange = function(range) {
|
|
var i = range.tabstop.indexOf(range);
|
|
range.tabstop.splice(i, 1);
|
|
i = this.ranges.indexOf(range);
|
|
this.ranges.splice(i, 1);
|
|
this.editor.session.removeMarker(range.markerId);
|
|
if (!range.tabstop.length) {
|
|
i = this.tabstops.indexOf(range.tabstop);
|
|
if (i != -1)
|
|
this.tabstops.splice(i, 1);
|
|
if (!this.tabstops.length)
|
|
this.detach();
|
|
}
|
|
};
|
|
|
|
this.keyboardHandler = new HashHandler();
|
|
this.keyboardHandler.bindKeys({
|
|
"Tab": function(ed) {
|
|
if (exports.snippetManager && exports.snippetManager.expandWithTab(ed)) {
|
|
return;
|
|
}
|
|
|
|
ed.tabstopManager.tabNext(1);
|
|
},
|
|
"Shift-Tab": function(ed) {
|
|
ed.tabstopManager.tabNext(-1);
|
|
},
|
|
"Esc": function(ed) {
|
|
ed.tabstopManager.detach();
|
|
},
|
|
"Return": function(ed) {
|
|
return false;
|
|
}
|
|
});
|
|
}).call(TabstopManager.prototype);
|
|
|
|
|
|
|
|
var changeTracker = {};
|
|
changeTracker.onChange = Anchor.prototype.onChange;
|
|
changeTracker.setPosition = function(row, column) {
|
|
this.pos.row = row;
|
|
this.pos.column = column;
|
|
};
|
|
changeTracker.update = function(pos, delta, $insertRight) {
|
|
this.$insertRight = $insertRight;
|
|
this.pos = pos;
|
|
this.onChange(delta);
|
|
};
|
|
|
|
var movePoint = function(point, diff) {
|
|
if (point.row == 0)
|
|
point.column += diff.column;
|
|
point.row += diff.row;
|
|
};
|
|
|
|
var moveRelative = function(point, start) {
|
|
if (point.row == start.row)
|
|
point.column -= start.column;
|
|
point.row -= start.row;
|
|
};
|
|
|
|
|
|
require("./lib/dom").importCssString("\
|
|
.ace_snippet-marker {\
|
|
-moz-box-sizing: border-box;\
|
|
box-sizing: border-box;\
|
|
background: rgba(194, 193, 208, 0.09);\
|
|
border: 1px dotted rgba(211, 208, 235, 0.62);\
|
|
position: absolute;\
|
|
}");
|
|
|
|
exports.snippetManager = new SnippetManager();
|
|
|
|
|
|
var Editor = require("./editor").Editor;
|
|
(function() {
|
|
this.insertSnippet = function(content, options) {
|
|
return exports.snippetManager.insertSnippet(this, content, options);
|
|
};
|
|
this.expandSnippet = function(options) {
|
|
return exports.snippetManager.expandWithTab(this, options);
|
|
};
|
|
}).call(Editor.prototype);
|
|
|
|
});
|
|
|
|
define("ace/ext/emmet",["require","exports","module","ace/keyboard/hash_handler","ace/editor","ace/snippets","ace/range","resources","resources","range","tabStops","resources","utils","actions","ace/config"], function(require, exports, module) {
|
|
"use strict";
|
|
var HashHandler = require("ace/keyboard/hash_handler").HashHandler;
|
|
var Editor = require("ace/editor").Editor;
|
|
var snippetManager = require("ace/snippets").snippetManager;
|
|
var Range = require("ace/range").Range;
|
|
var emmet;
|
|
|
|
Editor.prototype.indexToPosition = function(index) {
|
|
return this.session.doc.indexToPosition(index);
|
|
};
|
|
|
|
Editor.prototype.positionToIndex = function(pos) {
|
|
return this.session.doc.positionToIndex(pos);
|
|
};
|
|
function AceEmmetEditor() {}
|
|
|
|
AceEmmetEditor.prototype = {
|
|
setupContext: function(editor) {
|
|
this.ace = editor;
|
|
this.indentation = editor.session.getTabString();
|
|
if (!emmet)
|
|
emmet = window.emmet;
|
|
emmet.require("resources").setVariable("indentation", this.indentation);
|
|
this.$syntax = null;
|
|
this.$syntax = this.getSyntax();
|
|
},
|
|
getSelectionRange: function() {
|
|
var range = this.ace.getSelectionRange();
|
|
return {
|
|
start: this.ace.positionToIndex(range.start),
|
|
end: this.ace.positionToIndex(range.end)
|
|
};
|
|
},
|
|
createSelection: function(start, end) {
|
|
this.ace.selection.setRange({
|
|
start: this.ace.indexToPosition(start),
|
|
end: this.ace.indexToPosition(end)
|
|
});
|
|
},
|
|
getCurrentLineRange: function() {
|
|
var row = this.ace.getCursorPosition().row;
|
|
var lineLength = this.ace.session.getLine(row).length;
|
|
var index = this.ace.positionToIndex({row: row, column: 0});
|
|
return {
|
|
start: index,
|
|
end: index + lineLength
|
|
};
|
|
},
|
|
getCaretPos: function(){
|
|
var pos = this.ace.getCursorPosition();
|
|
return this.ace.positionToIndex(pos);
|
|
},
|
|
setCaretPos: function(index){
|
|
var pos = this.ace.indexToPosition(index);
|
|
this.ace.selection.moveToPosition(pos);
|
|
},
|
|
getCurrentLine: function() {
|
|
var row = this.ace.getCursorPosition().row;
|
|
return this.ace.session.getLine(row);
|
|
},
|
|
replaceContent: function(value, start, end, noIndent) {
|
|
if (end == null)
|
|
end = start == null ? this.getContent().length : start;
|
|
if (start == null)
|
|
start = 0;
|
|
|
|
var editor = this.ace;
|
|
var range = Range.fromPoints(editor.indexToPosition(start), editor.indexToPosition(end));
|
|
editor.session.remove(range);
|
|
|
|
range.end = range.start;
|
|
|
|
value = this.$updateTabstops(value);
|
|
snippetManager.insertSnippet(editor, value)
|
|
},
|
|
getContent: function(){
|
|
return this.ace.getValue();
|
|
},
|
|
getSyntax: function() {
|
|
if (this.$syntax)
|
|
return this.$syntax;
|
|
var syntax = this.ace.session.$modeId.split("/").pop();
|
|
if (syntax == "html" || syntax == "php") {
|
|
var cursor = this.ace.getCursorPosition();
|
|
var state = this.ace.session.getState(cursor.row);
|
|
if (typeof state != "string")
|
|
state = state[0];
|
|
if (state) {
|
|
state = state.split("-");
|
|
if (state.length > 1)
|
|
syntax = state[0];
|
|
else if (syntax == "php")
|
|
syntax = "html";
|
|
}
|
|
}
|
|
return syntax;
|
|
},
|
|
getProfileName: function() {
|
|
switch(this.getSyntax()) {
|
|
case "css": return "css";
|
|
case "xml":
|
|
case "xsl":
|
|
return "xml";
|
|
case "html":
|
|
var profile = emmet.require("resources").getVariable("profile");
|
|
if (!profile)
|
|
profile = this.ace.session.getLines(0,2).join("").search(/<!DOCTYPE[^>]+XHTML/i) != -1 ? "xhtml": "html";
|
|
return profile;
|
|
}
|
|
return "xhtml";
|
|
},
|
|
prompt: function(title) {
|
|
return prompt(title);
|
|
},
|
|
getSelection: function() {
|
|
return this.ace.session.getTextRange();
|
|
},
|
|
getFilePath: function() {
|
|
return "";
|
|
},
|
|
$updateTabstops: function(value) {
|
|
var base = 1000;
|
|
var zeroBase = 0;
|
|
var lastZero = null;
|
|
var range = emmet.require('range');
|
|
var ts = emmet.require('tabStops');
|
|
var settings = emmet.require('resources').getVocabulary("user");
|
|
var tabstopOptions = {
|
|
tabstop: function(data) {
|
|
var group = parseInt(data.group, 10);
|
|
var isZero = group === 0;
|
|
if (isZero)
|
|
group = ++zeroBase;
|
|
else
|
|
group += base;
|
|
|
|
var placeholder = data.placeholder;
|
|
if (placeholder) {
|
|
placeholder = ts.processText(placeholder, tabstopOptions);
|
|
}
|
|
|
|
var result = '${' + group + (placeholder ? ':' + placeholder : '') + '}';
|
|
|
|
if (isZero) {
|
|
lastZero = range.create(data.start, result);
|
|
}
|
|
|
|
return result
|
|
},
|
|
escape: function(ch) {
|
|
if (ch == '$') return '\\$';
|
|
if (ch == '\\') return '\\\\';
|
|
return ch;
|
|
}
|
|
};
|
|
|
|
value = ts.processText(value, tabstopOptions);
|
|
|
|
if (settings.variables['insert_final_tabstop'] && !/\$\{0\}$/.test(value)) {
|
|
value += '${0}';
|
|
} else if (lastZero) {
|
|
value = emmet.require('utils').replaceSubstring(value, '${0}', lastZero);
|
|
}
|
|
|
|
return value;
|
|
}
|
|
};
|
|
|
|
|
|
var keymap = {
|
|
expand_abbreviation: {"mac": "ctrl+alt+e", "win": "alt+e"},
|
|
match_pair_outward: {"mac": "ctrl+d", "win": "ctrl+,"},
|
|
match_pair_inward: {"mac": "ctrl+j", "win": "ctrl+shift+0"},
|
|
matching_pair: {"mac": "ctrl+alt+j", "win": "alt+j"},
|
|
next_edit_point: "alt+right",
|
|
prev_edit_point: "alt+left",
|
|
toggle_comment: {"mac": "command+/", "win": "ctrl+/"},
|
|
split_join_tag: {"mac": "shift+command+'", "win": "shift+ctrl+`"},
|
|
remove_tag: {"mac": "command+'", "win": "shift+ctrl+;"},
|
|
evaluate_math_expression: {"mac": "shift+command+y", "win": "shift+ctrl+y"},
|
|
increment_number_by_1: "ctrl+up",
|
|
decrement_number_by_1: "ctrl+down",
|
|
increment_number_by_01: "alt+up",
|
|
decrement_number_by_01: "alt+down",
|
|
increment_number_by_10: {"mac": "alt+command+up", "win": "shift+alt+up"},
|
|
decrement_number_by_10: {"mac": "alt+command+down", "win": "shift+alt+down"},
|
|
select_next_item: {"mac": "shift+command+.", "win": "shift+ctrl+."},
|
|
select_previous_item: {"mac": "shift+command+,", "win": "shift+ctrl+,"},
|
|
reflect_css_value: {"mac": "shift+command+r", "win": "shift+ctrl+r"},
|
|
|
|
encode_decode_data_url: {"mac": "shift+ctrl+d", "win": "ctrl+'"},
|
|
expand_abbreviation_with_tab: "Tab",
|
|
wrap_with_abbreviation: {"mac": "shift+ctrl+a", "win": "shift+ctrl+a"}
|
|
};
|
|
|
|
var editorProxy = new AceEmmetEditor();
|
|
exports.commands = new HashHandler();
|
|
exports.runEmmetCommand = function(editor) {
|
|
editorProxy.setupContext(editor);
|
|
if (editorProxy.getSyntax() == "php")
|
|
return false;
|
|
var actions = emmet.require("actions");
|
|
|
|
if (this.action == "expand_abbreviation_with_tab") {
|
|
if (!editor.selection.isEmpty())
|
|
return false;
|
|
}
|
|
|
|
if (this.action == "wrap_with_abbreviation") {
|
|
return setTimeout(function() {
|
|
actions.run("wrap_with_abbreviation", editorProxy);
|
|
}, 0);
|
|
}
|
|
|
|
try {
|
|
var result = actions.run(this.action, editorProxy);
|
|
} catch(e) {
|
|
editor._signal("changeStatus", typeof e == "string" ? e : e.message);
|
|
console.log(e);
|
|
result = false
|
|
}
|
|
return result;
|
|
};
|
|
|
|
for (var command in keymap) {
|
|
exports.commands.addCommand({
|
|
name: "emmet:" + command,
|
|
action: command,
|
|
bindKey: keymap[command],
|
|
exec: exports.runEmmetCommand,
|
|
multiSelectAction: "forEach"
|
|
});
|
|
}
|
|
|
|
var onChangeMode = function(e, target) {
|
|
var editor = target;
|
|
if (!editor)
|
|
return;
|
|
var modeId = editor.session.$modeId;
|
|
var enabled = modeId && /css|less|scss|sass|stylus|html|php/.test(modeId);
|
|
if (e.enableEmmet === false)
|
|
enabled = false;
|
|
if (enabled)
|
|
editor.keyBinding.addKeyboardHandler(exports.commands);
|
|
else
|
|
editor.keyBinding.removeKeyboardHandler(exports.commands);
|
|
};
|
|
|
|
|
|
exports.AceEmmetEditor = AceEmmetEditor;
|
|
require("ace/config").defineOptions(Editor.prototype, "editor", {
|
|
enableEmmet: {
|
|
set: function(val) {
|
|
this[val ? "on" : "removeListener"]("changeMode", onChangeMode);
|
|
onChangeMode({enableEmmet: !!val}, this);
|
|
},
|
|
value: true
|
|
}
|
|
});
|
|
|
|
|
|
exports.setCore = function(e) {emmet = e;};
|
|
});
|
|
|
|
define("ace/autocomplete/popup",["require","exports","module","ace/edit_session","ace/virtual_renderer","ace/editor","ace/range","ace/lib/event","ace/lib/lang","ace/lib/dom"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var EditSession = require("../edit_session").EditSession;
|
|
var Renderer = require("../virtual_renderer").VirtualRenderer;
|
|
var Editor = require("../editor").Editor;
|
|
var Range = require("../range").Range;
|
|
var event = require("../lib/event");
|
|
var lang = require("../lib/lang");
|
|
var dom = require("../lib/dom");
|
|
|
|
var $singleLineEditor = function(el) {
|
|
var renderer = new Renderer(el);
|
|
|
|
renderer.$maxLines = 4;
|
|
|
|
var editor = new Editor(renderer);
|
|
|
|
editor.setHighlightActiveLine(false);
|
|
editor.setShowPrintMargin(false);
|
|
editor.renderer.setShowGutter(false);
|
|
editor.renderer.setHighlightGutterLine(false);
|
|
|
|
editor.$mouseHandler.$focusWaitTimout = 0;
|
|
editor.$highlightTagPending = true;
|
|
|
|
return editor;
|
|
};
|
|
|
|
var AcePopup = function(parentNode) {
|
|
var el = dom.createElement("div");
|
|
var popup = new $singleLineEditor(el);
|
|
|
|
if (parentNode)
|
|
parentNode.appendChild(el);
|
|
el.style.display = "none";
|
|
popup.renderer.content.style.cursor = "default";
|
|
popup.renderer.setStyle("ace_autocomplete");
|
|
|
|
popup.setOption("displayIndentGuides", false);
|
|
popup.setOption("dragDelay", 150);
|
|
|
|
var noop = function(){};
|
|
|
|
popup.focus = noop;
|
|
popup.$isFocused = true;
|
|
|
|
popup.renderer.$cursorLayer.restartTimer = noop;
|
|
popup.renderer.$cursorLayer.element.style.opacity = 0;
|
|
|
|
popup.renderer.$maxLines = 8;
|
|
popup.renderer.$keepTextAreaAtCursor = false;
|
|
|
|
popup.setHighlightActiveLine(false);
|
|
popup.session.highlight("");
|
|
popup.session.$searchHighlight.clazz = "ace_highlight-marker";
|
|
|
|
popup.on("mousedown", function(e) {
|
|
var pos = e.getDocumentPosition();
|
|
popup.selection.moveToPosition(pos);
|
|
selectionMarker.start.row = selectionMarker.end.row = pos.row;
|
|
e.stop();
|
|
});
|
|
|
|
var lastMouseEvent;
|
|
var hoverMarker = new Range(-1,0,-1,Infinity);
|
|
var selectionMarker = new Range(-1,0,-1,Infinity);
|
|
selectionMarker.id = popup.session.addMarker(selectionMarker, "ace_active-line", "fullLine");
|
|
popup.setSelectOnHover = function(val) {
|
|
if (!val) {
|
|
hoverMarker.id = popup.session.addMarker(hoverMarker, "ace_line-hover", "fullLine");
|
|
} else if (hoverMarker.id) {
|
|
popup.session.removeMarker(hoverMarker.id);
|
|
hoverMarker.id = null;
|
|
}
|
|
};
|
|
popup.setSelectOnHover(false);
|
|
popup.on("mousemove", function(e) {
|
|
if (!lastMouseEvent) {
|
|
lastMouseEvent = e;
|
|
return;
|
|
}
|
|
if (lastMouseEvent.x == e.x && lastMouseEvent.y == e.y) {
|
|
return;
|
|
}
|
|
lastMouseEvent = e;
|
|
lastMouseEvent.scrollTop = popup.renderer.scrollTop;
|
|
var row = lastMouseEvent.getDocumentPosition().row;
|
|
if (hoverMarker.start.row != row) {
|
|
if (!hoverMarker.id)
|
|
popup.setRow(row);
|
|
setHoverMarker(row);
|
|
}
|
|
});
|
|
popup.renderer.on("beforeRender", function() {
|
|
if (lastMouseEvent && hoverMarker.start.row != -1) {
|
|
lastMouseEvent.$pos = null;
|
|
var row = lastMouseEvent.getDocumentPosition().row;
|
|
if (!hoverMarker.id)
|
|
popup.setRow(row);
|
|
setHoverMarker(row, true);
|
|
}
|
|
});
|
|
popup.renderer.on("afterRender", function() {
|
|
var row = popup.getRow();
|
|
var t = popup.renderer.$textLayer;
|
|
var selected = t.element.childNodes[row - t.config.firstRow];
|
|
if (selected == t.selectedNode)
|
|
return;
|
|
if (t.selectedNode)
|
|
dom.removeCssClass(t.selectedNode, "ace_selected");
|
|
t.selectedNode = selected;
|
|
if (selected)
|
|
dom.addCssClass(selected, "ace_selected");
|
|
});
|
|
var hideHoverMarker = function() { setHoverMarker(-1) };
|
|
var setHoverMarker = function(row, suppressRedraw) {
|
|
if (row !== hoverMarker.start.row) {
|
|
hoverMarker.start.row = hoverMarker.end.row = row;
|
|
if (!suppressRedraw)
|
|
popup.session._emit("changeBackMarker");
|
|
popup._emit("changeHoverMarker");
|
|
}
|
|
};
|
|
popup.getHoveredRow = function() {
|
|
return hoverMarker.start.row;
|
|
};
|
|
|
|
event.addListener(popup.container, "mouseout", hideHoverMarker);
|
|
popup.on("hide", hideHoverMarker);
|
|
popup.on("changeSelection", hideHoverMarker);
|
|
|
|
popup.session.doc.getLength = function() {
|
|
return popup.data.length;
|
|
};
|
|
popup.session.doc.getLine = function(i) {
|
|
var data = popup.data[i];
|
|
if (typeof data == "string")
|
|
return data;
|
|
return (data && data.value) || "";
|
|
};
|
|
|
|
var bgTokenizer = popup.session.bgTokenizer;
|
|
bgTokenizer.$tokenizeRow = function(row) {
|
|
var data = popup.data[row];
|
|
var tokens = [];
|
|
if (!data)
|
|
return tokens;
|
|
if (typeof data == "string")
|
|
data = {value: data};
|
|
if (!data.caption)
|
|
data.caption = data.value || data.name;
|
|
|
|
var last = -1;
|
|
var flag, c;
|
|
for (var i = 0; i < data.caption.length; i++) {
|
|
c = data.caption[i];
|
|
flag = data.matchMask & (1 << i) ? 1 : 0;
|
|
if (last !== flag) {
|
|
tokens.push({type: data.className || "" + ( flag ? "completion-highlight" : ""), value: c});
|
|
last = flag;
|
|
} else {
|
|
tokens[tokens.length - 1].value += c;
|
|
}
|
|
}
|
|
|
|
if (data.meta) {
|
|
var maxW = popup.renderer.$size.scrollerWidth / popup.renderer.layerConfig.characterWidth;
|
|
if (data.meta.length + data.caption.length < maxW - 2)
|
|
tokens.push({type: "rightAlignedText", value: data.meta});
|
|
}
|
|
return tokens;
|
|
};
|
|
bgTokenizer.$updateOnChange = noop;
|
|
bgTokenizer.start = noop;
|
|
|
|
popup.session.$computeWidth = function() {
|
|
return this.screenWidth = 0;
|
|
};
|
|
popup.isOpen = false;
|
|
popup.isTopdown = false;
|
|
|
|
popup.data = [];
|
|
popup.setData = function(list) {
|
|
popup.data = list || [];
|
|
popup.setValue(lang.stringRepeat("\n", list.length), -1);
|
|
popup.setRow(0);
|
|
};
|
|
popup.getData = function(row) {
|
|
return popup.data[row];
|
|
};
|
|
|
|
popup.getRow = function() {
|
|
return selectionMarker.start.row;
|
|
};
|
|
popup.setRow = function(line) {
|
|
line = Math.max(-1, Math.min(this.data.length, line));
|
|
if (selectionMarker.start.row != line) {
|
|
popup.selection.clearSelection();
|
|
selectionMarker.start.row = selectionMarker.end.row = line || 0;
|
|
popup.session._emit("changeBackMarker");
|
|
popup.moveCursorTo(line || 0, 0);
|
|
if (popup.isOpen)
|
|
popup._signal("select");
|
|
}
|
|
};
|
|
|
|
popup.on("changeSelection", function() {
|
|
if (popup.isOpen)
|
|
popup.setRow(popup.selection.lead.row);
|
|
});
|
|
|
|
popup.hide = function() {
|
|
this.container.style.display = "none";
|
|
this._signal("hide");
|
|
popup.isOpen = false;
|
|
};
|
|
popup.show = function(pos, lineHeight, topdownOnly) {
|
|
var el = this.container;
|
|
var screenHeight = window.innerHeight;
|
|
var screenWidth = window.innerWidth;
|
|
var renderer = this.renderer;
|
|
var maxH = renderer.$maxLines * lineHeight * 1.4;
|
|
var top = pos.top + this.$borderSize;
|
|
if (top + maxH > screenHeight - lineHeight && !topdownOnly) {
|
|
el.style.top = "";
|
|
el.style.bottom = screenHeight - top + "px";
|
|
popup.isTopdown = false;
|
|
} else {
|
|
top += lineHeight;
|
|
el.style.top = top + "px";
|
|
el.style.bottom = "";
|
|
popup.isTopdown = true;
|
|
}
|
|
|
|
el.style.display = "";
|
|
this.renderer.$textLayer.checkForSizeChanges();
|
|
|
|
var left = pos.left;
|
|
if (left + el.offsetWidth > screenWidth)
|
|
left = screenWidth - el.offsetWidth;
|
|
|
|
el.style.left = left + "px";
|
|
|
|
this._signal("show");
|
|
lastMouseEvent = null;
|
|
popup.isOpen = true;
|
|
};
|
|
|
|
popup.getTextLeftOffset = function() {
|
|
return this.$borderSize + this.renderer.$padding + this.$imageSize;
|
|
};
|
|
|
|
popup.$imageSize = 0;
|
|
popup.$borderSize = 1;
|
|
|
|
return popup;
|
|
};
|
|
|
|
dom.importCssString("\
|
|
.ace_editor.ace_autocomplete .ace_marker-layer .ace_active-line {\
|
|
background-color: #CAD6FA;\
|
|
z-index: 1;\
|
|
}\
|
|
.ace_editor.ace_autocomplete .ace_line-hover {\
|
|
border: 1px solid #abbffe;\
|
|
margin-top: -1px;\
|
|
background: rgba(233,233,253,0.4);\
|
|
}\
|
|
.ace_editor.ace_autocomplete .ace_line-hover {\
|
|
position: absolute;\
|
|
z-index: 2;\
|
|
}\
|
|
.ace_editor.ace_autocomplete .ace_scroller {\
|
|
background: none;\
|
|
border: none;\
|
|
box-shadow: none;\
|
|
}\
|
|
.ace_rightAlignedText {\
|
|
color: gray;\
|
|
display: inline-block;\
|
|
position: absolute;\
|
|
right: 4px;\
|
|
text-align: right;\
|
|
z-index: -1;\
|
|
}\
|
|
.ace_editor.ace_autocomplete .ace_completion-highlight{\
|
|
color: #000;\
|
|
text-shadow: 0 0 0.01em;\
|
|
}\
|
|
.ace_editor.ace_autocomplete {\
|
|
width: 280px;\
|
|
z-index: 200000;\
|
|
background: #fbfbfb;\
|
|
color: #444;\
|
|
border: 1px lightgray solid;\
|
|
position: fixed;\
|
|
box-shadow: 2px 3px 5px rgba(0,0,0,.2);\
|
|
line-height: 1.4;\
|
|
}");
|
|
|
|
exports.AcePopup = AcePopup;
|
|
|
|
});
|
|
|
|
define("ace/autocomplete/util",["require","exports","module"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
exports.parForEach = function(array, fn, callback) {
|
|
var completed = 0;
|
|
var arLength = array.length;
|
|
if (arLength === 0)
|
|
callback();
|
|
for (var i = 0; i < arLength; i++) {
|
|
fn(array[i], function(result, err) {
|
|
completed++;
|
|
if (completed === arLength)
|
|
callback(result, err);
|
|
});
|
|
}
|
|
};
|
|
|
|
var ID_REGEX = /[a-zA-Z_0-9\$\-\u00A2-\uFFFF]/;
|
|
|
|
exports.retrievePrecedingIdentifier = function(text, pos, regex) {
|
|
regex = regex || ID_REGEX;
|
|
var buf = [];
|
|
for (var i = pos-1; i >= 0; i--) {
|
|
if (regex.test(text[i]))
|
|
buf.push(text[i]);
|
|
else
|
|
break;
|
|
}
|
|
return buf.reverse().join("");
|
|
};
|
|
|
|
exports.retrieveFollowingIdentifier = function(text, pos, regex) {
|
|
regex = regex || ID_REGEX;
|
|
var buf = [];
|
|
for (var i = pos; i < text.length; i++) {
|
|
if (regex.test(text[i]))
|
|
buf.push(text[i]);
|
|
else
|
|
break;
|
|
}
|
|
return buf;
|
|
};
|
|
|
|
});
|
|
|
|
define("ace/autocomplete",["require","exports","module","ace/keyboard/hash_handler","ace/autocomplete/popup","ace/autocomplete/util","ace/lib/event","ace/lib/lang","ace/snippets"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var HashHandler = require("./keyboard/hash_handler").HashHandler;
|
|
var AcePopup = require("./autocomplete/popup").AcePopup;
|
|
var util = require("./autocomplete/util");
|
|
var event = require("./lib/event");
|
|
var lang = require("./lib/lang");
|
|
var snippetManager = require("./snippets").snippetManager;
|
|
|
|
var Autocomplete = function() {
|
|
this.autoInsert = true;
|
|
this.autoSelect = true;
|
|
this.keyboardHandler = new HashHandler();
|
|
this.keyboardHandler.bindKeys(this.commands);
|
|
|
|
this.blurListener = this.blurListener.bind(this);
|
|
this.changeListener = this.changeListener.bind(this);
|
|
this.mousedownListener = this.mousedownListener.bind(this);
|
|
this.mousewheelListener = this.mousewheelListener.bind(this);
|
|
|
|
this.changeTimer = lang.delayedCall(function() {
|
|
this.updateCompletions(true);
|
|
}.bind(this));
|
|
};
|
|
|
|
(function() {
|
|
this.gatherCompletionsId = 0;
|
|
|
|
this.$init = function() {
|
|
this.popup = new AcePopup(document.body || document.documentElement);
|
|
this.popup.on("click", function(e) {
|
|
this.insertMatch();
|
|
e.stop();
|
|
}.bind(this));
|
|
this.popup.focus = this.editor.focus.bind(this.editor);
|
|
};
|
|
|
|
this.openPopup = function(editor, prefix, keepPopupPosition) {
|
|
if (!this.popup)
|
|
this.$init();
|
|
|
|
this.popup.setData(this.completions.filtered);
|
|
|
|
var renderer = editor.renderer;
|
|
this.popup.setRow(this.autoSelect ? 0 : -1);
|
|
if (!keepPopupPosition) {
|
|
this.popup.setTheme(editor.getTheme());
|
|
this.popup.setFontSize(editor.getFontSize());
|
|
|
|
var lineHeight = renderer.layerConfig.lineHeight;
|
|
|
|
var pos = renderer.$cursorLayer.getPixelPosition(this.base, true);
|
|
pos.left -= this.popup.getTextLeftOffset();
|
|
|
|
var rect = editor.container.getBoundingClientRect();
|
|
pos.top += rect.top - renderer.layerConfig.offset;
|
|
pos.left += rect.left - editor.renderer.scrollLeft;
|
|
pos.left += renderer.$gutterLayer.gutterWidth;
|
|
|
|
this.popup.show(pos, lineHeight);
|
|
}
|
|
};
|
|
|
|
this.detach = function() {
|
|
this.editor.keyBinding.removeKeyboardHandler(this.keyboardHandler);
|
|
this.editor.off("changeSelection", this.changeListener);
|
|
this.editor.off("blur", this.blurListener);
|
|
this.editor.off("mousedown", this.mousedownListener);
|
|
this.editor.off("mousewheel", this.mousewheelListener);
|
|
this.changeTimer.cancel();
|
|
|
|
if (this.popup && this.popup.isOpen) {
|
|
this.gatherCompletionsId += 1;
|
|
this.popup.hide();
|
|
}
|
|
|
|
if (this.base)
|
|
this.base.detach();
|
|
this.activated = false;
|
|
this.completions = this.base = null;
|
|
};
|
|
|
|
this.changeListener = function(e) {
|
|
var cursor = this.editor.selection.lead;
|
|
if (cursor.row != this.base.row || cursor.column < this.base.column) {
|
|
this.detach();
|
|
}
|
|
if (this.activated)
|
|
this.changeTimer.schedule();
|
|
else
|
|
this.detach();
|
|
};
|
|
|
|
this.blurListener = function() {
|
|
var el = document.activeElement;
|
|
if (el != this.editor.textInput.getElement() && el.parentNode != this.popup.container)
|
|
this.detach();
|
|
};
|
|
|
|
this.mousedownListener = function(e) {
|
|
this.detach();
|
|
};
|
|
|
|
this.mousewheelListener = function(e) {
|
|
this.detach();
|
|
};
|
|
|
|
this.goTo = function(where) {
|
|
var row = this.popup.getRow();
|
|
var max = this.popup.session.getLength() - 1;
|
|
|
|
switch(where) {
|
|
case "up": row = row <= 0 ? max : row - 1; break;
|
|
case "down": row = row >= max ? -1 : row + 1; break;
|
|
case "start": row = 0; break;
|
|
case "end": row = max; break;
|
|
}
|
|
|
|
this.popup.setRow(row);
|
|
};
|
|
|
|
this.insertMatch = function(data) {
|
|
if (!data)
|
|
data = this.popup.getData(this.popup.getRow());
|
|
if (!data)
|
|
return false;
|
|
|
|
if (data.completer && data.completer.insertMatch) {
|
|
data.completer.insertMatch(this.editor);
|
|
} else {
|
|
if (this.completions.filterText) {
|
|
var ranges = this.editor.selection.getAllRanges();
|
|
for (var i = 0, range; range = ranges[i]; i++) {
|
|
range.start.column -= this.completions.filterText.length;
|
|
this.editor.session.remove(range);
|
|
}
|
|
}
|
|
if (data.snippet)
|
|
snippetManager.insertSnippet(this.editor, data.snippet);
|
|
else
|
|
this.editor.execCommand("insertstring", data.value || data);
|
|
}
|
|
this.detach();
|
|
};
|
|
|
|
this.commands = {
|
|
"Up": function(editor) { editor.completer.goTo("up"); },
|
|
"Down": function(editor) { editor.completer.goTo("down"); },
|
|
"Ctrl-Up|Ctrl-Home": function(editor) { editor.completer.goTo("start"); },
|
|
"Ctrl-Down|Ctrl-End": function(editor) { editor.completer.goTo("end"); },
|
|
|
|
"Esc": function(editor) { editor.completer.detach(); },
|
|
"Space": function(editor) { editor.completer.detach(); editor.insert(" ");},
|
|
"Return": function(editor) { return editor.completer.insertMatch(); },
|
|
"Shift-Return": function(editor) { editor.completer.insertMatch(true); },
|
|
"Tab": function(editor) {
|
|
var result = editor.completer.insertMatch();
|
|
if (!result && !editor.tabstopManager)
|
|
editor.completer.goTo("down");
|
|
else
|
|
return result;
|
|
},
|
|
|
|
"PageUp": function(editor) { editor.completer.popup.gotoPageUp(); },
|
|
"PageDown": function(editor) { editor.completer.popup.gotoPageDown(); }
|
|
};
|
|
|
|
this.gatherCompletions = function(editor, callback) {
|
|
var session = editor.getSession();
|
|
var pos = editor.getCursorPosition();
|
|
|
|
var line = session.getLine(pos.row);
|
|
var prefix = util.retrievePrecedingIdentifier(line, pos.column);
|
|
|
|
this.base = session.doc.createAnchor(pos.row, pos.column - prefix.length);
|
|
|
|
var matches = [];
|
|
var total = editor.completers.length;
|
|
editor.completers.forEach(function(completer, i) {
|
|
completer.getCompletions(editor, session, pos, prefix, function(err, results) {
|
|
if (!err)
|
|
matches = matches.concat(results);
|
|
var pos = editor.getCursorPosition();
|
|
var line = session.getLine(pos.row);
|
|
callback(null, {
|
|
prefix: util.retrievePrecedingIdentifier(line, pos.column, results[0] && results[0].identifierRegex),
|
|
matches: matches,
|
|
finished: (--total === 0)
|
|
});
|
|
});
|
|
});
|
|
return true;
|
|
};
|
|
|
|
this.showPopup = function(editor) {
|
|
if (this.editor)
|
|
this.detach();
|
|
|
|
this.activated = true;
|
|
|
|
this.editor = editor;
|
|
if (editor.completer != this) {
|
|
if (editor.completer)
|
|
editor.completer.detach();
|
|
editor.completer = this;
|
|
}
|
|
|
|
editor.keyBinding.addKeyboardHandler(this.keyboardHandler);
|
|
editor.on("changeSelection", this.changeListener);
|
|
editor.on("blur", this.blurListener);
|
|
editor.on("mousedown", this.mousedownListener);
|
|
editor.on("mousewheel", this.mousewheelListener);
|
|
|
|
this.updateCompletions();
|
|
};
|
|
|
|
this.updateCompletions = function(keepPopupPosition) {
|
|
if (keepPopupPosition && this.base && this.completions) {
|
|
var pos = this.editor.getCursorPosition();
|
|
var prefix = this.editor.session.getTextRange({start: this.base, end: pos});
|
|
if (prefix == this.completions.filterText)
|
|
return;
|
|
this.completions.setFilter(prefix);
|
|
if (!this.completions.filtered.length)
|
|
return this.detach();
|
|
if (this.completions.filtered.length == 1
|
|
&& this.completions.filtered[0].value == prefix
|
|
&& !this.completions.filtered[0].snippet)
|
|
return this.detach();
|
|
this.openPopup(this.editor, prefix, keepPopupPosition);
|
|
return;
|
|
}
|
|
var _id = this.gatherCompletionsId;
|
|
this.gatherCompletions(this.editor, function(err, results) {
|
|
var detachIfFinished = function() {
|
|
if (!results.finished) return;
|
|
return this.detach();
|
|
}.bind(this);
|
|
|
|
var prefix = results.prefix;
|
|
var matches = results && results.matches;
|
|
|
|
if (!matches || !matches.length)
|
|
return detachIfFinished();
|
|
if (prefix.indexOf(results.prefix) !== 0 || _id != this.gatherCompletionsId)
|
|
return;
|
|
|
|
this.completions = new FilteredList(matches);
|
|
this.completions.setFilter(prefix);
|
|
var filtered = this.completions.filtered;
|
|
if (!filtered.length)
|
|
return detachIfFinished();
|
|
if (filtered.length == 1 && filtered[0].value == prefix && !filtered[0].snippet)
|
|
return detachIfFinished();
|
|
if (this.autoInsert && filtered.length == 1)
|
|
return this.insertMatch(filtered[0]);
|
|
|
|
this.openPopup(this.editor, prefix, keepPopupPosition);
|
|
}.bind(this));
|
|
};
|
|
|
|
this.cancelContextMenu = function() {
|
|
this.editor.$mouseHandler.cancelContextMenu();
|
|
};
|
|
|
|
}).call(Autocomplete.prototype);
|
|
|
|
Autocomplete.startCommand = {
|
|
name: "startAutocomplete",
|
|
exec: function(editor) {
|
|
if (!editor.completer)
|
|
editor.completer = new Autocomplete();
|
|
editor.completer.autoInsert =
|
|
editor.completer.autoSelect = true;
|
|
editor.completer.showPopup(editor);
|
|
editor.completer.cancelContextMenu();
|
|
},
|
|
bindKey: "Ctrl-Space|Ctrl-Shift-Space|Alt-Space"
|
|
};
|
|
|
|
var FilteredList = function(array, filterText, mutateData) {
|
|
this.all = array;
|
|
this.filtered = array;
|
|
this.filterText = filterText || "";
|
|
};
|
|
(function(){
|
|
this.setFilter = function(str) {
|
|
if (str.length > this.filterText && str.lastIndexOf(this.filterText, 0) === 0)
|
|
var matches = this.filtered;
|
|
else
|
|
var matches = this.all;
|
|
|
|
this.filterText = str;
|
|
matches = this.filterCompletions(matches, this.filterText);
|
|
matches = matches.sort(function(a, b) {
|
|
return b.exactMatch - a.exactMatch || b.score - a.score;
|
|
});
|
|
var prev = null;
|
|
matches = matches.filter(function(item){
|
|
var caption = item.value || item.caption || item.snippet;
|
|
if (caption === prev) return false;
|
|
prev = caption;
|
|
return true;
|
|
});
|
|
|
|
this.filtered = matches;
|
|
};
|
|
this.filterCompletions = function(items, needle) {
|
|
var results = [];
|
|
var upper = needle.toUpperCase();
|
|
var lower = needle.toLowerCase();
|
|
loop: for (var i = 0, item; item = items[i]; i++) {
|
|
var caption = item.value || item.caption || item.snippet;
|
|
if (!caption) continue;
|
|
var lastIndex = -1;
|
|
var matchMask = 0;
|
|
var penalty = 0;
|
|
var index, distance;
|
|
for (var j = 0; j < needle.length; j++) {
|
|
var i1 = caption.indexOf(lower[j], lastIndex + 1);
|
|
var i2 = caption.indexOf(upper[j], lastIndex + 1);
|
|
index = (i1 >= 0) ? ((i2 < 0 || i1 < i2) ? i1 : i2) : i2;
|
|
if (index < 0)
|
|
continue loop;
|
|
distance = index - lastIndex - 1;
|
|
if (distance > 0) {
|
|
if (lastIndex === -1)
|
|
penalty += 10;
|
|
penalty += distance;
|
|
}
|
|
matchMask = matchMask | (1 << index);
|
|
lastIndex = index;
|
|
}
|
|
item.matchMask = matchMask;
|
|
item.exactMatch = penalty ? 0 : 1;
|
|
item.score = (item.score || 0) - penalty;
|
|
results.push(item);
|
|
}
|
|
return results;
|
|
};
|
|
}).call(FilteredList.prototype);
|
|
|
|
exports.Autocomplete = Autocomplete;
|
|
exports.FilteredList = FilteredList;
|
|
|
|
});
|
|
|
|
define("ace/autocomplete/text_completer",["require","exports","module","ace/range"], function(require, exports, module) {
|
|
var Range = require("../range").Range;
|
|
|
|
var splitRegex = /[^a-zA-Z_0-9\$\-\u00C0-\u1FFF\u2C00-\uD7FF\w]+/;
|
|
|
|
function getWordIndex(doc, pos) {
|
|
var textBefore = doc.getTextRange(Range.fromPoints({row: 0, column:0}, pos));
|
|
return textBefore.split(splitRegex).length - 1;
|
|
}
|
|
function wordDistance(doc, pos) {
|
|
var prefixPos = getWordIndex(doc, pos);
|
|
var words = doc.getValue().split(splitRegex);
|
|
var wordScores = Object.create(null);
|
|
|
|
var currentWord = words[prefixPos];
|
|
|
|
words.forEach(function(word, idx) {
|
|
if (!word || word === currentWord) return;
|
|
|
|
var distance = Math.abs(prefixPos - idx);
|
|
var score = words.length - distance;
|
|
if (wordScores[word]) {
|
|
wordScores[word] = Math.max(score, wordScores[word]);
|
|
} else {
|
|
wordScores[word] = score;
|
|
}
|
|
});
|
|
return wordScores;
|
|
}
|
|
|
|
exports.getCompletions = function(editor, session, pos, prefix, callback) {
|
|
var wordScore = wordDistance(session, pos, prefix);
|
|
var wordList = Object.keys(wordScore);
|
|
callback(null, wordList.map(function(word) {
|
|
return {
|
|
caption: word,
|
|
value: word,
|
|
score: wordScore[word],
|
|
meta: "local"
|
|
};
|
|
}));
|
|
};
|
|
});
|
|
|
|
define("ace/ext/language_tools",["require","exports","module","ace/snippets","ace/autocomplete","ace/config","ace/autocomplete/util","ace/autocomplete/text_completer","ace/editor","ace/config"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
var snippetManager = require("../snippets").snippetManager;
|
|
var Autocomplete = require("../autocomplete").Autocomplete;
|
|
var config = require("../config");
|
|
var util = require("../autocomplete/util");
|
|
|
|
var textCompleter = require("../autocomplete/text_completer");
|
|
var keyWordCompleter = {
|
|
getCompletions: function(editor, session, pos, prefix, callback) {
|
|
var state = editor.session.getState(pos.row);
|
|
var completions = session.$mode.getCompletions(state, session, pos, prefix);
|
|
callback(null, completions);
|
|
}
|
|
};
|
|
|
|
var snippetCompleter = {
|
|
getCompletions: function(editor, session, pos, prefix, callback) {
|
|
var snippetMap = snippetManager.snippetMap;
|
|
var completions = [];
|
|
snippetManager.getActiveScopes(editor).forEach(function(scope) {
|
|
var snippets = snippetMap[scope] || [];
|
|
for (var i = snippets.length; i--;) {
|
|
var s = snippets[i];
|
|
var caption = s.name || s.tabTrigger;
|
|
if (!caption)
|
|
continue;
|
|
completions.push({
|
|
caption: caption,
|
|
snippet: s.content,
|
|
meta: s.tabTrigger && !s.name ? s.tabTrigger + "\u21E5 " : "snippet"
|
|
});
|
|
}
|
|
}, this);
|
|
callback(null, completions);
|
|
}
|
|
};
|
|
|
|
var completers = [snippetCompleter, textCompleter, keyWordCompleter];
|
|
exports.addCompleter = function(completer) {
|
|
completers.push(completer);
|
|
};
|
|
exports.textCompleter = textCompleter;
|
|
exports.keyWordCompleter = keyWordCompleter;
|
|
exports.snippetCompleter = snippetCompleter;
|
|
|
|
var expandSnippet = {
|
|
name: "expandSnippet",
|
|
exec: function(editor) {
|
|
var success = snippetManager.expandWithTab(editor);
|
|
if (!success)
|
|
editor.execCommand("indent");
|
|
},
|
|
bindKey: "Tab"
|
|
};
|
|
|
|
var onChangeMode = function(e, editor) {
|
|
loadSnippetsForMode(editor.session.$mode);
|
|
};
|
|
|
|
var loadSnippetsForMode = function(mode) {
|
|
var id = mode.$id;
|
|
if (!snippetManager.files)
|
|
snippetManager.files = {};
|
|
loadSnippetFile(id);
|
|
if (mode.modes)
|
|
mode.modes.forEach(loadSnippetsForMode);
|
|
};
|
|
|
|
var loadSnippetFile = function(id) {
|
|
if (!id || snippetManager.files[id])
|
|
return;
|
|
var snippetFilePath = id.replace("mode", "snippets");
|
|
snippetManager.files[id] = {};
|
|
config.loadModule(snippetFilePath, function(m) {
|
|
if (m) {
|
|
snippetManager.files[id] = m;
|
|
if (!m.snippets && m.snippetText)
|
|
m.snippets = snippetManager.parseSnippetFile(m.snippetText);
|
|
snippetManager.register(m.snippets || [], m.scope);
|
|
if (m.includeScopes) {
|
|
snippetManager.snippetMap[m.scope].includeScopes = m.includeScopes;
|
|
m.includeScopes.forEach(function(x) {
|
|
loadSnippetFile("ace/mode/" + x);
|
|
});
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
function getCompletionPrefix(editor) {
|
|
var pos = editor.getCursorPosition();
|
|
var line = editor.session.getLine(pos.row);
|
|
var prefix = util.retrievePrecedingIdentifier(line, pos.column);
|
|
editor.completers.forEach(function(completer) {
|
|
if (completer.identifierRegexps) {
|
|
completer.identifierRegexps.forEach(function(identifierRegex) {
|
|
if (!prefix && identifierRegex)
|
|
prefix = util.retrievePrecedingIdentifier(line, pos.column, identifierRegex);
|
|
});
|
|
}
|
|
});
|
|
return prefix;
|
|
}
|
|
|
|
var doLiveAutocomplete = function(e) {
|
|
var editor = e.editor;
|
|
var text = e.args || "";
|
|
var hasCompleter = editor.completer && editor.completer.activated;
|
|
if (e.command.name === "backspace") {
|
|
if (hasCompleter && !getCompletionPrefix(editor))
|
|
editor.completer.detach();
|
|
}
|
|
else if (e.command.name === "insertstring") {
|
|
var prefix = getCompletionPrefix(editor);
|
|
if (prefix && !hasCompleter) {
|
|
if (!editor.completer) {
|
|
editor.completer = new Autocomplete();
|
|
}
|
|
editor.completer.autoSelect = false;
|
|
editor.completer.autoInsert = false;
|
|
editor.completer.showPopup(editor);
|
|
}
|
|
}
|
|
};
|
|
|
|
var Editor = require("../editor").Editor;
|
|
require("../config").defineOptions(Editor.prototype, "editor", {
|
|
enableBasicAutocompletion: {
|
|
set: function(val) {
|
|
if (val) {
|
|
if (!this.completers)
|
|
this.completers = Array.isArray(val)? val: completers;
|
|
this.commands.addCommand(Autocomplete.startCommand);
|
|
} else {
|
|
this.commands.removeCommand(Autocomplete.startCommand);
|
|
}
|
|
},
|
|
value: false
|
|
},
|
|
enableLiveAutocompletion: {
|
|
set: function(val) {
|
|
if (val) {
|
|
if (!this.completers)
|
|
this.completers = Array.isArray(val)? val: completers;
|
|
this.commands.on('afterExec', doLiveAutocomplete);
|
|
} else {
|
|
this.commands.removeListener('afterExec', doLiveAutocomplete);
|
|
}
|
|
},
|
|
value: false
|
|
},
|
|
enableSnippets: {
|
|
set: function(val) {
|
|
if (val) {
|
|
this.commands.addCommand(expandSnippet);
|
|
this.on("changeMode", onChangeMode);
|
|
onChangeMode(null, this);
|
|
} else {
|
|
this.commands.removeCommand(expandSnippet);
|
|
this.off("changeMode", onChangeMode);
|
|
}
|
|
},
|
|
value: false
|
|
}
|
|
});
|
|
});
|
|
|
|
define("ace/ext/beautify/php_rules",["require","exports","module","ace/token_iterator"], function(require, exports, module) {
|
|
"use strict";
|
|
var TokenIterator = require("ace/token_iterator").TokenIterator;
|
|
exports.newLines = [{
|
|
type: 'support.php_tag',
|
|
value: '<?php'
|
|
}, {
|
|
type: 'support.php_tag',
|
|
value: '<?'
|
|
}, {
|
|
type: 'support.php_tag',
|
|
value: '?>'
|
|
}, {
|
|
type: 'paren.lparen',
|
|
value: '{',
|
|
indent: true
|
|
}, {
|
|
type: 'paren.rparen',
|
|
breakBefore: true,
|
|
value: '}',
|
|
indent: false
|
|
}, {
|
|
type: 'paren.rparen',
|
|
breakBefore: true,
|
|
value: '})',
|
|
indent: false,
|
|
dontBreak: true
|
|
}, {
|
|
type: 'comment'
|
|
}, {
|
|
type: 'text',
|
|
value: ';'
|
|
}, {
|
|
type: 'text',
|
|
value: ':',
|
|
context: 'php'
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'case',
|
|
indent: true,
|
|
dontBreak: true
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'default',
|
|
indent: true,
|
|
dontBreak: true
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'break',
|
|
indent: false,
|
|
dontBreak: true
|
|
}, {
|
|
type: 'punctuation.doctype.end',
|
|
value: '>'
|
|
}, {
|
|
type: 'meta.tag.punctuation.end',
|
|
value: '>'
|
|
}, {
|
|
type: 'meta.tag.punctuation.begin',
|
|
value: '<',
|
|
blockTag: true,
|
|
indent: true,
|
|
dontBreak: true
|
|
}, {
|
|
type: 'meta.tag.punctuation.begin',
|
|
value: '</',
|
|
indent: false,
|
|
breakBefore: true,
|
|
dontBreak: true
|
|
}, {
|
|
type: 'punctuation.operator',
|
|
value: ';'
|
|
}];
|
|
|
|
exports.spaces = [{
|
|
type: 'xml-pe',
|
|
prepend: true
|
|
},{
|
|
type: 'entity.other.attribute-name',
|
|
prepend: true
|
|
}, {
|
|
type: 'storage.type',
|
|
value: 'var',
|
|
append: true
|
|
}, {
|
|
type: 'storage.type',
|
|
value: 'function',
|
|
append: true
|
|
}, {
|
|
type: 'keyword.operator',
|
|
value: '='
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'as',
|
|
prepend: true,
|
|
append: true
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'function',
|
|
append: true
|
|
}, {
|
|
type: 'support.function',
|
|
next: /[^\(]/,
|
|
append: true
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'or',
|
|
append: true,
|
|
prepend: true
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'and',
|
|
append: true,
|
|
prepend: true
|
|
}, {
|
|
type: 'keyword',
|
|
value: 'case',
|
|
append: true
|
|
}, {
|
|
type: 'keyword.operator',
|
|
value: '||',
|
|
append: true,
|
|
prepend: true
|
|
}, {
|
|
type: 'keyword.operator',
|
|
value: '&&',
|
|
append: true,
|
|
prepend: true
|
|
}];
|
|
exports.singleTags = ['!doctype','area','base','br','hr','input','img','link','meta'];
|
|
|
|
exports.transform = function(iterator, maxPos, context) {
|
|
var token = iterator.getCurrentToken();
|
|
|
|
var newLines = exports.newLines;
|
|
var spaces = exports.spaces;
|
|
var singleTags = exports.singleTags;
|
|
|
|
var code = '';
|
|
|
|
var indentation = 0;
|
|
var dontBreak = false;
|
|
var tag;
|
|
var lastTag;
|
|
var lastToken = {};
|
|
var nextTag;
|
|
var nextToken = {};
|
|
var breakAdded = false;
|
|
var value = '';
|
|
|
|
while (token!==null) {
|
|
console.log(token);
|
|
|
|
if( !token ){
|
|
token = iterator.stepForward();
|
|
continue;
|
|
}
|
|
if( token.type == 'support.php_tag' && token.value != '?>' ){
|
|
context = 'php';
|
|
}
|
|
else if( token.type == 'support.php_tag' && token.value == '?>' ){
|
|
context = 'html';
|
|
}
|
|
else if( token.type == 'meta.tag.name.style' && context != 'css' ){
|
|
context = 'css';
|
|
}
|
|
else if( token.type == 'meta.tag.name.style' && context == 'css' ){
|
|
context = 'html';
|
|
}
|
|
else if( token.type == 'meta.tag.name.script' && context != 'js' ){
|
|
context = 'js';
|
|
}
|
|
else if( token.type == 'meta.tag.name.script' && context == 'js' ){
|
|
context = 'html';
|
|
}
|
|
|
|
nextToken = iterator.stepForward();
|
|
if (nextToken && nextToken.type.indexOf('meta.tag.name') == 0) {
|
|
nextTag = nextToken.value;
|
|
}
|
|
if ( lastToken.type == 'support.php_tag' && lastToken.value == '<?=') {
|
|
dontBreak = true;
|
|
}
|
|
if (token.type == 'meta.tag.name') {
|
|
token.value = token.value.toLowerCase();
|
|
}
|
|
if (token.type == 'text') {
|
|
token.value = token.value.trim();
|
|
}
|
|
if (!token.value) {
|
|
token = nextToken;
|
|
continue;
|
|
}
|
|
value = token.value;
|
|
for (var i in spaces) {
|
|
if (
|
|
token.type == spaces[i].type &&
|
|
(!spaces[i].value || token.value == spaces[i].value) &&
|
|
(
|
|
nextToken &&
|
|
(!spaces[i].next || spaces[i].next.test(nextToken.value))
|
|
)
|
|
) {
|
|
if (spaces[i].prepend) {
|
|
value = ' ' + token.value;
|
|
}
|
|
|
|
if (spaces[i].append) {
|
|
value += ' ';
|
|
}
|
|
}
|
|
}
|
|
if (token.type.indexOf('meta.tag.name') == 0) {
|
|
tag = token.value;
|
|
}
|
|
breakAdded = false;
|
|
for (i in newLines) {
|
|
if (
|
|
token.type == newLines[i].type &&
|
|
(
|
|
!newLines[i].value ||
|
|
token.value == newLines[i].value
|
|
) &&
|
|
(
|
|
!newLines[i].blockTag ||
|
|
singleTags.indexOf(nextTag) === -1
|
|
) &&
|
|
(
|
|
!newLines[i].context ||
|
|
newLines[i].context === context
|
|
)
|
|
) {
|
|
if (newLines[i].indent === false) {
|
|
indentation--;
|
|
}
|
|
|
|
if (
|
|
newLines[i].breakBefore &&
|
|
( !newLines[i].prev || newLines[i].prev.test(lastToken.value) )
|
|
) {
|
|
code += "\n";
|
|
breakAdded = true;
|
|
for (i = 0; i < indentation; i++) {
|
|
code += "\t";
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (dontBreak===false) {
|
|
for (i in newLines) {
|
|
if (
|
|
lastToken.type == newLines[i].type &&
|
|
(
|
|
!newLines[i].value || lastToken.value == newLines[i].value
|
|
) &&
|
|
(
|
|
!newLines[i].blockTag ||
|
|
singleTags.indexOf(tag) === -1
|
|
) &&
|
|
(
|
|
!newLines[i].context ||
|
|
newLines[i].context === context
|
|
)
|
|
) {
|
|
if (newLines[i].indent === true) {
|
|
indentation++;
|
|
}
|
|
|
|
if (!newLines[i].dontBreak && !breakAdded) {
|
|
code += "\n";
|
|
for (i = 0; i < indentation; i++) {
|
|
code += "\t";
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
code += value;
|
|
if ( lastToken.type == 'support.php_tag' && lastToken.value == '?>' ) {
|
|
dontBreak = false;
|
|
}
|
|
lastTag = tag;
|
|
|
|
lastToken = token;
|
|
|
|
token = nextToken;
|
|
|
|
if (token===null) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return code;
|
|
};
|
|
|
|
|
|
|
|
});
|
|
|
|
define("ace/ext/beautify",["require","exports","module","ace/token_iterator","ace/ext/beautify/php_rules"], function(require, exports, module) {
|
|
"use strict";
|
|
var TokenIterator = require("ace/token_iterator").TokenIterator;
|
|
|
|
var phpTransform = require("./beautify/php_rules").transform;
|
|
|
|
exports.beautify = function(session) {
|
|
var iterator = new TokenIterator(session, 0, 0);
|
|
var token = iterator.getCurrentToken();
|
|
|
|
var context = session.$modeId.split("/").pop();
|
|
|
|
var code = phpTransform(iterator, context);
|
|
session.doc.setValue(code);
|
|
};
|
|
|
|
exports.commands = [{
|
|
name: "beautify",
|
|
exec: function(editor) {
|
|
exports.beautify(editor.session);
|
|
},
|
|
bindKey: "Ctrl-Shift-B"
|
|
}]
|
|
|
|
});
|
|
|
|
define("kitchen-sink/demo",["require","exports","module","ace/lib/fixoldbrowsers","ace/multi_select","ace/ext/spellcheck","kitchen-sink/inline_editor","kitchen-sink/dev_util","kitchen-sink/file_drop","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/ext/whitespace","kitchen-sink/doclist","ace/ext/modelist","ace/ext/themelist","kitchen-sink/layout","kitchen-sink/token_tooltip","kitchen-sink/util","ace/ext/elastic_tabstops_lite","ace/incremental_search","ace/worker/worker_client","ace/split","ace/keyboard/vim","ace/ext/statusbar","ace/ext/emmet","ace/snippets","ace/ext/language_tools","ace/ext/beautify"], function(require, exports, module) {
|
|
"use strict";
|
|
|
|
require("ace/lib/fixoldbrowsers");
|
|
|
|
require("ace/multi_select");
|
|
require("ace/ext/spellcheck");
|
|
require("./inline_editor");
|
|
require("./dev_util");
|
|
require("./file_drop");
|
|
|
|
var config = require("ace/config");
|
|
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 whitespace = require("ace/ext/whitespace");
|
|
|
|
|
|
|
|
var doclist = require("./doclist");
|
|
var modelist = require("ace/ext/modelist");
|
|
var themelist = require("ace/ext/themelist");
|
|
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 IncrementalSearch = require("ace/incremental_search").IncrementalSearch;
|
|
|
|
|
|
var workerModule = require("ace/worker/worker_client");
|
|
if (location.href.indexOf("noworker") !== -1) {
|
|
workerModule.WorkerClient = workerModule.UIWorkerClient;
|
|
}
|
|
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;
|
|
|
|
|
|
var consoleEl = dom.createElement("div");
|
|
container.parentNode.appendChild(consoleEl);
|
|
consoleEl.style.cssText = "position:fixed; bottom:1px; right:0;\
|
|
border:1px solid #baf; z-index:100";
|
|
|
|
var cmdLine = new layout.singleLineEditor(consoleEl);
|
|
cmdLine.editor = env.editor;
|
|
env.editor.cmdLine = cmdLine;
|
|
|
|
env.editor.showCommandLine = function(val) {
|
|
this.cmdLine.focus();
|
|
if (typeof val == "string")
|
|
this.cmdLine.setValue(val, 1);
|
|
};
|
|
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: "snippet",
|
|
bindKey: {win: "Alt-C", mac: "Command-Alt-C"},
|
|
exec: function(editor, needle) {
|
|
if (typeof needle == "object") {
|
|
editor.cmdLine.setValue("snippet ", 1);
|
|
editor.cmdLine.focus();
|
|
return;
|
|
}
|
|
var s = snippetManager.getSnippetByName(needle, editor);
|
|
if (s)
|
|
snippetManager.insertSnippet(editor, s.content);
|
|
},
|
|
readOnly: true
|
|
}, {
|
|
name: "focusCommandLine",
|
|
bindKey: "shift-esc|ctrl-`",
|
|
exec: function(editor, needle) { editor.cmdLine.focus(); },
|
|
readOnly: true
|
|
}, {
|
|
name: "nextFile",
|
|
bindKey: "Ctrl-tab",
|
|
exec: function(editor) { doclist.cycleOpen(editor, 1); },
|
|
readOnly: true
|
|
}, {
|
|
name: "previousFile",
|
|
bindKey: "Ctrl-shift-tab",
|
|
exec: function(editor) { doclist.cycleOpen(editor, -1); },
|
|
readOnly: true
|
|
}, {
|
|
name: "execute",
|
|
bindKey: "ctrl+enter",
|
|
exec: function(editor) {
|
|
try {
|
|
var r = window.eval(editor.getCopyText() || editor.getValue());
|
|
} catch(e) {
|
|
r = e;
|
|
}
|
|
editor.cmdLine.setValue(r + "");
|
|
},
|
|
readOnly: true
|
|
}, {
|
|
name: "showKeyboardShortcuts",
|
|
bindKey: {win: "Ctrl-Alt-h", mac: "Command-Alt-h"},
|
|
exec: function(editor) {
|
|
config.loadModule("ace/ext/keybinding_menu", function(module) {
|
|
module.init(editor);
|
|
editor.showKeyboardShortcuts();
|
|
});
|
|
}
|
|
}, {
|
|
name: "increaseFontSize",
|
|
bindKey: "Ctrl-=|Ctrl-+",
|
|
exec: function(editor) {
|
|
var size = parseInt(editor.getFontSize(), 10) || 12;
|
|
editor.setFontSize(size + 1);
|
|
}
|
|
}, {
|
|
name: "decreaseFontSize",
|
|
bindKey: "Ctrl+-|Ctrl-_",
|
|
exec: function(editor) {
|
|
var size = parseInt(editor.getFontSize(), 10) || 12;
|
|
editor.setFontSize(Math.max(size - 1 || 1));
|
|
}
|
|
}, {
|
|
name: "resetFontSize",
|
|
bindKey: "Ctrl+0|Ctrl-Numpad0",
|
|
exec: function(editor) {
|
|
editor.setFontSize(12);
|
|
}
|
|
}]);
|
|
|
|
|
|
env.editor.commands.addCommands(whitespace.commands);
|
|
|
|
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(arg) {
|
|
var session = env.editor.session;
|
|
var name = session.name.match(/[^\/]+$/);
|
|
localStorage.setItem(
|
|
"saved_file:" + name,
|
|
session.getValue()
|
|
);
|
|
env.editor.cmdLine.setValue("saved "+ name);
|
|
}
|
|
});
|
|
|
|
commands.addCommand({
|
|
name: "load",
|
|
bindKey: {win: "Ctrl-O", mac: "Command-O"},
|
|
exec: function(arg) {
|
|
var session = env.editor.session;
|
|
var name = session.name.match(/[^\/]+$/);
|
|
var value = localStorage.getItem("saved_file:" + name);
|
|
if (typeof value == "string") {
|
|
session.setValue(value);
|
|
env.editor.cmdLine.setValue("loaded "+ name);
|
|
} else {
|
|
env.editor.cmdLine.setValue("no previuos value saved for "+ name);
|
|
}
|
|
}
|
|
});
|
|
|
|
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 showVScrollEl = document.getElementById("show_vscroll");
|
|
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;
|
|
});
|
|
|
|
doclist.history = doclist.docs.map(function(doc) {
|
|
return doc.name;
|
|
});
|
|
doclist.history.index = 0;
|
|
doclist.cycleOpen = function(editor, dir) {
|
|
var h = this.history;
|
|
h.index += dir;
|
|
if (h.index >= h.length)
|
|
h.index = 0;
|
|
else if (h.index <= 0)
|
|
h.index = h.length - 1;
|
|
var s = h[h.index];
|
|
docEl.value = s;
|
|
docEl.onchange();
|
|
};
|
|
doclist.addToHistory = function(name) {
|
|
var h = this.history;
|
|
var i = h.indexOf(name);
|
|
if (i != h.index) {
|
|
if (i != -1)
|
|
h.splice(i, 1);
|
|
h.index = h.push(name);
|
|
}
|
|
};
|
|
|
|
bindDropdown("doc", function(name) {
|
|
doclist.loadDoc(name, function(session) {
|
|
if (!session)
|
|
return;
|
|
doclist.addToHistory(session.name);
|
|
session = env.split.setSession(session);
|
|
whitespace.detectIndentation(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());
|
|
}
|
|
|
|
themelist.themes.forEach(function(x){ x.value = x.theme });
|
|
fillDropdown(themeEl, {
|
|
Bright: themelist.themes.filter(function(x){return !x.isDark}),
|
|
Dark: themelist.themes.filter(function(x){return x.isDark}),
|
|
});
|
|
|
|
event.addListener(themeEl, "mouseover", function(e){
|
|
themeEl.desiredValue = e.target.value;
|
|
if (!themeEl.$timer)
|
|
themeEl.$timer = setTimeout(themeEl.updateTheme);
|
|
});
|
|
|
|
event.addListener(themeEl, "mouseout", function(e){
|
|
themeEl.desiredValue = null;
|
|
if (!themeEl.$timer)
|
|
themeEl.$timer = setTimeout(themeEl.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) {
|
|
env.editor.setOption("wrap", value);
|
|
});
|
|
|
|
bindCheckbox("select_style", function(checked) {
|
|
env.editor.setOption("selectionStyle", 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.setOption("hScrollBarAlwaysVisible", checked);
|
|
});
|
|
|
|
bindCheckbox("show_vscroll", function(checked) {
|
|
env.editor.setOption("vScrollBarAlwaysVisible", 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);
|
|
});
|
|
bindCheckbox("scrollPastEnd", function(checked) {
|
|
env.editor.setOption("scrollPastEnd", 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);
|
|
});
|
|
|
|
var iSearchCheckbox = bindCheckbox("isearch", function(checked) {
|
|
env.editor.setOption("useIncrementalSearch", checked);
|
|
});
|
|
|
|
env.editor.addEventListener('incrementalSearchSettingChanged', function(event) {
|
|
iSearchCheckbox.checked = event.isEnabled;
|
|
});
|
|
|
|
|
|
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);
|
|
}
|
|
});
|
|
|
|
var StatusBar = require("ace/ext/statusbar").StatusBar;
|
|
new StatusBar(env.editor, cmdLine.container);
|
|
|
|
|
|
var Emmet = require("ace/ext/emmet");
|
|
net.loadScript("https://nightwing.github.io/emmet-core/emmet.js", function() {
|
|
Emmet.setCore(window.emmet);
|
|
env.editor.setOption("enableEmmet", true);
|
|
});
|
|
|
|
var snippetManager = require("ace/snippets").snippetManager;
|
|
|
|
env.editSnippets = function() {
|
|
var sp = env.split;
|
|
if (sp.getSplits() == 2) {
|
|
sp.setSplits(1);
|
|
return;
|
|
}
|
|
sp.setSplits(1);
|
|
sp.setSplits(2);
|
|
sp.setOrientation(sp.BESIDE);
|
|
var editor = sp.$editors[1];
|
|
var id = sp.$editors[0].session.$mode.$id || "";
|
|
var m = snippetManager.files[id];
|
|
if (!doclist["snippets/" + id]) {
|
|
var text = m.snippetText;
|
|
var s = doclist.initDoc(text, "", {});
|
|
s.setMode("ace/mode/snippets");
|
|
doclist["snippets/" + id] = s;
|
|
}
|
|
editor.on("blur", function() {
|
|
m.snippetText = editor.getValue();
|
|
snippetManager.unregister(m.snippets);
|
|
m.snippets = snippetManager.parseSnippetFile(m.snippetText, m.scope);
|
|
snippetManager.register(m.snippets);
|
|
});
|
|
sp.$editors[0].once("changeMode", function() {
|
|
sp.setSplits(1);
|
|
});
|
|
editor.setSession(doclist["snippets/" + id], 1);
|
|
editor.focus();
|
|
};
|
|
|
|
require("ace/ext/language_tools");
|
|
env.editor.setOptions({
|
|
enableBasicAutocompletion: true,
|
|
enableLiveAutocompletion: false,
|
|
enableSnippets: true
|
|
});
|
|
|
|
var beautify = require("ace/ext/beautify");
|
|
env.editor.commands.addCommands(beautify.commands);
|
|
|
|
});
|