+

+

+

+

+

+

+ id: moduleName,

+

+

+

+

+ if (typeof requirejs !== "undefined") {

+

+ var define = global.define;

+ global.define = function(id, deps, callback) {

+ if (typeof callback !== "function")

+ return define.apply(this, arguments);

+

+ return define(id, deps, function(require, exports, module) {

+ if (deps[2] == "module")

+ module.packaged = true;

+ return callback.apply(this, arguments);

+ });

+ };

+ global.define.packaged = true;

+

+ return;

+ }

+

+

+

+

+

+define('ace/ace', ['require', 'exports', 'module' , 'ace/lib/fixoldbrowsers', 'ace/lib/dom', 'ace/lib/event', 'ace/editor', 'ace/edit_session', 'ace/undomanager', 'ace/virtual_renderer', 'ace/multi_select', 'ace/worker/worker_client', 'ace/keyboard/hash_handler', 'ace/keyboard/state_handler', 'ace/placeholder', 'ace/config', 'ace/theme/textmate'], function(require, exports, module) {

+var MultiSelect = require("./multi_select").MultiSelect;

+

+// The following require()s are for inclusion in the built ace file

+require("./worker/worker_client");

+require("./keyboard/hash_handler");

+require("./keyboard/state_handler");

+require("./placeholder");

+require("./config").init();

+ new MultiSelect(editor);

+ if ( typeof(str) == 'string' && match) {

+});

+// vim: ts=4 sts=4 sw=4 expandtab

+ if (sheets[index++].owningElement.id === id) return true;

+ style.owningElement.id = id;

+});/* ***** BEGIN LICENSE BLOCK *****

+ var factor = 8;

+ if (useragent.isOldGecko || useragent.isOpera) {

+

+ this.$blockScrolling += 1;

+ this.$blockScrolling -= 1;

+

+ this.renderer.updateFontSize();

+ if (session.$highlightLineMarker)

+ if (typeof this.$lastrow == "number")

+ this.renderer.removeGutterDecoration(this.$lastrow, "ace_gutter_active_line");

+

+ this.$lastrow = null;

+ if (this.getHighlightActiveLine()) {

+

+ if ((this.getSelectionStyle() != "line" || !this.selection.isMultiLine())) {

+ var range;

+ if (foldLine) {

+ range = new Range(foldLine.start.row, 0, foldLine.end.row + 1, 0);

+ } else {

+ range = new Range(cursor.row, 0, cursor.row+1, 0);

+ }

+ session.$highlightLineMarker = session.addMarker(range, "ace_active_line", "background");

+

+ this.renderer.addGutterDecoration(this.$lastrow = cursor.row, "ace_gutter_active_line");

+ this.commands.exec("cut", this);

+ this.setAnimatedScroll = function(shouldAnimate){

+ this.renderer.setAnimatedScroll(shouldAnimate);

+ };

+

+ this.getAnimatedScroll = function(){

+ return this.renderer.getAnimatedScroll();

+ };

+

+

+ }

+

+

+ var replaced = 0;

+ return replaced;

+ if (this.$tryReplace(range, replacement)) {

+ replaced = 1;

+ }

+ if (range !== null) {

+ this.renderer.scrollSelectionIntoView(range.start, range.end);

+ }

+

+ return replaced;

+ var replaced = 0;

+ return replaced;

+ for (var i = ranges.length - 1; i >= 0; --i) {

+ if(this.$tryReplace(ranges[i], replacement)) {

+ replaced++;

+ }

+ }

+

+ return replaced;

+

+ this.$blockScrolling += 1;

+ this.$blockScrolling -= 1;

+

+ if (this.getAnimatedScroll()) {

+ var cursor = this.getCursorPosition();

+ if (!this.isRowFullyVisible(cursor.row))

+ this.scrollToLine(cursor.row, true);

+

+ //@todo scroll X

+ //if (!this.isColumnFullyVisible(cursor.column))

+ //this.scrollToRow(cursor.column);

+ }

+ else {

+ this.renderer.scrollSelectionIntoView(range.start, range.end);

+ }

+ editor.selection.clearSelection();

+ editor.selection.clearSelection();

+ // If the user clicked on a fold, then expand it.

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+ multiSelectAction: "forEach",

+}, {

+ name: "jumptomatching",

+ bindKey: bindKey("Ctrl-Shift-P", "Ctrl-Shift-P"),

+ exec: function(editor) { editor.jumpToMatching(); },

+ multiSelectAction: "forEach",

+ readOnly: true

+ name: "cut",

+ exec: function(editor) {

+ var range = editor.getSelectionRange();

+ editor._emit("cut", range);

+

+ if (!editor.selection.isEmpty()) {

+ editor.session.remove(range);

+ editor.clearSelection();

+ }

+ },

+ multiSelectAction: "forEach"

+}, {

+ exec: function(editor) { editor.removeLines(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.toggleCommentLines(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.remove("right"); },

+ multiSelectAction: "forEach"

+ "Command-Backspace|Option-Backspace|Shift-Backspace|Backspace",

+ exec: function(editor) { editor.remove("left"); },

+ multiSelectAction: "forEach"

+ bindKey: bindKey("Alt-Backspace", "Command-Backspace"),

+ exec: function(editor) { editor.removeToLineStart(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.removeToLineEnd(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.removeWordLeft(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.removeWordRight(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.blockOutdent(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.indent(); },

+ multiSelectAction: "forEach"

+ exec: function(editor, str) { editor.insert(str); },

+ multiSelectAction: "forEach"

+ },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.splitLine(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.transposeLetters(); },

+ multiSelectAction: function(editor) {editor.transposeSelections(1); }

+ exec: function(editor) { editor.toUpperCase(); },

+ multiSelectAction: "forEach"

+ exec: function(editor) { editor.toLowerCase(); },

+ multiSelectAction: "forEach"

+define('ace/edit_session', ['require', 'exports', 'module' , 'ace/config', 'ace/lib/oop', 'ace/lib/lang', 'ace/lib/net', 'ace/lib/event_emitter', 'ace/selection', 'ace/mode/text', 'ace/range', 'ace/document', 'ace/background_tokenizer', 'ace/edit_session/folding', 'ace/edit_session/bracket_match'], function(require, exports, module) {

+var config = require("./config");

+var net = require("./lib/net");

+ this.$modes = {};

+ this._loadMode = function(mode, callback) {

+ if (this.$modes[mode])

+ return callback(this.$modes[mode]);

+

+ var _self = this;

+ var module;

+ try {

+ module = require(mode);

+ } catch (e) {};

+ if (module)

+ return done(module);

+

+ fetch(function() {

+ require([mode], done);

+ });

+

+ function done(module) {

+ if (_self.$modes[mode])

+ return callback(_self.$modes[mode]);

+

+ _self.$modes[mode] = new module.Mode();

+ _self._emit("loadmode", {

+ name: mode,

+ mode: _self.$modes[mode]

+ });

+ callback(_self.$modes[mode]);

+ }

+

+ function fetch(callback) {

+ if (!config.get("packaged"))

+ return callback();

+

+ var base = mode.split("/").pop();

+ var filename = config.get("modePath") + "/mode-" + base + config.get("suffix");

+ net.loadScript(filename, callback);

+ }

+ };

+

+ this.$origMode = null;

+ this.$origMode = mode;

+

+ // load on demand

+ if (typeof mode === "string") {

+ var _self = this;

+ this._loadMode(mode, function(module) {

+ if (_self.$origMode !== mode)

+ return;

+

+ _self.setMode(module);

+ });

+ return;

+ }

+

+

+ var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE)

+ return this.documentToScreenColumn(pos.row, pos.column);

+ // We remove one character at the end so that the docColumn

+ // position returned is not associated to the next row on the screen.

+ if (this.$useWrapMode && docColumn >= column) {

+ docColumn = column - 1;

+/* vim:ts=4:sts=4:sw=4:

+ * ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Fabian Jakobs <fabian AT ajax DOT org>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/config', ['require', 'exports', 'module' , 'ace/lib/lang'], function(require, exports, module) {

+"no use strict";

+

+var lang = require("./lib/lang");

+

+var global = (function() {

+ return this;

+})();

+

+var options = {

+ packaged: false,

+ workerPath: "",

+ modePath: "",

+ themePath: "",

+ suffix: ".js"

+};

+

+exports.get = function(key) {

+ if (!options.hasOwnProperty(key))

+ throw new Error("Unknown confik key: " + key);

+

+ return options[key];

+};

+

+exports.set = function(key, value) {

+ if (!options.hasOwnProperty(key))

+ throw new Error("Unknown confik key: " + key);

+

+ options[key] = value;

+};

+

+exports.all = function() {

+ return lang.copyObject(options);

+};

+

+exports.init = function() {

+ options.packaged = require.packaged || module.packaged || (global.define && define.packaged);

+

+ if (!global.document)

+ return "";

+

+ var scriptOptions = {};

+ var scriptUrl = "";

+ var suffix;

+

+ var scripts = document.getElementsByTagName("script");

+ for (var i=0; i<scripts.length; i++) {

+ var script = scripts[i];

+

+ var src = script.src || script.getAttribute("src");

+ if (!src) {

+ continue;

+ }

+

+ var attributes = script.attributes;

+ for (var j=0, l=attributes.length; j < l; j++) {

+ var attr = attributes[j];

+ if (attr.name.indexOf("data-ace-") === 0) {

+ scriptOptions[deHyphenate(attr.name.replace(/^data-ace-/, ""))] = attr.value;

+ }

+ }

+

+ var m = src.match(/^(?:(.*\/)ace\.js|(.*\/)ace((-uncompressed)?(-noconflict)?\.js))(?:\?|$)/);

+ if (m) {

+ scriptUrl = m[1] || m[2];

+ suffix = m[3];

+ }

+ }

+

+ if (scriptUrl) {

+ scriptOptions.base = scriptOptions.base || scriptUrl;

+ scriptOptions.packaged = true;

+ }

+

+ scriptOptions.suffix = scriptOptions.suffix || suffix;

+ scriptOptions.workerPath = scriptOptions.workerPath || scriptOptions.base;

+ scriptOptions.modePath = scriptOptions.modePath || scriptOptions.base;

+ scriptOptions.themePath = scriptOptions.themePath || scriptOptions.base;

+ delete scriptOptions.base;

+

+ for (var key in scriptOptions)

+ if (typeof scriptOptions[key] !== "undefined")

+ exports.set(key, scriptOptions[key]);

+};

+

+function deHyphenate(str) {

+ return str.replace(/-(.)/g, function(m, m1) { return m1.toUpperCase(); });

+}

+

+});/**

+ * based on code from:

+ *

+ * @license RequireJS text 0.25.0 Copyright (c) 2010-2011, The Dojo Foundation All Rights Reserved.

+ * Available via the MIT or new BSD license.

+ * see: http://github.com/jrburke/requirejs for details

+ */

+define('ace/lib/net', ['require', 'exports', 'module' ], function(require, exports, module) {

+"use strict";

+

+exports.get = function (url, callback) {

+ var xhr = exports.createXhr();

+ xhr.open('GET', url, true);

+ xhr.onreadystatechange = function (evt) {

+ //Do not explicitly handle errors, those should be

+ //visible via console output in the browser.

+ if (xhr.readyState === 4) {

+ callback(xhr.responseText);

+ }

+ };

+ xhr.send(null);

+};

+

+var progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'];

+

+exports.createXhr = function() {

+ //Would love to dump the ActiveX crap in here. Need IE 6 to die first.

+ var xhr, i, progId;

+ if (typeof XMLHttpRequest !== "undefined") {

+ return new XMLHttpRequest();

+ } else {

+ for (i = 0; i < 3; i++) {

+ progId = progIds[i];

+ try {

+ xhr = new ActiveXObject(progId);

+ } catch (e) {}

+

+ if (xhr) {

+ progIds = [progId]; // so faster next time

+ break;

+ }

+ }

+ }

+

+ if (!xhr) {

+ throw new Error("createXhr(): XMLHttpRequest not available");

+ }

+

+ return xhr;

+};

+

+exports.loadScript = function(path, callback) {

+ var head = document.getElementsByTagName('head')[0];

+ var s = document.createElement('script');

+

+ s.src = path;

+ head.appendChild(s);

+

+ s.onload = callback;

+};

+

+});/* ***** BEGIN LICENSE BLOCK *****

+ var self = this;

+ self._emit("changeCursor");

+ if (!self.$isEmpty)

+ self._emit("changeSelection");

+ if (!self.$keepDesiredColumnOnChange && e.old.column != e.value.column)

+ self.$desiredColumn = null;

+ if (!self.$isEmpty)

+ self._emit("changeSelection");

+ this.$desiredColumn = null;

+

+

+

+

+

+

+ if (chars === 0) {

+ if (this.$desiredColumn)

+ screenPos.column = this.$desiredColumn;

+ else

+ this.$desiredColumn = screenPos.column;

+ }

+

+ var docPos = this.session.screenToDocumentPosition(screenPos.row + rows, screenPos.column);

+ this.moveCursorTo = function(row, column, keepDesiredColumn) {

+ this.$keepDesiredColumnOnChange = true;

+ this.$keepDesiredColumnOnChange = false;

+ if (!keepDesiredColumn)

+ this.$desiredColumn = null;

+ this.moveCursorToScreen = function(row, column, keepDesiredColumn) {

+ this.moveCursorTo(pos.row, pos.column, keepDesiredColumn);

+ // remove listeners from document

+ this.detach = function() {

+ this.selectionLead.detach();

+ this.selectionAnchor.detach();

+ this.session = this.doc = null;

+ }

+

+ this.fromOrientedRange = function(range) {

+ this.setSelectionRange(range, range.cursor == range.start);

+ this.$desiredColumn = range.desiredColumn || this.$desiredColumn;

+ }

+

+ this.toOrientedRange = function(range) {

+ var r = this.getRange();

+ if (range) {

+ range.start.column = r.start.column;

+ range.start.row = r.start.row;

+ range.end.column = r.end.column;

+ range.end.row = r.end.row;

+ } else {

+ range = r;

+ }

+

+ range.cursor = this.isBackwards() ? range.start : range.end;

+ range.desiredColumn = this.$desiredColumn;

+ return range;

+ }

+

+ this.isEqual = function(range) {

+ this.intersectsRange = function(range) {

+ var cmp = this.compareRange(range);

+ return (cmp == -1 || cmp == 0 || cmp == 1);

+ }

+

+ this.fixOrientation = function() {

+ if (

+ this.start.row < this.end.row

+ || (this.start.row == this.end.row && this.start.column < this.end.column)

+ ) {

+ return false;

+ }

+

+ var temp = this.start;

+ this.end = this.start;

+ this.start = temp;

+ return true;

+ };

+

+

+

+

+ if (state[i].regex instanceof RegExp)

+ state[i].regex = state[i].regex.toString().slice(1, -1);

+

+

+

+ if (matchcount > 1 && state[i].token.length !== matchcount-1)

+ throw new Error("Matching groups and length of the token array don't match in rule #" + i + " of state " + key);

+

+

+

+

+

+

+ if (match[i + 1] === undefined)

+ continue;

+ rule = state[mapping[i].rule];

+ if (mapping[i].len > 1)

+ value = match.slice(i+2, i+1+mapping[i].len);

+

+ // compute token type

+ if (typeof rule.token == "function")

+ type = rule.token.apply(this, value);

+ else

+ type = rule.token;

+

+ var next = rule.next;

+ if (next && next !== currentState) {

+ currentState = next;

+ state = this.rules[currentState];

+ mapping = this.matchMappings[currentState];

+ lastIndex = re.lastIndex;

+

+ re = this.regExps[currentState];

+ re.lastIndex = lastIndex;

+ break;

+ if (!value[i])

+ continue;

+

+ if (token.type)

+

+

+

+ if (!text || text.length === 0)

+ // only detect new lines if the document has no line break yet

+ endRow = endRow || this.getLength();

+ if (fold && range.isEqual(fold.range)) {

+ if (this.range.isEqual(fold))

+define('ace/commands/command_manager', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/keyboard/hash_handler', 'ace/lib/event_emitter'], function(require, exports, module) {

+var oop = require("../lib/oop");

+var HashHandler = require("../keyboard/hash_handler").HashHandler;

+var EventEmitter = require("../lib/event_emitter").EventEmitter;

+ this.platform = platform;

+ this.commands = {};

+ this.commmandKeyBinding = {};

+

+ this.addCommands(commands);

+

+ this.setDefaultHandler("exec", function(e) {

+ e.command.exec(e.editor, e.args || {});

+ });

+};

+

+oop.inherits(CommandManager, HashHandler);

+

+(function() {

+

+ oop.implement(this, EventEmitter);

+

+ this.exec = function(command, editor, args) {

+ if (typeof command === 'string')

+ command = this.commands[command];

+

+ if (!command)

+ return false;

+

+ if (editor && editor.$readOnly && !command.readOnly)

+ return false;

+

+ this._emit("exec", {editor: editor, command: command, args: args});

+ return true;

+ };

+ this.toggleRecording = function() {

+ if (this.$inReplay)

+ return;

+ if (this.recording) {

+ this.macro.pop();

+ this.removeEventListener("exec", this.$addCommandToMacro);

+

+ if (!this.macro.length)

+ this.macro = this.oldMacro;

+

+ return this.recording = false;

+ }

+ if (!this.$addCommandToMacro) {

+ this.$addCommandToMacro = function(e) {

+ this.macro.push([e.command, e.args]);

+ }.bind(this);

+ }

+

+ this.oldMacro = this.macro;

+ this.macro = [];

+ this.on("exec", this.$addCommandToMacro);

+ return this.recording = true;

+ };

+

+ this.replay = function(editor) {

+ if (this.$inReplay || !this.macro)

+ return;

+

+ if (this.recording)

+ return this.toggleRecording();

+

+ try {

+ this.$inReplay = true;

+ this.macro.forEach(function(x) {

+ if (typeof x == "string")

+ this.exec(x, editor);

+ else

+ this.exec(x[0], editor, x[1]);

+ }, this);

+ } finally {

+ this.$inReplay = false;

+ }

+ };

+

+ this.trimMacro = function(m) {

+ return m.map(function(x){

+ if (typeof x[0] != "string")

+ x[0] = x[0].name;

+ if (!x[1])

+ x = x[0];

+ return x;

+ });

+ };

+

+}).call(CommandManager.prototype);

+

+exports.CommandManager = CommandManager;

+

+});

+/* ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Mozilla Skywriter.

+ *

+ * The Initial Developer of the Original Code is

+ * Mozilla.

+ * Portions created by the Initial Developer are Copyright (C) 2009

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Fabian Jakobs <fabian AT ajax DOT org>

+ * Julian Viereck (julian.viereck@gmail.com)

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/keyboard/hash_handler', ['require', 'exports', 'module' , 'ace/lib/keys'], function(require, exports, module) {

+"use strict";

+

+var keyUtil = require("../lib/keys");

+

+function HashHandler(config, platform) {

+ this.addCommands(config);

+ // exhaustive search is brute force but since removeCommand is

+ commands && Object.keys(commands).forEach(function(name) {

+ };

+ var parts = splitSafe(keys.toLowerCase());

+ for (var i = 0, l = parts.length; i < l; i++) {

+ };

+ function splitSafe(s) {

+ return (s.trim()

+ this.findKeyCommand = function findKeyCommand(hashId, keyString) {

+ return ckbr[hashId] && ckbr[hashId][keyString.toLowerCase()];

+ this.handleKeyboard = function(data, hashId, keyString, keyCode) {

+ return {

+ command: this.findKeyCommand(hashId, keyString)

+}).call(HashHandler.prototype)

+exports.HashHandler = HashHandler;

+define('ace/virtual_renderer', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/lib/dom', 'ace/lib/event', 'ace/lib/useragent', 'ace/config', 'ace/lib/net', 'ace/layer/gutter', 'ace/layer/marker', 'ace/layer/text', 'ace/layer/cursor', 'ace/scrollbar', 'ace/renderloop', 'ace/lib/event_emitter', 'text!ace/css/editor.css'], function(require, exports, module) {

+var config = require("./config");

+var net = require("./lib/net");

+

+

+ this.$gutterLayer.on("changeGutterWidth", this.onResize.bind(this, true));

+

+ this.$animatedScroll = false;

+

+

+ var scrollLeft = _self.scroller.scrollLeft;

+ _self.scrollLeft = scrollLeft;

+ _self.session.setScrollLeft(scrollLeft);

+

+ if (scrollLeft == 0) {

+ _self.$gutter.className = "ace_gutter";

+ }

+ else {

+ _self.$gutter.className = "ace_gutter horscroll";

+ }

+ this.$textLayer.addEventListener("changeCharacterSize", function() {

+ this.CHANGE_H_SCROLL = 1024;

+ this.setAnimatedScroll = function(shouldAnimate){

+ this.$animatedScroll = shouldAnimate;

+ };

+

+ this.getAnimatedScroll = function() {

+ return this.$animatedScroll;

+ };

+

+

+ if (!changes || !this.session || !this.container.offsetWidth)

+ // horizontal scrolling

+ if (changes & this.CHANGE_H_SCROLL) {

+ this.scroller.scrollLeft = this.scrollLeft;

+

+ // read the value after writing it since the value might get clipped

+ var scrollLeft = this.scroller.scrollLeft;

+ this.scrollLeft = scrollLeft;

+ this.session.setScrollLeft(scrollLeft);

+ }

+

+ this.$textLayer.checkForSizeChanges();

+ // update scrollbar first to not lose scroll position when gutter calls resize

+ this.$updateScrollBar();

+ this.$updateScrollBar();

+ if (this.$updateLines()) {

+ this.$updateScrollBar();

+ if (this.showGutter)

+ this.$gutterLayer.update(this.layerConfig);

+ }

+ if (horizScrollChanged) {

+ // when we hide scrollbar scroll event isn't emited

+ // leaving session with wrong scrollLeft value

+ if (!horizScroll)

+ this.session.setScrollLeft(0);

+ }

+ return true;

+ this.scrollSelectionIntoView = function(anchor, lead) {

+ // first scroll anchor into view then scroll lead into view

+ this.scrollCursorIntoView(anchor);

+ this.scrollCursorIntoView(lead);

+ };

+

+ this.scrollCursorIntoView = function(cursor) {

+ var pos = this.$cursorLayer.getPixelPosition(cursor);

+ this.session.setScrollLeft(left);

+ this.session.setScrollLeft(Math.round(left + this.characterWidth - this.$size.scrollerWidth));

+ return this.session.getScrollLeft();

+ this.STEPS = 10;

+ this.$calcSteps = function(fromValue, toValue){

+ var i = 0;

+ var l = this.STEPS;

+ var steps = [];

+ var func = function(t, x_min, dx) {

+ if ((t /= .5) < 1)

+ return dx / 2 * Math.pow(t, 3) + x_min;

+ return dx / 2 * (Math.pow(t - 2, 3) + 2) + x_min;

+ };

+

+ for (i = 0; i < l; ++i)

+ steps.push(func(i / this.STEPS, fromValue, toValue - fromValue));

+ steps.push(toValue);

+

+ return steps;

+ };

+

+ this.scrollToLine = function(line, center) {

+ var pos = this.$cursorLayer.getPixelPosition({row: line, column: 0});

+ var offset = pos.top;

+ if (center)

+

+ if (this.$animatedScroll && Math.abs(offset - this.scrollTop) < 10000) {

+ var _self = this;

+ var steps = _self.$calcSteps(this.scrollTop, offset);

+

+ clearInterval(this.$timer);

+ this.$timer = setInterval(function() {

+ _self.session.setScrollTop(steps.shift());

+

+ if (!steps.length)

+ clearInterval(_self.$timer);

+ }, 10);

+ }

+ else {

+ this.session.setScrollTop(offset);

+ if (this.scrollLeft !== scrollLeft)

+ this.scrollLeft = scrollLeft;

+ this.$loop.schedule(this.CHANGE_H_SCROLL);

+ this.pixelToScreenCoordinates = function(pageX, pageY) {

+ var canvasPos = this.scroller.getBoundingClientRect();

+

+ var col = Math.round(

+ (pageX + this.scrollLeft - canvasPos.left - this.$padding - dom.getPageScrollLeft()) / this.characterWidth

+ );

+ var row = Math.floor(

+ (pageY + this.scrollTop - canvasPos.top - dom.getPageScrollTop()) / this.lineHeight

+ );

+

+ return {row: row, column: col};

+ };

+

+ (pageX + this.scrollLeft - canvasPos.left - this.$padding - dom.getPageScrollLeft()) / this.characterWidth

+ (pageY + this.scrollTop - canvasPos.top - dom.getPageScrollTop()) / this.lineHeight

+ this._loadTheme = function(name, callback) {

+ if (!config.get("packaged"))

+ return callback();

+

+ var base = name.split("/").pop();

+ var filename = config.get("themePath") + "/theme-" + base + config.get("suffix");

+ net.loadScript(filename, callback);

+ };

+

+ var moduleName = theme || "ace/theme/textmate";

+

+ var module;

+ try {

+ module = require(moduleName);

+ } catch (e) {};

+ if (module)

+ return afterLoad(module);

+

+ _self._loadTheme(moduleName, function() {

+ require([moduleName], function(module) {

+ if (_self.$themeValue !== theme)

+ return;

+

+ afterLoad(module);

+ });

+ this.$decorations[row] += " " + className;

+ this.$decorations[row] = this.$decorations[row].replace(" " + className, "");

+ * Draws a marker, which spans a range of text on multiple lines

+ * Draws a marker which covers part or whole width of a single screen line

+ this._emit("changeCharacterSize", {data: size});

+ this.$measureSizes = useragent.isIE || useragent.isOldGecko ? function() {

+ style.position = "fixed";

+

+ // Size and width can be null if the editor is not visible or

+ // detached from the document

+ if (!this.element.offsetWidth)

+ return null;

+ if (size.width == 0 || size.height == 0)

+ return null;

+

+ return size;

+ }

+ : function() {

+ if (!this.$measureNode) {

+ var measureNode = this.$measureNode = dom.createElement("div");

+ var style = measureNode.style;

+

+ style.width = style.height = "auto";

+ style.left = style.top = -100 + "px";

+

+ style.visibility = "hidden";

+ style.position = "fixed";

+ style.overflow = "visible";

+ style.whiteSpace = "nowrap";

+

+ measureNode.innerHTML = "X";

+

+ var container = this.element.parentNode;

+ while (container && !dom.hasCssClass(container, "ace_editor"))

+ container = container.parentNode;

+

+ if (!container)

+ return this.$measureNode = null;

+

+ container.appendChild(measureNode);

+ }

+

+ var rect = this.$measureNode.getBoundingClientRect();

+

+ var size = {

+ height: rect.height,

+ width: rect.width

+ };

+

+ // Size and width can be null if the editor is not visible or

+ // detached from the document

+ if (size.width == 0 || size.height == 0)

+ var fragment = this.element.ownerDocument.createDocumentFragment();

+ var row = firstRow;

+ var foldLine = this.session.getNextFoldLine(row);

+ var foldStart = foldLine ? foldLine.start.row : Infinity;

+ row = foldLine.end.row+1;

+ foldLine = this.session.getNextFoldLine(row, foldLine);

+ foldStart = foldLine ? foldLine.start.row : Infinity;

+ var row = firstRow;

+ var foldLine = this.session.getNextFoldLine(row);

+ var foldStart = foldLine ? foldLine.start.row : Infinity;

+ row = foldLine.end.row+1;

+ foldLine = this.session.getNextFoldLine(row, foldLine);

+ foldStart = foldLine ? foldLine.start.row :Infinity;

+

+ this.cursors = [];

+ this.cursor = this.addCursor();

+ this.addCursor = function() {

+ var el = dom.createElement("div");

+ var className = "ace_cursor";

+ if (!this.isVisible)

+ className += " ace_hidden";

+ if (this.overwrite)

+ className += " ace_overwrite";

+

+ el.className = className;

+ this.element.appendChild(el);

+ this.cursors.push(el);

+ return el;

+ };

+

+ this.removeCursor = function() {

+ if (this.cursors.length > 1) {

+ var el = this.cursors.pop();

+ el.parentNode.removeChild(el);

+ return el;

+ }

+ };

+

+ for (var i = this.cursors.length; i--; )

+ dom.addCssClass(this.cursors[i], "ace_hidden");

+ for (var i = this.cursors.length; i--; )

+ dom.removeCssClass(this.cursors[i], "ace_hidden");

+

+ this.element.style.visibility = "";

+ if (!this.isVisible)

+ var element = this.element;

+ element.style.visibility = "hidden";

+ element.style.visibility = "visible";

+ this.getPixelPosition = function(position, onScreen) {

+ if (!position)

+ position = this.session.selection.getCursor();

+ if (this.session.selectionMarkerCount > 1) {

+ var selections = this.session.$selectionMarkers;

+ var i = 0, sel, cursorIndex = 0;

+ for (var i = selections.length; i--; ) {

+ sel = selections[i];

+ var pixelPos = this.getPixelPosition(sel.cursor, true);

+ var style = (this.cursors[cursorIndex++] || this.addCursor()).style;

+

+ style.left = pixelPos.left + "px";

+ style.top = pixelPos.top + "px";

+ style.width = config.characterWidth + "px";

+ style.height = config.lineHeight + "px";

+ }

+ if (cursorIndex > 1)

+ while (this.cursors.length > cursorIndex)

+ this.removeCursor();

+ } else {

+ var pixelPos = this.getPixelPosition(null, true);

+ var style = this.cursor.style;

+ style.left = pixelPos.left + "px";

+ style.top = pixelPos.top + "px";

+ style.width = config.characterWidth + "px";

+ style.height = config.lineHeight + "px";

+

+ while (this.cursors.length > 1)

+ this.removeCursor();

+ var overwrite = this.session.getOverwrite();

+ if (overwrite != this.overwrite)

+ this.$setOverite(overwrite);

+

+ this.$setOverite = function(overwrite) {

+ this.overwrite = overwrite;

+ for (var i = this.cursors.length; i--; ) {

+ if (overwrite)

+ dom.addCssClass(this.cursors[i], "ace_overwrite");

+ else

+ dom.removeCssClass(this.cursors[i], "ace_overwrite");

+ }

+ };

+

+ // TODO: on chrome 17+ after for small zoom levels after this function

+ // this.element.scrollTop != scrollTop which makes page to scroll up.

+ " font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', 'Droid Sans Mono', 'Consolas', monospace;\n" +

+ " z-index: 1000;\n" +

+ "}\n" +

+ "\n" +

+ ".ace_gutter.horscroll {\n" +

+ " box-shadow: 0px 0px 20px rgba(0,0,0,0.4);\n" +

+ " /* setting pointer-events: auto; on node under the mouse, which changes\n" +

+ " during scroll, will break mouse wheel scrolling in Safari */\n" +

+ " pointer-events: none;\n" +

+ "}\n" +

+ "\n" +

+ ".ace_gutter .ace_layer {\n" +

+ " position: relative;\n" +

+ " min-width: 40px;\n" +

+ " text-align: right;\n" +

+ " pointer-events: auto;\n" +

+ " z-index: 5;\n" +

+ " z-index: 6;\n" +

+ ".ace_gutter .ace_gutter_active_line{\n" +

+ " background-color : #dcdcdc;\n" +

+ "}\n" +

+ "\n" +

+ " z-index: 4;\n" +

+ ".ace_folding-enabled > .ace_gutter-cell {\n" +

+/* vim:ts=4:sts=4:sw=4:

+ * ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Harutyun Amirjanyan <amirjanyan AT gmail DOT com>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/multi_select', ['require', 'exports', 'module' , 'ace/range_list', 'ace/range', 'ace/selection', 'ace/mouse/multi_select_handler', 'ace/commands/multi_select_commands', 'ace/search', 'ace/edit_session', 'ace/editor'], function(require, exports, module) {

+

+var RangeList = require("./range_list").RangeList;

+var Range = require("./range").Range;

+var Selection = require("./selection").Selection;

+var onMouseDown = require("./mouse/multi_select_handler").onMouseDown;

+exports.commands = require("./commands/multi_select_commands");

+

+// Todo: session.find or editor.findVolatile that returns range

+var Search = require("./search").Search;

+var search = new Search();

+

+function find(session, needle, dir) {

+ search.$options.wrap = true;

+ search.$options.needle = needle;

+ search.$options.backwards = dir == -1;

+ return search.find(session);

+}

+

+// extend EditSession

+var EditSession = require("./edit_session").EditSession;

+(function() {

+ this.getSelectionMarkers = function() {

+ return this.$selectionMarkers;

+ };

+}).call(EditSession.prototype);

+

+// extend Selection

+(function() {

+ // list of ranges in reverse addition order

+ this.ranges = null;

+

+ // automatically sorted list of ranges

+ this.rangeList = null;

+

+ /**

+ * Selection.addRange(Range) -> Void

+ *

+ * adds a range to selection entering multiselect mode if necessary

+ **/

+ this.addRange = function(range) {

+ if (!this.inMultiSelectMode && this.rangeCount == 0) {

+ var oldRange = this.toOrientedRange();

+ if (!range || !range.isEqual(oldRange)) {

+ this.rangeList.add(oldRange);

+ this.$onAddRange(oldRange);

+ }

+ }

+

+ if (!range)

+ return;

+

+ if (!range.cursor)

+ range.cursor = range.end;

+

+ var removed = this.rangeList.add(range);

+

+ this.$onAddRange(range);

+

+ if (removed.length)

+ this.$onRemoveRange(removed);

+

+ if (this.rangeCount > 0 && !this.inMultiSelectMode) {

+ this._emit("multiSelect");

+ this.inMultiSelectMode = true;

+ this.session.$undoSelect = false;

+ this.rangeList.attach(this.session);

+ }

+ };

+

+ this.toSingleRange = function(range) {

+ range = range || this.ranges[0];

+ var removed = this.rangeList.removeAll();

+ if (removed.length)

+ this.$onRemoveRange(removed);

+

+ range && this.fromOrientedRange(range);

+ };

+

+ /**

+ * Selection.addRange(pos) -> Range

+ * pos: {row, column}

+ *

+ * removes range containing pos (if exists)

+ **/

+ this.substractPoint = function(pos) {

+ var removed = this.rangeList.substractPoint(pos);

+ if (removed) {

+ this.$onRemoveRange(removed);

+ return removed[0];

+ }

+ };

+

+ /**

+ * Selection.mergeOverlappingRanges() -> Void

+ *

+ * merges overlapping ranges ensuring consistency after changes

+ **/

+ this.mergeOverlappingRanges = function() {

+ var removed = this.rangeList.merge();

+ if (removed.length)

+ this.$onRemoveRange(removed);

+ else if(this.ranges[0])

+ this.fromOrientedRange(this.ranges[0]);

+ };

+

+ this.$onAddRange = function(range) {

+ this.rangeCount = this.rangeList.ranges.length;

+ this.ranges.unshift(range);

+ this.fromOrientedRange(range);

+ this._emit("addRange", {range: range});

+ };

+

+ this.$onRemoveRange = function(removed) {

+ this.rangeCount = this.rangeList.ranges.length;

+ if (this.rangeCount == 1 && this.inMultiSelectMode) {

+ var lastRange = this.rangeList.ranges.pop();

+ removed.push(lastRange);

+ this.rangeCount = 0;

+ }

+

+ for (var i = removed.length; i--; ) {

+ var index = this.ranges.indexOf(removed[i]);

+ this.ranges.splice(index, 1);

+ }

+

+ this._emit("removeRange", {ranges: removed});

+

+ if (this.rangeCount == 0 && this.inMultiSelectMode) {

+ this.inMultiSelectMode = false;

+ this._emit("singleSelect");

+ this.session.$undoSelect = true;

+ this.rangeList.detach(this.session);

+ }

+

+ lastRange = lastRange || this.ranges[0];

+ if (lastRange && !lastRange.isEqual(this.getRange()))

+ this.fromOrientedRange(lastRange);

+ };

+

+ // adds multicursor support to selection

+ this.$initRangeList = function() {

+ if (this.rangeList)

+ return;

+

+ this.rangeList = new RangeList();

+ this.ranges = [];

+ this.rangeCount = 0;

+ };

+

+ this.getAllRanges = function() {

+ return this.rangeList.ranges.concat();

+ };

+

+ this.splitIntoLines = function () {

+ if (this.rangeCount > 1) {

+ var ranges = this.rangeList.ranges;

+ var lastRange = ranges[ranges.length - 1];

+ var range = Range.fromPoints(ranges[0].start, lastRange.end);

+

+ this.toSingleRange();

+ this.setSelectionRange(range, lastRange.cursor == lastRange.start);

+ } else {

+ var cursor = this.session.documentToScreenPosition(this.selectionLead);

+ var anchor = this.session.documentToScreenPosition(this.selectionAnchor);

+

+ var rectSel = this.rectangularRangeBlock(cursor, anchor);

+ rectSel.forEach(this.addRange, this);

+ }

+ };

+

+ /**

+ * Selection.rectangularRangeBlock(screenCursor, screenAnchor, includeEmptyLines) -> [Range]

+ * gets list of ranges composing rectangular block on the screen

+ * @includeEmptyLines if true includes ranges inside the block which

+ * are empty becuase of the clipping

+ */

+ this.rectangularRangeBlock = function(screenCursor, screenAnchor, includeEmptyLines) {

+ var rectSel = [];

+

+ var xBackwards = screenCursor.column < screenAnchor.column;

+ if (xBackwards) {

+ var startColumn = screenCursor.column;

+ var endColumn = screenAnchor.column;

+ } else {

+ var startColumn = screenAnchor.column;

+ var endColumn = screenCursor.column;

+ }

+

+ var yBackwards = screenCursor.row < screenAnchor.row;

+ if (yBackwards) {

+ var startRow = screenCursor.row;

+ var endRow = screenAnchor.row;

+ } else {

+ var startRow = screenAnchor.row;

+ var endRow = screenCursor.row;

+ }

+

+ if (startColumn < 0)

+ startColumn = 0;

+ if (startRow < 0)

+ startRow = 0;

+

+ if (startRow == endRow)

+ includeEmptyLines = true;

+

+ for (var row = startRow; row <= endRow; row++) {

+ var range = Range.fromPoints(

+ this.session.screenToDocumentPosition(row, startColumn),

+ this.session.screenToDocumentPosition(row, endColumn)

+ );

+ if (range.isEmpty()) {

+ if (docEnd && isSamePoint(range.end, docEnd))

+ break;

+ var docEnd = range.end;

+ }

+ range.cursor = xBackwards ? range.start : range.end;

+ rectSel.push(range);

+ }

+

+ if (yBackwards)

+ rectSel.reverse();

+

+ if (!includeEmptyLines) {

+ var end = rectSel.length - 1;

+ while (rectSel[end].isEmpty() && end > 0)

+ end--;

+ if (end > 0) {

+ var start = 0;

+ while (rectSel[start].isEmpty())

+ start++;

+ }

+ for (var i = end; i >= start; i--) {

+ if (rectSel[i].isEmpty())

+ rectSel.splice(i, 1);

+ }

+ }

+

+ return rectSel;

+ };

+}).call(Selection.prototype);

+

+// extend Editor

+var Editor = require("./editor").Editor;

+(function() {

+ /**

+ * Editor.updateSelectionMarkers() -> Void

+ *

+ * updates cursor and marker layers

+ **/

+ this.updateSelectionMarkers = function() {

+ this.renderer.updateCursor();

+ this.renderer.updateBackMarkers();

+ };

+

+ /**

+ * Editor.addSelectionMarker(orientedRange) -> Range

+ * - orientedRange: range with cursor

+ *

+ * adds selection and cursor

+ **/

+ this.addSelectionMarker = function(orientedRange) {

+ if (!orientedRange.cursor)

+ orientedRange.cursor = orientedRange.end;

+

+ var style = this.getSelectionStyle();

+ orientedRange.marker = this.session.addMarker(orientedRange, "ace_selection", style);

+

+ this.session.$selectionMarkers.push(orientedRange);

+ this.session.selectionMarkerCount = this.session.$selectionMarkers.length;

+ return orientedRange;

+ };

+

+ this.removeSelectionMarkers = function(ranges) {

+ for (var i = ranges.length; i--; ) {

+ var range = ranges[i];

+ if (!range.marker)

+ continue;

+ this.session.removeMarker(range.marker);

+ var index = this.session.$selectionMarkers.indexOf(range);

+ if (index != -1)

+ this.session.$selectionMarkers.splice(index, 1);

+ }

+ this.session.selectionMarkerCount = this.session.$selectionMarkers.length;

+ };

+

+ this.$onAddRange = function(e) {

+ this.addSelectionMarker(e.range);

+ this.renderer.updateCursor();

+ this.renderer.updateBackMarkers();

+ };

+

+ this.$onRemoveRange = function(e) {

+ this.removeSelectionMarkers(e.ranges);

+ this.renderer.updateCursor();

+ this.renderer.updateBackMarkers();

+ };

+

+ this.$onMultiSelect = function(e) {

+ if (this.inMultiSelectMode)

+ return;

+ this.inMultiSelectMode = true;

+

+ this.setStyle("multiselect");

+ this.keyBinding.addKeyboardHandler(exports.commands.keyboardHandler);

+ this.commands.on("exec", this.$onMultiSelectExec);

+

+ this.renderer.updateCursor();

+ this.renderer.updateBackMarkers();

+ };

+

+ this.$onSingleSelect = function(e) {

+ if (this.session.multiSelect.inVirtualMode)

+ return;

+ this.inMultiSelectMode = false;

+

+ this.unsetStyle("multiselect");

+ this.keyBinding.removeKeyboardHandler(exports.commands.keyboardHandler);

+

+ this.commands.removeEventListener("exec", this.$onMultiSelectExec);

+ this.renderer.updateCursor();

+ this.renderer.updateBackMarkers();

+ };

+

+ this.$onMultiSelectExec = function(e) {

+ var command = e.command;

+ var editor = e.editor;

+ if (!command.multiSelectAction) {

+ command.exec(editor, e.args || {});

+ editor.multiSelect.addRange(editor.multiSelect.toOrientedRange());

+ editor.multiSelect.mergeOverlappingRanges();

+ } else if (command.multiSelectAction == "forEach") {

+ editor.forEachSelection(command, e.args);

+ } else if (command.multiSelectAction == "single") {

+ editor.exitMultiSelectMode();

+ command.exec(editor, e.args || {});

+ } else {

+ command.multiSelectAction(editor, e.args || {});

+ }

+ e.preventDefault();

+ };

+

+ /**

+ * Editor.forEachSelection(cmd, args) -> Void

+ * - cmd: command to execute

+ * - args: arguments to the command

+ *

+ * executes command for each selection range

+ **/

+ this.forEachSelection = function(cmd, args) {

+ if (this.inVirtualSelectionMode)

+ return;

+

+ var session = this.session;

+ var selection = this.selection;

+ var rangeList = selection.rangeList;

+

+ var reg = selection._eventRegistry;

+ selection._eventRegistry = {};

+

+ var tmpSel = new Selection(session);

+ this.inVirtualSelectionMode = true;

+ for (var i = rangeList.ranges.length; i--;) {

+ tmpSel.fromOrientedRange(rangeList.ranges[i]);

+ this.selection = session.selection = tmpSel;

+ cmd.exec(this, args || {});

+ tmpSel.toOrientedRange(rangeList.ranges[i]);

+ }

+ tmpSel.detach();

+

+ this.selection = session.selection = selection;

+ this.inVirtualSelectionMode = false;

+ selection._eventRegistry = reg;

+ selection.mergeOverlappingRanges();

+

+ this.onCursorChange();

+ this.onSelectionChange();

+ };

+

+ /**

+ * Editor.exitMultiSelectMode() -> Void

+ *

+ * removes all selections except the last added one.

+ **/

+ this.exitMultiSelectMode = function() {

+ if (this.inVirtualSelectionMode)

+ return;

+ this.multiSelect.toSingleRange();

+ };

+

+ this.getCopyText = function() {

+ var text = "";

+ if (this.inMultiSelectMode) {

+ var ranges = this.multiSelect.rangeList.ranges;

+ text = [];

+ for (var i = 0; i < ranges.length; i++) {

+ text.push(this.session.getTextRange(ranges[i]));

+ }

+ text = text.join(this.session.getDocument().getNewLineCharacter());

+ } else if (!this.selection.isEmpty()) {

+ text = this.session.getTextRange(this.getSelectionRange());

+ }

+

+ return text;

+ };

+

+

+ // commands

+ /**

+ * Editor.selectMoreLines(dir, skip) -> Void

+ * - dir: -1 up, 1 down

+ * - skip: remove active selection range if true

+ *

+ * adds cursor above or bellow active cursor

+ **/

+ this.selectMoreLines = function(dir, skip) {

+ var range = this.selection.toOrientedRange();

+ var isBackwards = range.cursor == range.end;

+

+ var screenLead = this.session.documentToScreenPosition(range.cursor);

+ if (this.selection.$desiredColumn)

+ screenLead.column = this.selection.$desiredColumn;

+

+ var lead = this.session.screenToDocumentPosition(screenLead.row + dir, screenLead.column);

+

+ if (!range.isEmpty()) {

+ var screenAnchor = this.session.documentToScreenPosition(isBackwards ? range.end : range.start);

+ var anchor = this.session.screenToDocumentPosition(screenAnchor.row + dir, screenAnchor.column);

+ } else {

+ var anchor = lead;

+ }

+

+ if (isBackwards) {

+ var newRange = Range.fromPoints(lead, anchor);

+ newRange.cursor = newRange.start;

+ } else {

+ var newRange = Range.fromPoints(anchor, lead);

+ newRange.cursor = newRange.end;

+ }

+

+ newRange.desiredColumn = screenLead.column;

+ if (!this.selection.inMultiSelectMode) {

+ this.selection.addRange(range);

+ } else {

+ if (skip)

+ var toRemove = range.cursor;

+ }

+

+ this.selection.addRange(newRange);

+ if (toRemove)

+ this.selection.substractPoint(toRemove);

+ };

+

+ /**

+ * Editor.transposeSelections(dir) -> Void

+ * - dir: direction to rotate selections

+ *

+ * contents

+ * empty ranges are expanded to word

+ **/

+ this.transposeSelections = function(dir) {

+ var session = this.session;

+ var sel = session.multiSelect;

+ var all = sel.ranges;

+

+ for (var i = all.length; i--; ) {

+ var range = all[i];

+ if (range.isEmpty()) {

+ var tmp = session.getWordRange(range.start.row, range.start.column);

+ range.start.row = tmp.start.row;

+ range.start.column = tmp.start.column;

+ range.end.row = tmp.end.row;

+ range.end.column = tmp.end.column;

+ }

+ }

+ sel.mergeOverlappingRanges();

+

+ var words = [];

+ for (var i = all.length; i--; ) {

+ var range = all[i];

+ words.unshift(session.getTextRange(range));

+ }

+

+ if (dir < 0)

+ words.unshift(words.pop());

+ else

+ words.push(words.shift());

+

+ for (var i = all.length; i--; ) {

+ var range = all[i];

+ var tmp = range.clone();

+ session.replace(range, words[i]);

+ range.start.row = tmp.start.row;

+ range.start.column = tmp.start.column;

+ }

+ }

+

+ /**

+ * Editor.selectMore(dir, skip) -> Void

+ * - dir: 1 next, -1 previous

+ * - skip: remove active selection range if true

+ *

+ * finds next occurence of text in active selection

+ * and adds it to the selections

+ **/

+ this.selectMore = function (dir, skip) {

+ var session = this.session;

+ var sel = session.multiSelect;

+

+ var range = sel.toOrientedRange();

+ if (range.isEmpty()) {

+ var range = session.getWordRange(range.start.row, range.start.column);

+ range.cursor = range.end;

+ this.multiSelect.addRange(range);

+ }

+ var needle = session.getTextRange(range);

+

+ var newRange = find(session, needle, dir);

+ if (newRange) {

+ newRange.cursor = dir == -1 ? newRange.start : newRange.end;

+ this.multiSelect.addRange(newRange);

+ }

+ if (skip)

+ this.multiSelect.substractPoint(range.cursor);

+ };

+}).call(Editor.prototype);

+

+

+function isSamePoint(p1, p2) {

+ return p1.row == p2.row && p1.column == p2.column;

+}

+

+// patch

+// adds multicursor support to a session

+exports.onSessionChange = function(e) {

+ var session = e.session;

+ if (!session.multiSelect) {

+ session.$selectionMarkers = [];

+ session.selection.$initRangeList();

+ session.multiSelect = session.selection;

+ }

+ this.multiSelect = session.multiSelect;

+

+ var oldSession = e.oldSession;

+ if (oldSession) {

+ // todo use events

+ if (oldSession.multiSelect && oldSession.multiSelect.editor == this)

+ oldSession.multiSelect.editor = null;

+

+ session.multiSelect.removeEventListener("addRange", this.$onAddRange);

+ session.multiSelect.removeEventListener("removeRange", this.$onRemoveRange);

+ session.multiSelect.removeEventListener("multiSelect", this.$onMultiSelect);

+ session.multiSelect.removeEventListener("singleSelect", this.$onSingleSelect);

+ }

+

+ session.multiSelect.on("addRange", this.$onAddRange);

+ session.multiSelect.on("removeRange", this.$onRemoveRange);

+ session.multiSelect.on("multiSelect", this.$onMultiSelect);

+ session.multiSelect.on("singleSelect", this.$onSingleSelect);

+

+ // this.$onSelectionChange = this.onSelectionChange.bind(this);

+

+ if (this.inMultiSelectMode != session.selection.inMultiSelectMode) {

+ if (session.selection.inMultiSelectMode)

+ this.$onMultiSelect();

+ else

+ this.$onSingleSelect();

+ }

+};

+

+/**

+ * MultiSelect(editor) -> Void

+ *

+ * adds multiple selection support to the editor

+ * (note: should be called only once for each editor instance)

+ **/

+function MultiSelect(editor) {

+ editor.$onAddRange = editor.$onAddRange.bind(editor);

+ editor.$onRemoveRange = editor.$onRemoveRange.bind(editor);

+ editor.$onMultiSelect = editor.$onMultiSelect.bind(editor);

+ editor.$onSingleSelect = editor.$onSingleSelect.bind(editor);

+

+ exports.onSessionChange.call(editor, editor);

+ editor.on("changeSession", exports.onSessionChange.bind(editor));

+

+ editor.on("mousedown", onMouseDown);

+ editor.commands.addCommands(exports.commands.defaultCommands);

+}

+

+exports.MultiSelect = MultiSelect;

+

+});/* ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Harutyun Amirjanyan <amirjanyan AT gmail DOT com>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/range_list', ['require', 'exports', 'module' ], function(require, exports, module) {

+"use strict";

+

+

+var RangeList = function() {

+ this.ranges = [];

+};

+

+(function() {

+ this.comparePoints = function(p1, p2) {

+ return p1.row - p2.row || p1.column - p2.column;

+ };

+

+ this.pointIndex = function(pos, startIndex) {

+ var list = this.ranges;

+

+ for (var i = startIndex || 0; i < list.length; i++) {

+ var range = list[i];

+ var cmp = this.comparePoints(pos, range.end);

+

+ if (cmp > 0)

+ continue;

+ if (cmp == 0)

+ return i;

+ cmp = this.comparePoints(pos, range.start);

+ if (cmp >= 0)

+ return i;

+

+ return -i-1;

+ }

+ return -i - 1;

+ };

+

+ this.add = function(range) {

+ var startIndex = this.pointIndex(range.start);

+ if (startIndex < 0)

+ startIndex = -startIndex - 1;

+

+ var endIndex = this.pointIndex(range.end, startIndex);

+

+ if (endIndex < 0)

+ endIndex = -endIndex - 1;

+ else

+ endIndex++;

+

+ return this.ranges.splice(startIndex, endIndex - startIndex, range);

+ };

+

+ this.addList = function(list) {

+ var removed = [];

+ for (var i = list.length; i--; ) {

+ removed.push.call(removed, this.add(list[i]));

+ }

+ return removed;

+ };

+

+ this.substractPoint = function(pos) {

+ var i = this.pointIndex(pos);

+

+ if (i >= 0)

+ return this.ranges.splice(i, 1);

+ };

+

+ // merge overlapping ranges

+ this.merge = function() {

+ var removed = [];

+ var list = this.ranges;

+ var next = list[0], range;

+ for (var i = 1; i < list.length; i++) {

+ range = next;

+ next = list[i];

+ var cmp = this.comparePoints(range.end, next.start);

+ if (cmp < 0)

+ continue;

+

+ if (cmp == 0 && !(range.isEmpty() || next.isEmpty()))

+ continue;

+

+ if (this.comparePoints(range.end, next.end) < 0) {

+ range.end.row = next.end.row;

+ range.end.column = next.end.column;

+ }

+

+ list.splice(i, 1);

+ removed.push(next);

+ next = range;

+ i--;

+ }

+

+ return removed;

+ };

+

+ this.contains = function(row, column) {

+ return this.pointIndex({row: row, column: column}) >= 0;

+ };

+

+ this.containsPoint = function(pos) {

+ return this.pointIndex(pos) >= 0;

+ };

+

+ this.rangeAtPoint = function(pos) {

+ var i = this.pointIndex(pos);

+ if (i >= 0)

+ return this.ranges[i];

+ };

+

+

+ this.clipRows = function(startRow, endRow) {

+ var list = this.ranges;

+ if (list[0].start.row > endRow || list[list.length - 1].start.row < startRow)

+ return [];

+

+ var startIndex = this.pointIndex({row: startRow, column: 0});

+ if (startIndex < 0)

+ startIndex = -startIndex - 1;

+ var endIndex = this.pointIndex({row: endRow, column: 0}, startIndex);

+ if (endIndex < 0)

+ endIndex = -endIndex - 1;

+

+ var clipped = [];

+ for (var i = startIndex; i < endIndex; i++) {

+ clipped.push(list[i]);

+ }

+ return clipped;

+ };

+

+ this.removeAll = function() {

+ return this.ranges.splice(0, this.ranges.length);

+ };

+

+ this.attach = function(session) {

+ if (this.session)

+ this.detach();

+

+ this.session = session;

+ this.onChange = this.$onChange.bind(this);

+

+ this.session.on('change', this.onChange);

+ };

+

+ this.detach = function() {

+ if (!this.session)

+ return;

+ this.session.removeListener('change', this.onChange);

+ this.session = null;

+ };

+

+ this.$onChange = function(e) {

+ var changeRange = e.data.range;

+ if (e.data.action[0] == "i"){

+ var start = changeRange.start;

+ var end = changeRange.end;

+ } else {

+ var end = changeRange.start;

+ var start = changeRange.end;

+ }

+ var startRow = start.row;

+ var endRow = end.row;

+ var lineDif = endRow - startRow;

+

+ var colDiff = -start.column + end.column;

+

+ var ranges = this.ranges;

+

+ for (var i=0, n = ranges.length; i < n; i++) {

+ var r = ranges[i];

+ if (r.end.row < startRow)

+ continue;

+ if (r.start.row > startRow)

+ break;

+

+ if (r.start.row == startRow && r.start.column >= start.column ) {

+ r.start.column += colDiff;

+ r.start.row += lineDif;

+ }

+ if (r.end.row == startRow && r.end.column >= start.column) {

+ r.end.column += colDiff;

+ r.end.row += lineDif;

+ }

+ }

+

+ if (lineDif != 0 && i < n) {

+ for (; i < n; i++) {

+ var r = ranges[i];

+ r.start.row += lineDif;

+ r.end.row += lineDif;

+ }

+ }

+ };

+

+}).call(RangeList.prototype);

+

+exports.RangeList = RangeList;

+});

+/* vim:ts=4:sts=4:sw=4:

+ * ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Harutyun Amirjanyan <amirjanyan AT gmail DOT com>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/mouse/multi_select_handler', ['require', 'exports', 'module' , 'ace/lib/event'], function(require, exports, module) {

+

+var event = require("../lib/event");

+

+

+// mouse

+function isSamePoint(p1, p2) {

+ return p1.row == p2.row && p1.column == p2.column;

+}

+

+function onMouseDown(e) {

+ var ev = e.domEvent;

+ var alt = ev.altKey;

+ var shift = ev.shiftKey;

+ var ctrl = e.getAccelKey();

+ var button = e.getButton();

+

+ if (!ctrl && !alt) {

+ if (e.editor.inMultiSelectMode) {

+ if (button == 0) {

+ e.editor.exitMultiSelectMode();

+ } else if (button == 2) {

+ var editor = e.editor;

+ var selectionEmpty = editor.selection.isEmpty();

+ editor.textInput.onContextMenu({x: e.clientX, y: e.clientY}, selectionEmpty);

+ event.capture(editor.container, function(){}, editor.textInput.onContextMenuClose);

+ e.stop();

+ }

+ }

+ return;

+ }

+

+ var editor = e.editor;

+ var selection = editor.selection;

+ var isMultiSelect = editor.inMultiSelectMode;

+ var pos = e.getDocumentPosition();

+ var cursor = selection.getCursor();

+ var inSelection = e.inSelection() || (selection.isEmpty() && isSamePoint(pos, cursor));

+

+

+ var mouseX = e.pageX, mouseY = e.pageY;

+ var onMouseSelection = function(e) {

+ mouseX = event.getDocumentX(e);

+ mouseY = event.getDocumentY(e);

+ };

+

+ var blockSelect = function() {

+ var newCursor = editor.renderer.pixelToScreenCoordinates(mouseX, mouseY);

+ var cursor = session.screenToDocumentPosition(newCursor.row, newCursor.column);

+

+ if (isSamePoint(screenCursor, newCursor)

+ && isSamePoint(cursor, selection.selectionLead))

+ return;

+ screenCursor = newCursor;

+

+ editor.selection.moveCursorToPosition(cursor);

+ editor.selection.clearSelection();

+ editor.renderer.scrollCursorIntoView();

+

+ editor.removeSelectionMarkers(rectSel);

+ rectSel = selection.rectangularRangeBlock(screenCursor, screenAnchor);

+ rectSel.forEach(editor.addSelectionMarker, editor);

+ editor.updateSelectionMarkers();

+ };

+

+ var session = editor.session;

+ var screenAnchor = editor.renderer.pixelToScreenCoordinates(mouseX, mouseY);

+ var screenCursor = screenAnchor;

+

+

+

+ if (ctrl && !shift && !alt && button == 0) {

+ if (!isMultiSelect && inSelection)

+ return; // dragging

+

+ if (!isMultiSelect)

+ selection.addRange(selection.toOrientedRange());

+

+

+ var oldRange = selection.rangeList.rangeAtPoint(pos);

+

+ event.capture(editor.container, function(){}, function() {

+ var tmpSel = selection.toOrientedRange();

+

+ if (oldRange && tmpSel.isEmpty() && isSamePoint(oldRange.cursor, tmpSel.cursor))

+ selection.substractPoint(tmpSel.cursor);

+ else

+ selection.addRange(tmpSel);

+ });

+

+ } else if (!shift && alt && button == 0) {

+ e.stop();

+

+ if (isMultiSelect && !ctrl)

+ selection.toSingleRange();

+ else if (!isMultiSelect && ctrl)

+ selection.addRange();

+

+ selection.moveCursorToPosition(pos);

+ selection.clearSelection();

+

+ var rectSel = [];

+

+ var onMouseSelectionEnd = function(e) {

+ clearInterval(timerId);

+ editor.removeSelectionMarkers(rectSel);

+ for (var i = 0; i < rectSel.length; i++)

+ selection.addRange(rectSel[i]);

+ };

+

+ var onSelectionInterval = blockSelect;

+

+ event.capture(editor.container, onMouseSelection, onMouseSelectionEnd);

+ var timerId = setInterval(function() {onSelectionInterval();}, 20);

+

+ return e.preventDefault();

+ }

+}

+

+

+exports.onMouseDown = onMouseDown;

+

+});/* vim:ts=4:sts=4:sw=4:

+ * ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Harutyun Amirjanyan <amirjanyan AT gmail DOT com>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/commands/multi_select_commands', ['require', 'exports', 'module' , 'ace/keyboard/hash_handler'], function(require, exports, module) {

+

+// commands to enter multiselect mode

+exports.defaultCommands = [{

+ name: "addCursorAbove",

+ exec: function(editor) { editor.selectMoreLines(-1); },

+ bindKey: {win: "Ctrl-Alt-Up", mac: "Ctrl-Alt-Up"},

+ readonly: true

+}, {

+ name: "addCursorBelow",

+ exec: function(editor) { editor.selectMoreLines(1); },

+ bindKey: {win: "Ctrl-Alt-Down", mac: "Ctrl-Alt-Down"},

+ readonly: true

+}, {

+ name: "addCursorAboveSkipCurrent",

+ exec: function(editor) { editor.selectMoreLines(-1, true); },

+ bindKey: {win: "Ctrl-Alt-Shift-Up", mac: "Ctrl-Alt-Shift-Up"},

+ readonly: true

+}, {

+ name: "addCursorBelowSkipCurrent",

+ exec: function(editor) { editor.selectMoreLines(1, true); },

+ bindKey: {win: "Ctrl-Alt-Shift-Down", mac: "Ctrl-Alt-Shift-Down"},

+ readonly: true

+}, {

+ name: "selectMoreBefore",

+ exec: function(editor) { editor.selectMore(-1); },

+ bindKey: {win: "Ctrl-Alt-Left", mac: "Ctrl-Alt-Left"},

+ readonly: true

+}, {

+ name: "selectMoreAfter",

+ exec: function(editor) { editor.selectMore(1); },

+ bindKey: {win: "Ctrl-Alt-Right", mac: "Ctrl-Alt-Right"},

+ readonly: true

+}, {

+ name: "selectNextBefore",

+ exec: function(editor) { editor.selectMore(-1, true); },

+ bindKey: {win: "Ctrl-Alt-Shift-Left", mac: "Ctrl-Alt-Shift-Left"},

+ readonly: true

+}, {

+ name: "selectNextAfter",

+ exec: function(editor) { editor.selectMore(1, true); },

+ bindKey: {win: "Ctrl-Alt-Shift-Right", mac: "Ctrl-Alt-Shift-Right"},

+ readonly: true

+}, {

+ name: "splitIntoLines",

+ exec: function(editor) { editor.multiSelect.splitIntoLines(); },

+ bindKey: {win: "Ctrl-Shift-L", mac: "Ctrl-Shift-L"},

+ readonly: true

+}];

+

+// commands active in multiselect mode

+exports.multiEditCommands = [{

+ name: "singleSelection",

+ bindKey: "esc",

+ exec: function(editor) { editor.exitMultiSelectMode(); },

+ readonly: true

+}];

+

+var HashHandler = require("../keyboard/hash_handler").HashHandler;

+exports.keyboardHandler = new HashHandler(exports.multiEditCommands);

+

+});/* ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Fabian Jakobs <fabian AT ajax DOT org>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/worker/worker_client', ['require', 'exports', 'module' , 'ace/lib/oop', 'ace/lib/event_emitter', 'ace/config'], function(require, exports, module) {

+"use strict";

+

+var oop = require("../lib/oop");

+var EventEmitter = require("../lib/event_emitter").EventEmitter;

+var config = require("../config");

+

+var WorkerClient = function(topLevelNamespaces, packagedJs, mod, classname) {

+

+ this.changeListener = this.changeListener.bind(this);

+

+ if (config.get("packaged")) {

+ this.$worker = new Worker(config.get("workerPath") + "/" + packagedJs);

+ }

+ else {

+ var workerUrl = this.$normalizePath(require.nameToUrl("ace/worker/worker", null, "_"));

+ this.$worker = new Worker(workerUrl);

+

+ var tlns = {};

+ for (var i=0; i<topLevelNamespaces.length; i++) {

+ var ns = topLevelNamespaces[i];

+ var path = this.$normalizePath(require.nameToUrl(ns, null, "_").replace(/.js$/, ""));

+

+ tlns[ns] = path;

+ }

+ }

+

+ this.$worker.postMessage({

+ init : true,

+ tlns: tlns,

+ module: mod,

+ classname: classname

+ });

+

+ this.callbackId = 1;

+ this.callbacks = {};

+

+ var _self = this;

+ this.$worker.onerror = function(e) {

+ window.console && console.log && console.log(e);

+ throw e;

+ };

+ this.$worker.onmessage = function(e) {

+ var msg = e.data;

+ switch(msg.type) {

+ case "log":

+ window.console && console.log && console.log(msg.data);

+ break;

+

+ case "event":

+ _self._emit(msg.name, {data: msg.data});

+ break;

+

+ case "call":

+ var callback = _self.callbacks[msg.id];

+ if (callback) {

+ callback(msg.data);

+ delete _self.callbacks[msg.id];

+ }

+ break;

+ }

+ };

+};

+

+(function(){

+

+ oop.implement(this, EventEmitter);

+

+ this.$normalizePath = function(path) {

+ path = path.replace(/^[a-z]+:\/\/[^\/]+/, ""); // Remove domain name and rebuild it

+ path = location.protocol + "//" + location.host

+ // paths starting with a slash are relative to the root (host)

+ + (path.charAt(0) == "/" ? "" : location.pathname.replace(/\/[^\/]*$/, ""))

+ + "/" + path.replace(/^[\/]+/, "");

+ return path;

+ };

+

+ this.terminate = function() {

+ this._emit("terminate", {});

+ this.$worker.terminate();

+ this.$worker = null;

+ this.$doc.removeEventListener("change", this.changeListener);

+ this.$doc = null;

+ };

+

+ this.send = function(cmd, args) {

+ this.$worker.postMessage({command: cmd, args: args});

+ };

+

+ this.call = function(cmd, args, callback) {

+ if (callback) {

+ var id = this.callbackId++;

+ this.callbacks[id] = callback;

+ args.push(id);

+ }

+ this.send(cmd, args);

+ };

+

+ this.emit = function(event, data) {

+ try {

+ // firefox refuses to clone objects which have function properties

+ // TODO: cleanup event

+ this.$worker.postMessage({event: event, data: {data: data.data}});

+ }

+ catch(ex) {}

+ };

+

+ this.attachToDocument = function(doc) {

+ if(this.$doc)

+ this.terminate();

+

+ this.$doc = doc;

+ this.call("setValue", [doc.getValue()]);

+ doc.on("change", this.changeListener);

+ };

+

+ this.changeListener = function(e) {

+ e.range = {

+ start: e.data.range.start,

+ end: e.data.range.end

+ };

+ this.emit("change", e);

+ };

+

+}).call(WorkerClient.prototype);

+

+exports.WorkerClient = WorkerClient;

+

+});

+/* ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Mozilla Skywriter.

+ *

+ * The Initial Developer of the Original Code is

+ * Mozilla.

+ * Portions created by the Initial Developer are Copyright (C) 2009

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Julian Viereck (julian.viereck@gmail.com)

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+

+define('ace/keyboard/state_handler', ['require', 'exports', 'module' ], function(require, exports, module) {

+"use strict";

+

+// If you're developing a new keymapping and want to get an idea what's going

+// on, then enable debugging.

+var DEBUG = false;

+

+function StateHandler(keymapping) {

+ this.keymapping = this.$buildKeymappingRegex(keymapping);

+}

+

+StateHandler.prototype = {

+ /**

+ * Build the RegExp from the keymapping as RegExp can't stored directly

+ * in the metadata JSON and as the RegExp used to match the keys/buffer

+ * need to be adapted.

+ */

+ $buildKeymappingRegex: function(keymapping) {

+ for (var state in keymapping) {

+ this.$buildBindingsRegex(keymapping[state]);

+ }

+ return keymapping;

+ },

+

+ $buildBindingsRegex: function(bindings) {

+ // Escape a given Regex string.

+ bindings.forEach(function(binding) {

+ if (binding.key) {

+ binding.key = new RegExp('^' + binding.key + '$');

+ } else if (Array.isArray(binding.regex)) {

+ if (!('key' in binding))

+ binding.key = new RegExp('^' + binding.regex[1] + '$');

+ binding.regex = new RegExp(binding.regex.join('') + '$');

+ } else if (binding.regex) {

+ binding.regex = new RegExp(binding.regex + '$');

+ }

+ });

+ },

+

+ $composeBuffer: function(data, hashId, key, e) {

+ // Initialize the data object.

+ if (data.state == null || data.buffer == null) {

+ data.state = "start";

+ data.buffer = "";

+ }

+

+ var keyArray = [];

+ if (hashId & 1) keyArray.push("ctrl");

+ if (hashId & 8) keyArray.push("command");

+ if (hashId & 2) keyArray.push("option");

+ if (hashId & 4) keyArray.push("shift");

+ if (key) keyArray.push(key);

+

+ var symbolicName = keyArray.join("-");

+ var bufferToUse = data.buffer + symbolicName;

+

+ // Don't add the symbolic name to the key buffer if the alt_ key is

+ // part of the symbolic name. If it starts with alt_, this means

+ // that the user hit an alt keycombo and there will be a single,

+ // new character detected after this event, which then will be

+ // added to the buffer (e.g. alt_j will result in ∆).

+ //

+ // We test for 2 and not for & 2 as we only want to exclude the case where

+ // the option key is pressed alone.

+ if (hashId != 2) {

+ data.buffer = bufferToUse;

+ }

+

+ var bufferObj = {

+ bufferToUse: bufferToUse,

+ symbolicName: symbolicName,

+ };

+

+ if (e) {

+ bufferObj.keyIdentifier = e.keyIdentifier

+ }

+

+ return bufferObj;

+ },

+

+ $find: function(data, buffer, symbolicName, hashId, key, keyIdentifier) {

+ // Holds the command to execute and the args if a command matched.

+ var result = {};

+

+ // Loop over all the bindings of the keymap until a match is found.

+ this.keymapping[data.state].some(function(binding) {

+ var match;

+

+ // Check if the key matches.

+ if (binding.key && !binding.key.test(symbolicName)) {

+ return false;

+ }

+

+ // Check if the regex matches.

+ if (binding.regex && !(match = binding.regex.exec(buffer))) {

+ return false;

+ }

+

+ // Check if the match function matches.

+ if (binding.match && !binding.match(buffer, hashId, key, symbolicName, keyIdentifier)) {

+ return false;

+ }

+

+ // Check for disallowed matches.

+ if (binding.disallowMatches) {

+ for (var i = 0; i < binding.disallowMatches.length; i++) {

+ if (!!match[binding.disallowMatches[i]]) {

+ return false;

+ }

+ }

+ }

+

+ // If there is a command to execute, then figure out the

+ // command and the arguments.

+ if (binding.exec) {

+ result.command = binding.exec;

+

+ // Build the arguments.

+ if (binding.params) {

+ var value;

+ result.args = {};

+ binding.params.forEach(function(param) {

+ if (param.match != null && match != null) {

+ value = match[param.match] || param.defaultValue;

+ } else {

+ value = param.defaultValue;

+ }

+

+ if (param.type === 'number') {

+ value = parseInt(value);

+ }

+

+ result.args[param.name] = value;

+ });

+ }

+ data.buffer = "";

+ }

+

+ // Handle the 'then' property.

+ if (binding.then) {

+ data.state = binding.then;

+ data.buffer = "";

+ }

+

+ // If no command is set, then execute the "null" fake command.

+ if (result.command == null) {

+ result.command = "null";

+ }

+

+ if (DEBUG) {

+ console.log("KeyboardStateMapper#find", binding);

+ }

+ return true;

+ });

+

+ if (result.command) {

+ return result;

+ } else {

+ data.buffer = "";

+ return false;

+ }

+ },

+

+ /**

+ * This function is called by keyBinding.

+ */

+ handleKeyboard: function(data, hashId, key, keyCode, e) {

+ // If we pressed any command key but no other key, then ignore the input.

+ // Otherwise "shift-" is added to the buffer, and later on "shift-g"

+ // which results in "shift-shift-g" which doesn't make sense.

+ if (hashId != 0 && (key == "" || key == String.fromCharCode(0))) {

+ return null;

+ }

+

+ // Compute the current value of the keyboard input buffer.

+ var r = this.$composeBuffer(data, hashId, key, e);

+ var buffer = r.bufferToUse;

+ var symbolicName = r.symbolicName;

+ var keyId = r.keyIdentifier;

+

+ r = this.$find(data, buffer, symbolicName, hashId, key, keyId);

+ if (DEBUG) {

+ console.log("KeyboardStateMapper#match", buffer, symbolicName, r);

+ }

+

+ return r;

+ }

+}

+

+/**

+ * This is a useful matching function and therefore is defined here so that

+ * users of KeyboardStateMapper can use it.

+ *

+ * @return boolean

+ * If no command key (Command|Option|Shift|Ctrl) is pressed, it

+ * returns true. If the only the Shift key is pressed + a character

+ * true is returned as well. Otherwise, false is returned.

+ * Summing up, the function returns true whenever the user typed

+ * a normal character on the keyboard and no shortcut.

+ */

+exports.matchCharacterOnly = function(buffer, hashId, key, symbolicName) {

+ // If no command keys are pressed, then catch the input.

+ if (hashId == 0) {

+ return true;

+ }

+ // If only the shift key is pressed and a character key, then

+ // catch that input as well.

+ else if ((hashId == 4) && key.length == 1) {

+ return true;

+ }

+ // Otherwise, we let the input got through.

+ else {

+ return false;

+ }

+};

+

+exports.StateHandler = StateHandler;

+});

+/* ***** BEGIN LICENSE BLOCK *****

+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1

+ *

+ * The contents of this file are subject to the Mozilla Public License Version

+ * 1.1 (the "License"); you may not use this file except in compliance with

+ * the License. You may obtain a copy of the License at

+ * http://www.mozilla.org/MPL/

+ *

+ * Software distributed under the License is distributed on an "AS IS" basis,

+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

+ * for the specific language governing rights and limitations under the

+ * License.

+ *

+ * The Original Code is Ajax.org Code Editor (ACE).

+ *

+ * The Initial Developer of the Original Code is

+ * Ajax.org B.V.

+ * Portions created by the Initial Developer are Copyright (C) 2010

+ * the Initial Developer. All Rights Reserved.

+ *

+ * Contributor(s):

+ * Zef Hemel <zef@c9.io>

+ *

+ * Alternatively, the contents of this file may be used under the terms of

+ * either the GNU General Public License Version 2 or later (the "GPL"), or

+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

+ * in which case the provisions of the GPL or the LGPL are applicable instead

+ * of those above. If you wish to allow use of your version of this file only

+ * under the terms of either the GPL or the LGPL, and not to allow others to

+ * use your version of this file under the terms of the MPL, indicate your

+ * decision by deleting the provisions above and replace them with the notice

+ * and other provisions required by the GPL or the LGPL. If you do not delete

+ * the provisions above, a recipient may use your version of this file under

+ * the terms of any one of the MPL, the GPL or the LGPL.

+ *

+ * ***** END LICENSE BLOCK ***** */

+define('ace/placeholder', ['require', 'exports', 'module' , 'ace/range', 'ace/lib/event_emitter', 'ace/lib/oop'], function(require, exports, module) {

+"use strict";

+

+var Range = require('./range').Range;

+var EventEmitter = require("./lib/event_emitter").EventEmitter;

+var oop = require("./lib/oop");

+

+var PlaceHolder = function(session, length, pos, others, mainClass, othersClass) {

+ var _self = this;

+ this.length = length;

+ this.session = session;

+ this.doc = session.getDocument();

+ this.mainClass = mainClass;

+ this.othersClass = othersClass;

+ this.$onUpdate = this.onUpdate.bind(this);

+ this.doc.on("change", this.$onUpdate);

+ this.$others = others;

+

+ this.$onCursorChange = function() {

+ setTimeout(function() {

+ _self.onCursorChange();

+ });

+ };

+

+ this.$pos = pos;

+ // Used for reset

+ var undoStack = session.getUndoManager().$undoStack || session.getUndoManager().$undostack || {length: -1};

+ this.$undoStackDepth = undoStack.length;

+ this.setup();

+

+ session.selection.on("changeCursor", this.$onCursorChange);

+};

+

+(function() {

+

+ oop.implement(this, EventEmitter);

+

+ this.setup = function() {

+ var _self = this;

+ var doc = this.doc;

+ var session = this.session;

+ var pos = this.$pos;

+

+ this.pos = doc.createAnchor(pos.row, pos.column);

+ this.markerId = session.addMarker(new Range(pos.row, pos.column, pos.row, pos.column + this.length), this.mainClass, null, false);

+ this.pos.on("change", function(event) {

+ session.removeMarker(_self.markerId);

+ _self.markerId = session.addMarker(new Range(event.value.row, event.value.column, event.value.row, event.value.column+_self.length), _self.mainClass, null, false);

+ });

+ this.others = [];

+ this.$others.forEach(function(other) {

+ var anchor = doc.createAnchor(other.row, other.column);

+ _self.others.push(anchor);

+ });

+ session.setUndoSelect(false);

+ };

+

+ this.showOtherMarkers = function() {

+ if(this.othersActive) return;

+ var session = this.session;

+ var _self = this;

+ this.othersActive = true;

+ this.others.forEach(function(anchor) {

+ anchor.markerId = session.addMarker(new Range(anchor.row, anchor.column, anchor.row, anchor.column+_self.length), _self.othersClass, null, false);

+ anchor.on("change", function(event) {

+ session.removeMarker(anchor.markerId);

+ anchor.markerId = session.addMarker(new Range(event.value.row, event.value.column, event.value.row, event.value.column+_self.length), _self.othersClass, null, false);

+ });

+ });

+ };

+

+ this.hideOtherMarkers = function() {

+ if(!this.othersActive) return;

+ this.othersActive = false;

+ for (var i = 0; i < this.others.length; i++) {

+ this.session.removeMarker(this.others[i].markerId);

+ }

+ };

+

+ this.onUpdate = function(event) {

+ var delta = event.data;

+ var range = delta.range;

+ if(range.start.row !== range.end.row) return;

+ if(range.start.row !== this.pos.row) return;

+ if (this.$updating) return;

+ this.$updating = true;

+ var lengthDiff = delta.action === "insertText" ? range.end.column - range.start.column : range.start.column - range.end.column;

+

+ if(range.start.column >= this.pos.column && range.start.column <= this.pos.column + this.length + 1) {

+ var distanceFromStart = range.start.column - this.pos.column;

+ this.length += lengthDiff;

+ if(!this.session.$fromUndo) {

+ if(delta.action === "insertText") {

+ for (var i = this.others.length - 1; i >= 0; i--) {

+ var otherPos = this.others[i];

+ var newPos = {row: otherPos.row, column: otherPos.column + distanceFromStart};

+ if(otherPos.row === range.start.row && range.start.column < otherPos.column)

+ newPos.column += lengthDiff;

+ this.doc.insert(newPos, delta.text);

+ }

+ } else if(delta.action === "removeText") {

+ for (var i = this.others.length - 1; i >= 0; i--) {

+ var otherPos = this.others[i];

+ var newPos = {row: otherPos.row, column: otherPos.column + distanceFromStart};

+ if(otherPos.row === range.start.row && range.start.column < otherPos.column)

+ newPos.column += lengthDiff;

+ this.doc.remove(new Range(newPos.row, newPos.column, newPos.row, newPos.column - lengthDiff));

+ }

+ }

+ // Special case: insert in beginning

+ if(range.start.column === this.pos.column && delta.action === "insertText") {

+ setTimeout(function() {

+ this.pos.setPosition(this.pos.row, this.pos.column - lengthDiff);

+ for (var i = 0; i < this.others.length; i++) {

+ var other = this.others[i];

+ var newPos = {row: other.row, column: other.column - lengthDiff};

+ if(other.row === range.start.row && range.start.column < other.column)

+ newPos.column += lengthDiff;

+ other.setPosition(newPos.row, newPos.column);

+ }

+ }.bind(this), 0);

+ }

+ else if(range.start.column === this.pos.column && delta.action === "removeText") {

+ setTimeout(function() {

+ for (var i = 0; i < this.others.length; i++) {

+ var other = this.others[i];

+ if(other.row === range.start.row && range.start.column < other.column) {

+ other.setPosition(other.row, other.column - lengthDiff);

+ }

+ }

+ }.bind(this), 0);

+ }

+ }

+ this.pos._emit("change", {value: this.pos});

+ for (var i = 0; i < this.others.length; i++) {

+ this.others[i]._emit("change", {value: this.others[i]});

+ }

+ }

+ this.$updating = false;

+ };

+

+ this.onCursorChange = function(event) {

+ if (this.$updating) return;

+ var pos = this.session.selection.getCursor();

+ if(pos.row === this.pos.row && pos.column >= this.pos.column && pos.column <= this.pos.column + this.length) {

+ this.showOtherMarkers();

+ this._emit("cursorEnter", event);

+ } else {

+ this.hideOtherMarkers();

+ this._emit("cursorLeave", event);

+ }

+ };

+

+ this.detach = function() {

+ this.session.removeMarker(this.markerId);

+ this.hideOtherMarkers();

+ this.doc.removeEventListener("change", this.$onUpdate);

+ this.session.selection.removeEventListener("changeCursor", this.$onCursorChange);

+ this.pos.detach();

+ for (var i = 0; i < this.others.length; i++) {

+ this.others[i].detach();

+ }

+ this.session.setUndoSelect(true);

+ };

+

+ this.cancel = function() {

+ if(this.$undoStackDepth === -1)

+ throw Error("Canceling placeholders only supported with undo manager attached to session.");

+ var undoManager = this.session.getUndoManager();

+ var undosRequired = (undoManager.$undoStack || undoManager.$undostack).length - this.$undoStackDepth;

+ for (var i = 0; i < undosRequired; i++) {

+ undoManager.undo(true);

+ }

+ };

+}).call(PlaceHolder.prototype);

+

+

+exports.PlaceHolder = PlaceHolder;

+});

+ background-color: #6B72E6;\

+ border-left: 1px solid black;\

+.ace-tm .ace_line .ace_storage,\

+.ace-tm .ace_line .ace_constant {\

+ color: rgb(197, 6, 11);\

+}\

+\