(http://jeditoolkit.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 ***** */
+
+__ace_shadowed__.define('pilot/fixoldbrowsers', function(require, exports, module) {
+
+// Should be the first thing, as we want to use that in this module.
+if (!Function.prototype.bind) {
+ // from MDC
+ // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind
+ Function.prototype.bind = function (obj) {
+ var slice = [].slice;
+ var args = slice.call(arguments, 1);
+ var self = this;
+ var nop = function () {};
+
+ // optimize common case
+ if (arguments.length == 1) {
+ var bound = function() {
+ return self.apply(this instanceof nop ? this : obj, arguments);
+ };
+ }
+ else {
+ var bound = function () {
+ return self.apply(
+ this instanceof nop ? this : ( obj || {} ),
+ args.concat( slice.call(arguments) )
+ );
+ };
+ }
+
+ nop.prototype = self.prototype;
+ bound.prototype = new nop();
+
+ // From Narwhal
+ bound.name = this.name;
+ bound.displayName = this.displayName;
+ bound.length = this.length;
+ bound.unbound = self;
+
+ return bound;
+ };
+}
+
+
+var F = function() {}
+var call = Function.prototype.call;
+// Shortcut for `Object.prototype.hasOwnProperty.call`.
+var owns = call.bind(Object.prototype.hasOwnProperty);
+
+// Shortcuts for getter / setter utilities if supported by JS engine.
+var getGetter, getSetter, setGetter, setSetter
+getGetter = getSetter = setGetter = setSetter = F;
+
+if (Object.prototype.__lookupGetter__)
+ getGetter = call.bind(Object.prototype.__lookupGetter__);
+if (Object.prototype.__lookupSetter__)
+ getSetter = call.bind(Object.prototype.__lookupSetter__);
+if (Object.prototype.__defineGetter__)
+ setGetter = call.bind(Object.prototype.__defineGetter__);
+if (Object.prototype.__defineSetter__)
+ setSetter = call.bind(Object.prototype.__defineSetter__);
+
+/**
+ * Array detector.
+ * Firefox 3.5 and Safari 4 have this already. Chrome 4 however ...
+ * Note to Dojo - your isArray is still broken: instanceof doesn't work with
+ * Arrays taken from a different frame/window.
+ */
+// ES5 15.4.3.2
+if (!Array.isArray) {
+ Array.isArray = function(data) {
+ return data && Object.prototype.toString.call(data) === "[object Array]";
+ };
+}
+
+// from MDC
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
+if (!Array.prototype.indexOf)
+{
+ Array.prototype.indexOf = function(searchElement /*, fromIndex */)
+ {
+ if (this === void 0 || this === null)
+ throw new TypeError();
+
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if (len === 0)
+ return -1;
+
+ var n = 0, zero = n;
+ if (arguments.length > 0) {
+ n = Number(arguments[1]);
+ if (n !== n)
+ n = 0;
+ else if (n !== 0 && n !== (1 / zero) && n !== -(1 / zero))
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+
+ if (n >= len)
+ return -1;
+
+ var k = n >= 0
+ ? n
+ : Math.max(len - Math.abs(n), 0);
+
+ for (; k < len; k++) {
+ if (k in t && t[k] === searchElement)
+ return k;
+ }
+ return -1;
+ };
+}
+
+// from MDC
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+if (!Array.prototype.lastIndexOf)
+{
+ Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/)
+ {
+ "use strict";
+
+ if (this === void 0 || this === null)
+ throw new TypeError();
+
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if (len === 0)
+ return -1;
+
+ var n = len, zero = false | 0;
+ if (arguments.length > 0)
+ {
+ n = Number(arguments[1]);
+ if (n !== n)
+ n = 0;
+ else if (n !== 0 && n !== (1 / zero) && n !== -(1 / zero))
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+
+ var k = n >= 0
+ ? Math.min(n, len - 1)
+ : len - Math.abs(n);
+
+ while (k >= 0)
+ {
+ if (k in t && t[k] === searchElement)
+ return k;
+ }
+ return -1;
+ };
+}
+
+// from MDC
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/map
+// ES5 15.4.4.19
+if (!Array.prototype.map) {
+ Array.prototype.map = function(fun /*, thisp */) {
+ if (this === void 0 || this === null)
+ throw new TypeError();
+
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if (typeof fun !== "function")
+ throw new TypeError();
+
+ res = new Array(len);
+ var thisp = arguments[1];
+ for (var i = 0; i < len; i++) {
+ if (i in t)
+ res[i] = fun.call(thisp, t[i], i, t);
+ }
+
+ return res;
+ };
+}
+
+// from MDC
+// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach
+// ES5 15.4.4.18
+if (!Array.prototype.forEach) {
+ Array.prototype.forEach = function(fun /*, thisp */) {
+ if (this === void 0 || this === null)
+ throw new TypeError();
+
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if (typeof fun !== "function")
+ throw new TypeError();
+
+ var thisp = arguments[1];
+ for (var i = 0; i < len; i++) {
+ if (i in t)
+ fun.call(thisp, t[i], i, t);
+ }
+ };
+}
+
+// ES5 15.4.4.20
+if (!Array.prototype.filter) {
+ Array.prototype.filter = function filter(callback, scope) {
+ var values = [], i, ii;
+ for (i = 0, ii = this.length; i < ii; i++) {
+ if (callback.call(scope, this[i])) values.push(this[i]);
+ }
+ return values;
+ };
+}
+
+// ES5 15.4.4.16
+if (!Array.prototype.every) {
+ Array.prototype.every = function every(callback, scope) {
+ var i, ii;
+ for (i = 0, ii = this.length; i < ii; i++) {
+ if (!callback.call(scope, this[i])) return false;
+ }
+ return true;
+ };
+}
+
+// ES5 15.4.4.17
+if (!Array.prototype.some) {
+ Array.prototype.some = function (callback, scope) {
+ var i, ii;
+ for (i = 0, ii = this.length; i < ii; i++) {
+ if (callback.call(scope, this[i])) return true;
+ }
+ return false;
+ };
+}
+
+// ES5 15.4.4.21
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduce
+if (!Array.prototype.reduce) {
+ Array.prototype.reduce = function(fun /*, initial*/) {
+ var len = this.length >>> 0;
+ if (typeof fun != "function")
+ throw new TypeError();
+
+ // no value to return if no initial value and an empty array
+ if (len == 0 && arguments.length == 1)
+ throw new TypeError();
+
+ var i = 0;
+ if (arguments.length >= 2) {
+ var rv = arguments[1];
+ } else {
+ do {
+ if (i in this) {
+ rv = this[i++];
+ break;
+ }
+
+ // if array contains no values, no initial value to return
+ if (++i >= len)
+ throw new TypeError();
+ } while (true);
+ }
+
+ for (; i < len; i++) {
+ if (i in this)
+ rv = fun.call(null, rv, this[i], i, this);
+ }
+
+ return rv;
+ };
+}
+
+// ES5 15.4.4.22
+// https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Objects/Array/reduceRight
+if (!Array.prototype.reduceRight) {
+ Array.prototype.reduceRight = function(fun /*, initial*/) {
+ var len = this.length >>> 0;
+ if (typeof fun != "function")
+ throw new TypeError();
+
+ // no value to return if no initial value, empty array
+ if (len == 0 && arguments.length == 1)
+ throw new TypeError();
+
+ var i = len - 1;
+ if (arguments.length >= 2) {
+ var rv = arguments[1];
+ } else {
+ do {
+ if (i in this) {
+ rv = this[i--];
+ break;
+ }
+
+ // if array contains no values, no initial value to return
+ if (--i < 0)
+ throw new TypeError();
+ } while (true);
+ }
+
+ for (; i >= 0; i--) {
+ if (i in this)
+ rv = fun.call(null, rv, this[i], i, this);
+ }
+
+ return rv;
+ };
+}
+
+
+/**
+ * Retrieves the list of keys on an object.
+ */
+if (!Object.keys) {
+ Object.keys = function keys(object) {
+ var name, names = [];
+ for (name in object)
+ if (owns(object, name)) names.push(name);
+
+ return names;
+ };
+}
+
+// Can not be implemented so we default to the Object.keys
+// ES5 15.2.3.4
+if (!Object.getOwnPropertyNames) {
+ Object.getOwnPropertyNames = Object.keys;
+}
+
+// ES5 15.2.3.3
+var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a non-object"
+if (!Object.getOwnPropertyDescriptor) {
+ Object.getOwnPropertyDescriptor =
+ function getOwnPropertyDescriptor(object, name) {
+ var descriptor, getter, setter;
+
+ if (typeof object !== "object" && typeof object !== "function"
+ || object === null) throw new TypeError(ERR_NON_OBJECT);
+
+ if (owns(object, name)) {
+ descriptor = { configurable: true, enumerable: true };
+ getter = descriptor.get = getGetter(object, name);
+ setter = descriptor.set = getSetter(object, name);
+ // If nor getter nor setter is not defined we default to
+ // normal value. This can mean that either it's data
+ // property or js engine does not supports getters / setters.
+ if (!getter && !setter) {
+ descriptor.writeable = true;
+ descriptor.value = object[name]
+ }
+ }
+ return descriptor
+ }
+}
+
+// Returning `__proto__` of an object or `object.constructor.prototype` for IE.
+if (!Object.getPrototypeOf) {
+ Object.getPrototypeOf = function getPrototypeOf(object) {
+ return object.__proto__ || object.constructor.prototype;
+ }
+}
+
+// ES5 15.2.3.5
+if (!Object.create) {
+ Object.create = function create(prototype, properties) {
+ var object;
+
+ if (prototype === null) {
+ object = { __proto__: null };
+ } else if (typeof prototype !== "object") {
+ throw new TypeError(prototype + " is not an object or null");
+ } else {
+ F.prototype = prototype;
+ object = new F();
+ }
+
+ if (typeof properties !== "undefined")
+ Object.defineProperties(object, properties);
+
+ return object;
+ };
+}
+
+// ES5 15.2.3.6
+if (!Object.defineProperty) {
+ Object.defineProperty = function defineProperty(object, name, descriptor) {
+ var proto, setter, getter;
+
+ if ("object" !== typeof object && "function" !== typeof object)
+ throw new TypeError(object + "is not an object");
+ if (descriptor && 'object' !== typeof descriptor)
+ throw new TypeError('Property descriptor map must be an object');
+ if ('value' in descriptor) { // if it's a data property
+ if ('get' in descriptor || 'set' in descriptor) {
+ throw new TypeError('Invalid property. "value" present on '
+ + 'property with getter or setter.');
+ }
+
+ // Swapping __proto__ with default one to avoid calling inherited
+ // getters / setters with this `name`.
+ if (proto = object.__proto__) object.__proto__ = Object.prototype;
+ // Delete property cause it may be a setter.
+ delete object[name];
+ object[name] = descriptor.value;
+ // Return __proto__ back.
+ if (proto) object.__proto__ = proto;
+ } else {
+ if (getter = descriptor.get) setGetter(object, getter);
+ if (setter = descriptor.set) setSetter(object, setter);
+ }
+ return object;
+ };
+}
+
+// ES5 15.2.3.7
+if (!Object.defineProperties) {
+ Object.defineProperties = function defineProperties(object, properties) {
+ Object.getOwnPropertyNames(properties).forEach(function (name) {
+ Object.defineProperty(object, name, properties[name]);
+ });
+ return object;
+ };
+}
+
+var passThrough = function(object) { return object };
+// ES5 15.2.3.8
+if (!Object.seal) Object.seal = passThrough;
+
+// ES5 15.2.3.9
+if (!Object.freeze) Object.freeze = passThrough;
+
+// ES5 15.2.3.10
+if (!Object.preventExtensions) Object.preventExtension = passThrough;
+
+var no = function() { return false };
+var yes = function() { return true };
+
+// ES5 15.2.3.11
+if (!Object.isSealed) Object.isSealed = no;
+// ES5 15.2.3.12
+if (!Object.isFrozen) Object.isFrozen = no;
+// ES5 15.2.3.13
+if (!Object.isExtensible) Object.isExtensible = yes;
+
+if (!String.prototype.trim) {
+ String.prototype.trim = function() {
+ return this.trimLeft().trimRight();
+ }
+}
+
+if (!String.prototype.trimRight) {
+ String.prototype.trimRight = function() {
+ return this.replace(/[\t\v\f\s\u00a0\ufeff]+$/, "");
+ }
+}
+
+if (!String.prototype.trimLeft) {
+ String.prototype.trimLeft = function() {
+ return this.replace(/^[\t\v\f\s\u00a0\ufeff]+/, "");
+ }
+}
+
+exports.globalsLoaded = true;
+
+});
+/* ***** 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):
+ * Kevin Dangoor (kdangoor@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/index', function(require, exports, module) {
+
+exports.startup = function(data, reason) {
+ require('pilot/fixoldbrowsers');
+
+ require('pilot/types/basic').startup(data, reason);
+ require('pilot/types/command').startup(data, reason);
+ require('pilot/types/settings').startup(data, reason);
+ require('pilot/commands/settings').startup(data, reason);
+ require('pilot/commands/basic').startup(data, reason);
+ // require('pilot/commands/history').startup(data, reason);
+ require('pilot/settings/canon').startup(data, reason);
+ require('pilot/canon').startup(data, reason);
+};
+
+exports.shutdown = function(data, reason) {
+ require('pilot/types/basic').shutdown(data, reason);
+ require('pilot/types/command').shutdown(data, reason);
+ require('pilot/types/settings').shutdown(data, reason);
+ require('pilot/commands/settings').shutdown(data, reason);
+ require('pilot/commands/basic').shutdown(data, reason);
+ // require('pilot/commands/history').shutdown(data, reason);
+ require('pilot/settings/canon').shutdown(data, reason);
+ require('pilot/canon').shutdown(data, reason);
+};
+
+
+});
+/* ***** 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):
+ * Joe Walker (jwalker@mozilla.com)
+ * Kevin Dangoor (kdangoor@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/types/basic', function(require, exports, module) {
+
+var types = require("pilot/types");
+var Type = types.Type;
+var Conversion = types.Conversion;
+var Status = types.Status;
+
+/**
+ * These are the basic types that we accept. They are vaguely based on the
+ * Jetpack settings system (https://wiki.mozilla.org/Labs/Jetpack/JEP/24)
+ * although clearly more restricted.
+ *
+ * In addition to these types, Jetpack also accepts range, member, password
+ * that we are thinking of adding.
+ *
+ *
This module probably should not be accessed directly, but instead used
+ * through types.js
+ */
+
+/**
+ * 'text' is the default if no type is given.
+ */
+var text = new Type();
+
+text.stringify = function(value) {
+ return value;
+};
+
+text.parse = function(value) {
+ if (typeof value != 'string') {
+ throw new Error('non-string passed to text.parse()');
+ }
+ return new Conversion(value);
+};
+
+text.name = 'text';
+
+/**
+ * We don't currently plan to distinguish between integers and floats
+ */
+var number = new Type();
+
+number.stringify = function(value) {
+ if (!value) {
+ return null;
+ }
+ return '' + value;
+};
+
+number.parse = function(value) {
+ if (typeof value != 'string') {
+ throw new Error('non-string passed to number.parse()');
+ }
+
+ if (value.replace(/\s/g, '').length === 0) {
+ return new Conversion(null, Status.INCOMPLETE, '');
+ }
+
+ var reply = new Conversion(parseInt(value, 10));
+ if (isNaN(reply.value)) {
+ reply.status = Status.INVALID;
+ reply.message = 'Can\'t convert "' + value + '" to a number.';
+ }
+
+ return reply;
+};
+
+number.decrement = function(value) {
+ return value - 1;
+};
+
+number.increment = function(value) {
+ return value + 1;
+};
+
+number.name = 'number';
+
+/**
+ * One of a known set of options
+ */
+function SelectionType(typeSpec) {
+ if (!Array.isArray(typeSpec.data) && typeof typeSpec.data !== 'function') {
+ throw new Error('instances of SelectionType need typeSpec.data to be an array or function that returns an array:' + JSON.stringify(typeSpec));
+ }
+ Object.keys(typeSpec).forEach(function(key) {
+ this[key] = typeSpec[key];
+ }, this);
+};
+
+SelectionType.prototype = new Type();
+
+SelectionType.prototype.stringify = function(value) {
+ return value;
+};
+
+SelectionType.prototype.parse = function(str) {
+ if (typeof str != 'string') {
+ throw new Error('non-string passed to parse()');
+ }
+ if (!this.data) {
+ throw new Error('Missing data on selection type extension.');
+ }
+ var data = (typeof(this.data) === 'function') ? this.data() : this.data;
+
+ // The matchedValue could be the boolean value false
+ var hasMatched = false;
+ var matchedValue;
+ var completions = [];
+ data.forEach(function(option) {
+ if (str == option) {
+ matchedValue = this.fromString(option);
+ hasMatched = true;
+ }
+ else if (option.indexOf(str) === 0) {
+ completions.push(this.fromString(option));
+ }
+ }, this);
+
+ if (hasMatched) {
+ return new Conversion(matchedValue);
+ }
+ else {
+ // This is something of a hack it basically allows us to tell the
+ // setting type to forget its last setting hack.
+ if (this.noMatch) {
+ this.noMatch();
+ }
+
+ if (completions.length > 0) {
+ var msg = 'Possibilities' +
+ (str.length === 0 ? '' : ' for \'' + str + '\'');
+ return new Conversion(null, Status.INCOMPLETE, msg, completions);
+ }
+ else {
+ var msg = 'Can\'t use \'' + str + '\'.';
+ return new Conversion(null, Status.INVALID, msg, completions);
+ }
+ }
+};
+
+SelectionType.prototype.fromString = function(str) {
+ return str;
+};
+
+SelectionType.prototype.decrement = function(value) {
+ var data = (typeof this.data === 'function') ? this.data() : this.data;
+ var index;
+ if (value == null) {
+ index = data.length - 1;
+ }
+ else {
+ var name = this.stringify(value);
+ var index = data.indexOf(name);
+ index = (index === 0 ? data.length - 1 : index - 1);
+ }
+ return this.fromString(data[index]);
+};
+
+SelectionType.prototype.increment = function(value) {
+ var data = (typeof this.data === 'function') ? this.data() : this.data;
+ var index;
+ if (value == null) {
+ index = 0;
+ }
+ else {
+ var name = this.stringify(value);
+ var index = data.indexOf(name);
+ index = (index === data.length - 1 ? 0 : index + 1);
+ }
+ return this.fromString(data[index]);
+};
+
+SelectionType.prototype.name = 'selection';
+
+/**
+ * SelectionType is a base class for other types
+ */
+exports.SelectionType = SelectionType;
+
+/**
+ * true/false values
+ */
+var bool = new SelectionType({
+ name: 'bool',
+ data: [ 'true', 'false' ],
+ stringify: function(value) {
+ return '' + value;
+ },
+ fromString: function(str) {
+ return str === 'true' ? true : false;
+ }
+});
+
+
+/**
+ * A we don't know right now, but hope to soon.
+ */
+function DeferredType(typeSpec) {
+ if (typeof typeSpec.defer !== 'function') {
+ throw new Error('Instances of DeferredType need typeSpec.defer to be a function that returns a type');
+ }
+ Object.keys(typeSpec).forEach(function(key) {
+ this[key] = typeSpec[key];
+ }, this);
+};
+
+DeferredType.prototype = new Type();
+
+DeferredType.prototype.stringify = function(value) {
+ return this.defer().stringify(value);
+};
+
+DeferredType.prototype.parse = function(value) {
+ return this.defer().parse(value);
+};
+
+DeferredType.prototype.decrement = function(value) {
+ var deferred = this.defer();
+ return (deferred.decrement ? deferred.decrement(value) : undefined);
+};
+
+DeferredType.prototype.increment = function(value) {
+ var deferred = this.defer();
+ return (deferred.increment ? deferred.increment(value) : undefined);
+};
+
+DeferredType.prototype.name = 'deferred';
+
+/**
+ * DeferredType is a base class for other types
+ */
+exports.DeferredType = DeferredType;
+
+
+/**
+ * A set of objects of the same type
+ */
+function ArrayType(typeSpec) {
+ if (typeSpec instanceof Type) {
+ this.subtype = typeSpec;
+ }
+ else if (typeof typeSpec === 'string') {
+ this.subtype = types.getType(typeSpec);
+ if (this.subtype == null) {
+ throw new Error('Unknown array subtype: ' + typeSpec);
+ }
+ }
+ else {
+ throw new Error('Can\' handle array subtype');
+ }
+};
+
+ArrayType.prototype = new Type();
+
+ArrayType.prototype.stringify = function(values) {
+ // TODO: Check for strings with spaces and add quotes
+ return values.join(' ');
+};
+
+ArrayType.prototype.parse = function(value) {
+ return this.defer().parse(value);
+};
+
+ArrayType.prototype.name = 'array';
+
+/**
+ * Registration and de-registration.
+ */
+exports.startup = function() {
+ types.registerType(text);
+ types.registerType(number);
+ types.registerType(bool);
+ types.registerType(SelectionType);
+ types.registerType(DeferredType);
+ types.registerType(ArrayType);
+};
+
+exports.shutdown = function() {
+ types.unregisterType(text);
+ types.unregisterType(number);
+ types.unregisterType(bool);
+ types.unregisterType(SelectionType);
+ types.unregisterType(DeferredType);
+ types.unregisterType(ArrayType);
+};
+
+
+});
+/* ***** 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 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):
+ * Joe Walker (jwalker@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/types', function(require, exports, module) {
+
+/**
+ * Some types can detect validity, that is to say they can distinguish between
+ * valid and invalid values.
+ * TODO: Change these constants to be numbers for more performance?
+ */
+var Status = {
+ /**
+ * The conversion process worked without any problem, and the value is
+ * valid. There are a number of failure states, so the best way to check
+ * for failure is (x !== Status.VALID)
+ */
+ VALID: {
+ toString: function() { return 'VALID'; },
+ valueOf: function() { return 0; }
+ },
+
+ /**
+ * A conversion process failed, however it was noted that the string
+ * provided to 'parse()' could be VALID by the addition of more characters,
+ * so the typing may not be actually incorrect yet, just unfinished.
+ * @see Status.INVALID
+ */
+ INCOMPLETE: {
+ toString: function() { return 'INCOMPLETE'; },
+ valueOf: function() { return 1; }
+ },
+
+ /**
+ * The conversion process did not work, the value should be null and a
+ * reason for failure should have been provided. In addition some completion
+ * values may be available.
+ * @see Status.INCOMPLETE
+ */
+ INVALID: {
+ toString: function() { return 'INVALID'; },
+ valueOf: function() { return 2; }
+ },
+
+ /**
+ * A combined status is the worser of the provided statuses
+ */
+ combine: function(statuses) {
+ var combined = Status.VALID;
+ for (var i = 0; i < arguments; i++) {
+ if (arguments[i] > combined) {
+ combined = arguments[i];
+ }
+ }
+ return combined;
+ }
+};
+exports.Status = Status;
+
+/**
+ * The type.parse() method returns a Conversion to inform the user about not
+ * only the result of a Conversion but also about what went wrong.
+ * We could use an exception, and throw if the conversion failed, but that
+ * seems to violate the idea that exceptions should be exceptional. Typos are
+ * not. Also in order to store both a status and a message we'd still need
+ * some sort of exception type...
+ */
+function Conversion(value, status, message, predictions) {
+ /**
+ * The result of the conversion process. Will be null if status != VALID
+ */
+ this.value = value;
+
+ /**
+ * The status of the conversion.
+ * @see Status
+ */
+ this.status = status || Status.VALID;
+
+ /**
+ * A message to go with the conversion. This could be present for any status
+ * including VALID in the case where we want to note a warning for example.
+ * I18N: On the one hand this nasty and un-internationalized, however with
+ * a command line it is hard to know where to start.
+ */
+ this.message = message;
+
+ /**
+ * A array of strings which are the systems best guess at better inputs than
+ * the one presented.
+ * We generally expect there to be about 7 predictions (to match human list
+ * comprehension ability) however it is valid to provide up to about 20,
+ * or less. It is the job of the predictor to decide a smart cut-off.
+ * For example if there are 4 very good matches and 4 very poor ones,
+ * probably only the 4 very good matches should be presented.
+ */
+ this.predictions = predictions || [];
+}
+exports.Conversion = Conversion;
+
+/**
+ * Most of our types are 'static' e.g. there is only one type of 'text', however
+ * some types like 'selection' and 'deferred' are customizable. The basic
+ * Type type isn't useful, but does provide documentation about what types do.
+ */
+function Type() {
+};
+Type.prototype = {
+ /**
+ * Convert the given value to a string representation.
+ * Where possible, there should be round-tripping between values and their
+ * string representations.
+ */
+ stringify: function(value) { throw new Error("not implemented"); },
+
+ /**
+ * Convert the given str to an instance of this type.
+ * Where possible, there should be round-tripping between values and their
+ * string representations.
+ * @return Conversion
+ */
+ parse: function(str) { throw new Error("not implemented"); },
+
+ /**
+ * The plug-in system, and other things need to know what this type is
+ * called. The name alone is not enough to fully specify a type. Types like
+ * 'selection' and 'deferred' need extra data, however this function returns
+ * only the name, not the extra data.
+ *
In old bespin, equality was based on the name. This may turn out to be
+ * important in Ace too.
+ */
+ name: undefined,
+
+ /**
+ * If there is some concept of a higher value, return it,
+ * otherwise return undefined.
+ */
+ increment: function(value) {
+ return undefined;
+ },
+
+ /**
+ * If there is some concept of a lower value, return it,
+ * otherwise return undefined.
+ */
+ decrement: function(value) {
+ return undefined;
+ },
+
+ /**
+ * There is interesting information (like predictions) in a conversion of
+ * nothing, the output of this can sometimes be customized.
+ * @return Conversion
+ */
+ getDefault: function() {
+ return this.parse('');
+ }
+};
+exports.Type = Type;
+
+/**
+ * Private registry of types
+ * Invariant: types[name] = type.name
+ */
+var types = {};
+
+/**
+ * Add a new type to the list available to the system.
+ * You can pass 2 things to this function - either an instance of Type, in
+ * which case we return this instance when #getType() is called with a 'name'
+ * that matches type.name.
+ * Also you can pass in a constructor (i.e. function) in which case when
+ * #getType() is called with a 'name' that matches Type.prototype.name we will
+ * pass the typeSpec into this constructor. See #reconstituteType().
+ */
+exports.registerType = function(type) {
+ if (typeof type === 'object') {
+ if (type instanceof Type) {
+ if (!type.name) {
+ throw new Error('All registered types must have a name');
+ }
+ types[type.name] = type;
+ }
+ else {
+ throw new Error('Can\'t registerType using: ' + type);
+ }
+ }
+ else if (typeof type === 'function') {
+ if (!type.prototype.name) {
+ throw new Error('All registered types must have a name');
+ }
+ types[type.prototype.name] = type;
+ }
+ else {
+ throw new Error('Unknown type: ' + type);
+ }
+};
+
+exports.registerTypes = function registerTypes(types) {
+ Object.keys(types).forEach(function (name) {
+ var type = types[name];
+ type.name = name;
+ exports.registerType(type);
+ });
+};
+
+/**
+ * Remove a type from the list available to the system
+ */
+exports.deregisterType = function(type) {
+ delete types[type.name];
+};
+
+/**
+ * See description of #exports.registerType()
+ */
+function reconstituteType(name, typeSpec) {
+ if (name.substr(-2) === '[]') { // i.e. endsWith('[]')
+ var subtypeName = name.slice(0, -2);
+ return new types['array'](subtypeName);
+ }
+
+ var type = types[name];
+ if (typeof type === 'function') {
+ type = new type(typeSpec);
+ }
+ return type;
+}
+
+/**
+ * Find a type, previously registered using #registerType()
+ */
+exports.getType = function(typeSpec) {
+ if (typeof typeSpec === 'string') {
+ return reconstituteType(typeSpec);
+ }
+
+ if (typeof typeSpec === 'object') {
+ if (!typeSpec.name) {
+ throw new Error('Missing \'name\' member to typeSpec');
+ }
+ return reconstituteType(typeSpec.name, typeSpec);
+ }
+
+ throw new Error('Can\'t extract type from ' + typeSpec);
+};
+
+
+});
+/* ***** 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):
+ * Joe Walker (jwalker@mozilla.com)
+ * Kevin Dangoor (kdangoor@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/types/command', function(require, exports, module) {
+
+var canon = require("pilot/canon");
+var SelectionType = require("pilot/types/basic").SelectionType;
+var types = require("pilot/types");
+
+
+/**
+ * Select from the available commands
+ */
+var command = new SelectionType({
+ name: 'command',
+ data: function() {
+ return canon.getCommandNames();
+ },
+ stringify: function(command) {
+ return command.name;
+ },
+ fromString: function(str) {
+ return canon.getCommand(str);
+ }
+});
+
+
+/**
+ * Registration and de-registration.
+ */
+exports.startup = function() {
+ types.registerType(command);
+};
+
+exports.shutdown = function() {
+ types.unregisterType(command);
+};
+
+
+});
+/* ***** 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):
+ * Joe Walker (jwalker@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/canon', function(require, exports, module) {
+
+var console = require('pilot/console');
+var Trace = require('pilot/stacktrace').Trace;
+var oop = require('pilot/oop');
+var EventEmitter = require('pilot/event_emitter').EventEmitter;
+var catalog = require('pilot/catalog');
+var Status = require('pilot/types').Status;
+var types = require('pilot/types');
+var lang = require('pilot/lang');
+
+/*
+// TODO: this doesn't belong here - or maybe anywhere?
+var dimensionsChangedExtensionSpec = {
+ name: 'dimensionsChanged',
+ description: 'A dimensionsChanged is a way to be notified of ' +
+ 'changes to the dimension of Skywriter'
+};
+exports.startup = function(data, reason) {
+ catalog.addExtensionSpec(commandExtensionSpec);
+};
+exports.shutdown = function(data, reason) {
+ catalog.removeExtensionSpec(commandExtensionSpec);
+};
+*/
+
+var commandExtensionSpec = {
+ name: 'command',
+ description: 'A command is a bit of functionality with optional ' +
+ 'typed arguments which can do something small like moving ' +
+ 'the cursor around the screen, or large like cloning a ' +
+ 'project from VCS.',
+ indexOn: 'name'
+};
+
+exports.startup = function(data, reason) {
+ // TODO: this is probably all kinds of evil, but we need something working
+ catalog.addExtensionSpec(commandExtensionSpec);
+};
+
+exports.shutdown = function(data, reason) {
+ catalog.removeExtensionSpec(commandExtensionSpec);
+};
+
+/**
+ * Manage a list of commands in the current canon
+ */
+
+/**
+ * A Command is a discrete action optionally with a set of ways to customize
+ * how it happens. This is here for documentation purposes.
+ * TODO: Document better
+ */
+var thingCommand = {
+ name: 'thing',
+ description: 'thing is an example command',
+ params: [{
+ name: 'param1',
+ description: 'an example parameter',
+ type: 'text',
+ defaultValue: null
+ }],
+ exec: function(env, args, request) {
+ thing();
+ }
+};
+
+/**
+ * A lookup hash of our registered commands
+ */
+var commands = {};
+
+/**
+ * A sorted list of command names, we regularly want them in order, so pre-sort
+ */
+var commandNames = [];
+
+/**
+ * This registration method isn't like other Ace registration methods because
+ * it doesn't return a decorated command because there is no functional
+ * decoration to be done.
+ * TODO: Are we sure that in the future there will be no such decoration?
+ */
+function addCommand(command) {
+ if (!command.name) {
+ throw new Error('All registered commands must have a name');
+ }
+ if (command.params == null) {
+ command.params = [];
+ }
+ if (!Array.isArray(command.params)) {
+ throw new Error('command.params must be an array in ' + command.name);
+ }
+ // Replace the type
+ command.params.forEach(function(param) {
+ if (!param.name) {
+ throw new Error('In ' + command.name + ': all params must have a name');
+ }
+ upgradeType(command.name, param);
+ }, this);
+ commands[command.name] = command;
+
+ commandNames.push(command.name);
+ commandNames.sort();
+};
+
+function upgradeType(name, param) {
+ var lookup = param.type;
+ param.type = types.getType(lookup);
+ if (param.type == null) {
+ throw new Error('In ' + name + '/' + param.name +
+ ': can\'t find type for: ' + JSON.stringify(lookup));
+ }
+}
+
+function removeCommand(command) {
+ var name = (typeof command === 'string' ? command : command.name);
+ delete commands[name];
+ lang.arrayRemove(commandNames, name);
+};
+
+function getCommand(name) {
+ return commands[name];
+};
+
+function getCommandNames() {
+ return commandNames;
+};
+
+/**
+ * Entry point for keyboard accelerators or anything else that knows
+ * everything it needs to about the command params
+ * @param command Either a command, or the name of one
+ */
+function exec(command, env, args, typed) {
+ if (typeof command === 'string') {
+ command = commands[command];
+ }
+ if (!command) {
+ // TODO: Should we complain more than returning false?
+ return false;
+ }
+
+ var request = new Request({
+ command: command,
+ args: args,
+ typed: typed
+ });
+ command.exec(env, args || {}, request);
+ return true;
+};
+
+exports.removeCommand = removeCommand;
+exports.addCommand = addCommand;
+exports.getCommand = getCommand;
+exports.getCommandNames = getCommandNames;
+exports.exec = exec;
+exports.upgradeType = upgradeType;
+
+
+/**
+ * We publish a 'output' event whenever new command begins output
+ * TODO: make this more obvious
+ */
+oop.implement(exports, EventEmitter);
+
+
+/**
+ * Current requirements are around displaying the command line, and provision
+ * of a 'history' command and cursor up|down navigation of history.
+ *
Future requirements could include:
+ *
+ * - Multiple command lines
+ *
- The ability to recall key presses (i.e. requests with no output) which
+ * will likely be needed for macro recording or similar
+ *
- The ability to store the command history either on the server or in the
+ * browser local storage.
+ *
+ * The execute() command doesn't really live here, except as part of that
+ * last future requirement, and because it doesn't really have anywhere else to
+ * live.
+ */
+
+/**
+ * The array of requests that wish to announce their presence
+ */
+var requests = [];
+
+/**
+ * How many requests do we store?
+ */
+var maxRequestLength = 100;
+
+/**
+ * To create an invocation, you need to do something like this (all the ctor
+ * args are optional):
+ *
+ * var request = new Request({
+ * command: command,
+ * args: args,
+ * typed: typed
+ * });
+ *
+ * @constructor
+ */
+function Request(options) {
+ options = options || {};
+
+ // Will be used in the keyboard case and the cli case
+ this.command = options.command;
+
+ // Will be used only in the cli case
+ this.args = options.args;
+ this.typed = options.typed;
+
+ // Have we been initialized?
+ this._begunOutput = false;
+
+ this.start = new Date();
+ this.end = null;
+ this.completed = false;
+ this.error = false;
+};
+
+oop.implement(Request.prototype, EventEmitter);
+
+/**
+ * Lazy init to register with the history should only be done on output.
+ * init() is expensive, and won't be used in the majority of cases
+ */
+Request.prototype._beginOutput = function() {
+ this._begunOutput = true;
+ this.outputs = [];
+
+ requests.push(this);
+ // This could probably be optimized with some maths, but 99.99% of the
+ // time we will only be off by one, and I'm feeling lazy.
+ while (requests.length > maxRequestLength) {
+ requests.shiftObject();
+ }
+
+ exports._dispatchEvent('output', { requests: requests, request: this });
+};
+
+/**
+ * Sugar for:
+ * request.error = true; request.done(output);
+ */
+Request.prototype.doneWithError = function(content) {
+ this.error = true;
+ this.done(content);
+};
+
+/**
+ * Declares that this function will not be automatically done when
+ * the command exits
+ */
+Request.prototype.async = function() {
+ if (!this._begunOutput) {
+ this._beginOutput();
+ }
+};
+
+/**
+ * Complete the currently executing command with successful output.
+ * @param output Either DOM node, an SproutCore element or something that
+ * can be used in the content of a DIV to create a DOM node.
+ */
+Request.prototype.output = function(content) {
+ if (!this._begunOutput) {
+ this._beginOutput();
+ }
+
+ if (typeof content !== 'string' && !(content instanceof Node)) {
+ content = content.toString();
+ }
+
+ this.outputs.push(content);
+ this._dispatchEvent('output', {});
+
+ return this;
+};
+
+/**
+ * All commands that do output must call this to indicate that the command
+ * has finished execution.
+ */
+Request.prototype.done = function(content) {
+ this.completed = true;
+ this.end = new Date();
+ this.duration = this.end.getTime() - this.start.getTime();
+
+ if (content) {
+ this.output(content);
+ }
+
+ this._dispatchEvent('output', {});
+};
+exports.Request = Request;
+
+
+});
+/* ***** 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):
+ * Joe Walker (jwalker@mozilla.com)
+ * Patrick Walton (pwalton@mozilla.com)
+ * Julian Viereck (jviereck@mozilla.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 ***** */
+__ace_shadowed__.define('pilot/console', function(require, exports, module) {
+
+/**
+ * This object represents a "safe console" object that forwards debugging
+ * messages appropriately without creating a dependency on Firebug in Firefox.
+ */
+
+var noop = function() {};
+
+// These are the functions that are available in Chrome 4/5, Safari 4
+// and Firefox 3.6. Don't add to this list without checking browser support
+var NAMES = [
+ "assert", "count", "debug", "dir", "dirxml", "error", "group", "groupEnd",
+ "info", "log", "profile", "profileEnd", "time", "timeEnd", "trace", "warn"
+];
+
+if (typeof(window) === 'undefined') {
+ // We're in a web worker. Forward to the main thread so the messages
+ // will show up.
+ NAMES.forEach(function(name) {
+ exports[name] = function() {
+ var args = Array.prototype.slice.call(arguments);
+ var msg = { op: 'log', method: name, args: args };
+ postMessage(JSON.stringify(msg));
+ };
+ });
+} else {
+ // For each of the console functions, copy them if they exist, stub if not
+ NAMES.forEach(function(name) {
+ if (window.console && window.console[name]) {
+ exports[name] = Function.prototype.bind.call(window.console[name], window.console);
+ } else {
+ exports[name] = noop;
+ }
+ });
+}
+
+});
+__ace_shadowed__.define('pilot/stacktrace', function(require, exports, module) {
+
+var ua = require("pilot/useragent");
+var console = require('pilot/console');
+
+// Changed to suit the specific needs of running within Skywriter
+
+// Domain Public by Eric Wendelin http://eriwen.com/ (2008)
+// Luke Smith http://lucassmith.name/ (2008)
+// Loic Dachary (2008)
+// Johan Euphrosine (2008)
+// Øyvind Sean Kinsey http://kinsey.no/blog
+//
+// Information and discussions
+// http://jspoker.pokersource.info/skin/test-printstacktrace.html
+// http://eriwen.com/javascript/js-stack-trace/
+// http://eriwen.com/javascript/stacktrace-update/
+// http://pastie.org/253058
+// http://browsershots.org/http://jspoker.pokersource.info/skin/test-printstacktrace.html
+//
+
+//
+// guessFunctionNameFromLines comes from firebug
+//
+// Software License Agreement (BSD License)
+//
+// Copyright (c) 2007, Parakey Inc.
+// All rights reserved.
+//
+// Redistribution and use of this software in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above
+// copyright notice, this list of conditions and the
+// following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the
+// following disclaimer in the documentation and/or other
+// materials provided with the distribution.
+//
+// * Neither the name of Parakey Inc. nor the names of its
+// contributors may be used to endorse or promote products
+// derived from this software without specific prior
+// written permission of Parakey Inc.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+// FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+
+/**
+ * Different browsers create stack traces in different ways.
+ * Feature Browser detection baby ;).
+ */
+var mode = (function() {
+
+ // We use SC's browser detection here to avoid the "break on error"
+ // functionality provided by Firebug. Firebug tries to do the right
+ // thing here and break, but it happens every time you load the page.
+ // bug 554105
+ if (ua.isGecko) {
+ return 'firefox';
+ } else if (ua.isOpera) {
+ return 'opera';
+ } else {
+ return 'other';
+ }
+
+ // SC doesn't do any detection of Chrome at this time.
+
+ // this is the original feature detection code that is used as a
+ // fallback.
+ try {
+ (0)();
+ } catch (e) {
+ if (e.arguments) {
+ return 'chrome';
+ }
+ if (e.stack) {
+ return 'firefox';
+ }
+ if (window.opera && !('stacktrace' in e)) { //Opera 9-
+ return 'opera';
+ }
+ }
+ return 'other';
+})();
+
+/**
+ *
+ */
+function stringifyArguments(args) {
+ for (var i = 0; i < args.length; ++i) {
+ var argument = args[i];
+ if (typeof argument == 'object') {
+ args[i] = '#object';
+ } else if (typeof argument == 'function') {
+ args[i] = '#function';
+ } else if (typeof argument == 'string') {
+ args[i] = '"' + argument + '"';
+ }
+ }
+ return args.join(',');
+}
+
+/**
+ * Extract a stack trace from the format emitted by each browser.
+ */
+var decoders = {
+ chrome: function(e) {
+ var stack = e.stack;
+ if (!stack) {
+ console.log(e);
+ return [];
+ }
+ return stack.replace(/^.*?\n/, '').
+ replace(/^.*?\n/, '').
+ replace(/^.*?\n/, '').
+ replace(/^[^\(]+?[\n$]/gm, '').
+ replace(/^\s+at\s+/gm, '').
+ replace(/^Object.\s*\(/gm, '{anonymous}()@').
+ split('\n');
+ },
+
+ firefox: function(e) {
+ var stack = e.stack;
+ if (!stack) {
+ console.log(e);
+ return [];
+ }
+ // stack = stack.replace(/^.*?\n/, '');
+ stack = stack.replace(/(?:\n@:0)?\s+$/m, '');
+ stack = stack.replace(/^\(/gm, '{anonymous}(');
+ return stack.split('\n');
+ },
+
+ // Opera 7.x and 8.x only!
+ opera: function(e) {
+ var lines = e.message.split('\n'), ANON = '{anonymous}',
+ lineRE = /Line\s+(\d+).*?script\s+(http\S+)(?:.*?in\s+function\s+(\S+))?/i, i, j, len;
+
+ for (i = 4, j = 0, len = lines.length; i < len; i += 2) {
+ if (lineRE.test(lines[i])) {
+ lines[j++] = (RegExp.$3 ? RegExp.$3 + '()@' + RegExp.$2 + RegExp.$1 : ANON + '()@' + RegExp.$2 + ':' + RegExp.$1) +
+ ' -- ' +
+ lines[i + 1].replace(/^\s+/, '');
+ }
+ }
+
+ lines.splice(j, lines.length - j);
+ return lines;
+ },
+
+ // Safari, Opera 9+, IE, and others
+ other: function(curr) {
+ var ANON = '{anonymous}', fnRE = /function\s*([\w\-$]+)?\s*\(/i, stack = [], j = 0, fn, args;
+
+ var maxStackSize = 10;
+ while (curr && stack.length < maxStackSize) {
+ fn = fnRE.test(curr.toString()) ? RegExp.$1 || ANON : ANON;
+ args = Array.prototype.slice.call(curr['arguments']);
+ stack[j++] = fn + '(' + stringifyArguments(args) + ')';
+
+ //Opera bug: if curr.caller does not exist, Opera returns curr (WTF)
+ if (curr === curr.caller && window.opera) {
+ //TODO: check for same arguments if possible
+ break;
+ }
+ curr = curr.caller;
+ }
+ return stack;
+ }
+};
+
+/**
+ *
+ */
+function NameGuesser() {
+}
+
+NameGuesser.prototype = {
+
+ sourceCache: {},
+
+ ajax: function(url) {
+ var req = this.createXMLHTTPObject();
+ if (!req) {
+ return;
+ }
+ req.open('GET', url, false);
+ req.setRequestHeader('User-Agent', 'XMLHTTP/1.0');
+ req.send('');
+ return req.responseText;
+ },
+
+ createXMLHTTPObject: function() {
+ // Try XHR methods in order and store XHR factory
+ var xmlhttp, XMLHttpFactories = [
+ function() {
+ return new XMLHttpRequest();
+ }, function() {
+ return new ActiveXObject('Msxml2.XMLHTTP');
+ }, function() {
+ return new ActiveXObject('Msxml3.XMLHTTP');
+ }, function() {
+ return new ActiveXObject('Microsoft.XMLHTTP');
+ }
+ ];
+ for (var i = 0; i < XMLHttpFactories.length; i++) {
+ try {
+ xmlhttp = XMLHttpFactories[i]();
+ // Use memoization to cache the factory
+ this.createXMLHTTPObject = XMLHttpFactories[i];
+ return xmlhttp;
+ } catch (e) {}
+ }
+ },
+
+ getSource: function(url) {
+ if (!(url in this.sourceCache)) {
+ this.sourceCache[url] = this.ajax(url).split('\n');
+ }
+ return this.sourceCache[url];
+ },
+
+ guessFunctions: function(stack) {
+ for (var i = 0; i < stack.length; ++i) {
+ var reStack = /{anonymous}\(.*\)@(\w+:\/\/([-\w\.]+)+(:\d+)?[^:]+):(\d+):?(\d+)?/;
+ var frame = stack[i], m = reStack.exec(frame);
+ if (m) {
+ var file = m[1], lineno = m[4]; //m[7] is character position in Chrome
+ if (file && lineno) {
+ var functionName = this.guessFunctionName(file, lineno);
+ stack[i] = frame.replace('{anonymous}', functionName);
+ }
+ }
+ }
+ return stack;
+ },
+
+ guessFunctionName: function(url, lineNo) {
+ try {
+ return this.guessFunctionNameFromLines(lineNo, this.getSource(url));
+ } catch (e) {
+ return 'getSource failed with url: ' + url + ', exception: ' + e.toString();
+ }
+ },
+
+ guessFunctionNameFromLines: function(lineNo, source) {
+ var reFunctionArgNames = /function ([^(]*)\(([^)]*)\)/;
+ var reGuessFunction = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*(function|eval|new Function)/;
+ // Walk backwards from the first line in the function until we find the line which
+ // matches the pattern above, which is the function definition
+ var line = '', maxLines = 10;
+ for (var i = 0; i < maxLines; ++i) {
+ line = source[lineNo - i] + line;
+ if (line !== undefined) {
+ var m = reGuessFunction.exec(line);
+ if (m) {
+ return m[1];
+ }
+ else {
+ m = reFunctionArgNames.exec(line);
+ }
+ if (m && m[1]) {
+ return m[1];
+ }
+ }
+ }
+ return '(?)';
+ }
+};
+
+var guesser = new NameGuesser();
+
+var frameIgnorePatterns = [
+ /http:\/\/localhost:4020\/sproutcore.js:/
+];
+
+exports.ignoreFramesMatching = function(regex) {
+ frameIgnorePatterns.push(regex);
+};
+
+/**
+ * Create a stack trace from an exception
+ * @param ex {Error} The error to create a stacktrace from (optional)
+ * @param guess {Boolean} If we should try to resolve the names of anonymous functions
+ */
+exports.Trace = function Trace(ex, guess) {
+ this._ex = ex;
+ this._stack = decoders[mode](ex);
+
+ if (guess) {
+ this._stack = guesser.guessFunctions(this._stack);
+ }
+};
+
+/**
+ * Log to the console a number of lines (default all of them)
+ * @param lines {number} Maximum number of lines to wrote to console
+ */
+exports.Trace.prototype.log = function(lines) {
+ if (lines <= 0) {
+ // You aren't going to have more lines in your stack trace than this
+ // and it still fits in a 32bit integer
+ lines = 999999999;
+ }
+
+ var printed = 0;
+ for (var i = 0; i < this._stack.length && printed < lines; i++) {
+ var frame = this._stack[i];
+ var display = true;
+ frameIgnorePatterns.forEach(function(regex) {
+ if (regex.test(frame)) {
+ display = false;
+ }
+ });
+ if (display) {
+ console.debug(frame);
+ printed++;
+ }
+ }
+};
+
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('pilot/useragent', function(require, exports, module) {
+
+var os = (navigator.platform.match(/mac|win|linux/i) || ["other"])[0].toLowerCase();
+var ua = navigator.userAgent;
+var av = navigator.appVersion;
+
+/** Is the user using a browser that identifies itself as Windows */
+exports.isWin = (os == "win");
+
+/** Is the user using a browser that identifies itself as Mac OS */
+exports.isMac = (os == "mac");
+
+/** Is the user using a browser that identifies itself as Linux */
+exports.isLinux = (os == "linux");
+
+exports.isIE = ! + "\v1";
+
+/** Is this Firefox or related? */
+exports.isGecko = exports.isMozilla = window.controllers && window.navigator.product === "Gecko";
+
+/** oldGecko == rev < 2.0 **/
+exports.isOldGecko = exports.isGecko && /rv\:1/.test(navigator.userAgent);
+
+/** Is this Opera */
+exports.isOpera = window.opera && Object.prototype.toString.call(window.opera) == "[object Opera]";
+
+/** Is the user using a browser that identifies itself as WebKit */
+exports.isWebKit = parseFloat(ua.split("WebKit/")[1]) || undefined;
+
+exports.isAIR = ua.indexOf("AdobeAIR") >= 0;
+
+exports.isIPad = ua.indexOf("iPad") >= 0;
+
+/**
+ * I hate doing this, but we need some way to determine if the user is on a Mac
+ * The reason is that users have different expectations of their key combinations.
+ *
+ * Take copy as an example, Mac people expect to use CMD or APPLE + C
+ * Windows folks expect to use CTRL + C
+ */
+exports.OS = {
+ LINUX: 'LINUX',
+ MAC: 'MAC',
+ WINDOWS: 'WINDOWS'
+};
+
+/**
+ * Return an exports.OS constant
+ */
+exports.getOS = function() {
+ if (exports.isMac) {
+ return exports.OS['MAC'];
+ } else if (exports.isLinux) {
+ return exports.OS['LINUX'];
+ } else {
+ return exports.OS['WINDOWS'];
+ }
+};
+
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('pilot/oop', function(require, exports, module) {
+
+exports.inherits = (function() {
+ var tempCtor = function() {};
+ return function(ctor, superCtor) {
+ tempCtor.prototype = superCtor.prototype;
+ ctor.super_ = superCtor.prototype;
+ ctor.prototype = new tempCtor();
+ ctor.prototype.constructor = ctor;
+ }
+}());
+
+exports.mixin = function(obj, mixin) {
+ for (var key in mixin) {
+ obj[key] = mixin[key];
+ }
+};
+
+exports.implement = function(proto, mixin) {
+ exports.mixin(proto, mixin);
+};
+
+});
+/* 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
+ * Irakli Gozalishvili (http://jeditoolkit.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 ***** */
+
+__ace_shadowed__.define('pilot/event_emitter', function(require, exports, module) {
+
+var EventEmitter = {};
+
+EventEmitter._emit =
+EventEmitter._dispatchEvent = function(eventName, e) {
+ this._eventRegistry = this._eventRegistry || {};
+
+ var listeners = this._eventRegistry[eventName];
+ if (!listeners || !listeners.length) return;
+
+ var e = e || {};
+ e.type = eventName;
+
+ for (var i=0; i
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('pilot/lang', function(require, exports, module) {
+
+exports.stringReverse = function(string) {
+ return string.split("").reverse().join("");
+};
+
+exports.stringRepeat = function (string, count) {
+ return new Array(count + 1).join(string);
+};
+
+exports.copyObject = function(obj) {
+ var copy = {};
+ for (var key in obj) {
+ copy[key] = obj[key];
+ }
+ return copy;
+};
+
+exports.arrayToMap = function(arr) {
+ var map = {};
+ for (var i=0; i (http://jeditoolkit.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 ***** */
+
+__ace_shadowed__.define('pilot/settings', function(require, exports, module) {
+
+/**
+ * This plug-in manages settings.
+ */
+
+var console = require('pilot/console');
+var oop = require('pilot/oop');
+var types = require('pilot/types');
+var EventEmitter = require('pilot/event_emitter').EventEmitter;
+var catalog = require('pilot/catalog');
+
+var settingExtensionSpec = {
+ name: 'setting',
+ description: 'A setting is something that the application offers as a ' +
+ 'way to customize how it works',
+ register: 'env.settings.addSetting',
+ indexOn: 'name'
+};
+
+exports.startup = function(data, reason) {
+ catalog.addExtensionSpec(settingExtensionSpec);
+};
+
+exports.shutdown = function(data, reason) {
+ catalog.removeExtensionSpec(settingExtensionSpec);
+};
+
+
+/**
+ * Create a new setting.
+ * @param settingSpec An object literal that looks like this:
+ * {
+ * name: 'thing',
+ * description: 'Thing is an example setting',
+ * type: 'string',
+ * defaultValue: 'something'
+ * }
+ */
+function Setting(settingSpec, settings) {
+ this._settings = settings;
+
+ Object.keys(settingSpec).forEach(function(key) {
+ this[key] = settingSpec[key];
+ }, this);
+
+ this.type = types.getType(this.type);
+ if (this.type == null) {
+ throw new Error('In ' + this.name +
+ ': can\'t find type for: ' + JSON.stringify(settingSpec.type));
+ }
+
+ if (!this.name) {
+ throw new Error('Setting.name == undefined. Ignoring.', this);
+ }
+
+ if (!this.defaultValue === undefined) {
+ throw new Error('Setting.defaultValue == undefined', this);
+ }
+
+ if (this.onChange) {
+ this.on('change', this.onChange.bind(this))
+ }
+
+ this.set(this.defaultValue);
+}
+Setting.prototype = {
+ get: function() {
+ return this.value;
+ },
+
+ set: function(value) {
+ if (this.value === value) {
+ return;
+ }
+
+ this.value = value;
+ if (this._settings.persister) {
+ this._settings.persister.persistValue(this._settings, this.name, value);
+ }
+
+ this._dispatchEvent('change', { setting: this, value: value });
+ },
+
+ /**
+ * Reset the value of the key setting to it's default
+ */
+ resetValue: function() {
+ this.set(this.defaultValue);
+ }
+};
+oop.implement(Setting.prototype, EventEmitter);
+
+
+/**
+ * A base class for all the various methods of storing settings.
+ * Usage:
+ *
+ * // Create manually, or require 'settings' from the container.
+ * // This is the manual version:
+ * var settings = plugins.catalog.getObject('settings');
+ * // Add a new setting
+ * settings.addSetting({ name:'foo', ... });
+ * // Display the default value
+ * alert(settings.get('foo'));
+ * // Alter the value, which also publishes the change etc.
+ * settings.set('foo', 'bar');
+ * // Reset the value to the default
+ * settings.resetValue('foo');
+ *
+ * @constructor
+ */
+function Settings(persister) {
+ // Storage for deactivated values
+ this._deactivated = {};
+
+ // Storage for the active settings
+ this._settings = {};
+ // We often want sorted setting names. Cache
+ this._settingNames = [];
+
+ if (persister) {
+ this.setPersister(persister);
+ }
+};
+
+Settings.prototype = {
+ /**
+ * Function to add to the list of available settings.
+ * Example usage:
+ *
+ * var settings = plugins.catalog.getObject('settings');
+ * settings.addSetting({
+ * name: 'tabsize', // For use in settings.get('X')
+ * type: 'number', // To allow value checking.
+ * defaultValue: 4 // Default value for use when none is directly set
+ * });
+ *
+ * @param {object} settingSpec Object containing name/type/defaultValue members.
+ */
+ addSetting: function(settingSpec) {
+ var setting = new Setting(settingSpec, this);
+ this._settings[setting.name] = setting;
+ this._settingNames.push(setting.name);
+ this._settingNames.sort();
+ },
+
+ addSettings: function addSettings(settings) {
+ Object.keys(settings).forEach(function (name) {
+ var setting = settings[name];
+ if (!('name' in setting)) setting.name = name;
+ this.addSetting(setting);
+ }, this);
+ },
+
+ removeSetting: function(setting) {
+ var name = (typeof setting === 'string' ? setting : setting.name);
+ setting = this._settings[name];
+ delete this._settings[name];
+ util.arrayRemove(this._settingNames, name);
+ settings.removeAllListeners('change');
+ },
+
+ removeSettings: function removeSettings(settings) {
+ Object.keys(settings).forEach(function(name) {
+ var setting = settings[name];
+ if (!('name' in setting)) setting.name = name;
+ this.removeSettings(setting);
+ }, this);
+ },
+
+ getSettingNames: function() {
+ return this._settingNames;
+ },
+
+ getSetting: function(name) {
+ return this._settings[name];
+ },
+
+ /**
+ * A Persister is able to store settings. It is an object that defines
+ * two functions:
+ * loadInitialValues(settings) and persistValue(settings, key, value).
+ */
+ setPersister: function(persister) {
+ this._persister = persister;
+ if (persister) {
+ persister.loadInitialValues(this);
+ }
+ },
+
+ resetAll: function() {
+ this.getSettingNames().forEach(function(key) {
+ this.resetValue(key);
+ }, this);
+ },
+
+ /**
+ * Retrieve a list of the known settings and their values
+ */
+ _list: function() {
+ var reply = [];
+ this.getSettingNames().forEach(function(setting) {
+ reply.push({
+ 'key': setting,
+ 'value': this.getSetting(setting).get()
+ });
+ }, this);
+ return reply;
+ },
+
+ /**
+ * Prime the local cache with the defaults.
+ */
+ _loadDefaultValues: function() {
+ this._loadFromObject(this._getDefaultValues());
+ },
+
+ /**
+ * Utility to load settings from an object
+ */
+ _loadFromObject: function(data) {
+ // We iterate over data rather than keys so we don't forget values
+ // which don't have a setting yet.
+ for (var key in data) {
+ if (data.hasOwnProperty(key)) {
+ var setting = this._settings[key];
+ if (setting) {
+ var value = setting.type.parse(data[key]);
+ this.set(key, value);
+ } else {
+ this.set(key, data[key]);
+ }
+ }
+ }
+ },
+
+ /**
+ * Utility to grab all the settings and export them into an object
+ */
+ _saveToObject: function() {
+ return this.getSettingNames().map(function(key) {
+ return this._settings[key].type.stringify(this.get(key));
+ }.bind(this));
+ },
+
+ /**
+ * The default initial settings
+ */
+ _getDefaultValues: function() {
+ return this.getSettingNames().map(function(key) {
+ return this._settings[key].spec.defaultValue;
+ }.bind(this));
+ }
+};
+exports.settings = new Settings();
+
+/**
+ * Save the settings in a cookie
+ * This code has not been tested since reboot
+ * @constructor
+ */
+function CookiePersister() {
+};
+
+CookiePersister.prototype = {
+ loadInitialValues: function(settings) {
+ settings._loadDefaultValues();
+ var data = cookie.get('settings');
+ settings._loadFromObject(JSON.parse(data));
+ },
+
+ persistValue: function(settings, key, value) {
+ try {
+ var stringData = JSON.stringify(settings._saveToObject());
+ cookie.set('settings', stringData);
+ } catch (ex) {
+ console.error('Unable to JSONify the settings! ' + ex);
+ return;
+ }
+ }
+};
+
+exports.CookiePersister = CookiePersister;
+
+});
+/* ***** 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 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):
+ * Skywriter Team (skywriter@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/commands/settings', function(require, exports, module) {
+
+
+var setCommandSpec = {
+ name: 'set',
+ params: [
+ {
+ name: 'setting',
+ type: 'setting',
+ description: 'The name of the setting to display or alter',
+ defaultValue: null
+ },
+ {
+ name: 'value',
+ type: 'settingValue',
+ description: 'The new value for the chosen setting',
+ defaultValue: null
+ }
+ ],
+ description: 'define and show settings',
+ exec: function(env, args, request) {
+ var html;
+ if (!args.setting) {
+ // 'set' by itself lists all the settings
+ var names = env.settings.getSettingNames();
+ html = '';
+ // first sort the settingsList based on the name
+ names.sort(function(name1, name2) {
+ return name1.localeCompare(name2);
+ });
+
+ names.forEach(function(name) {
+ var setting = env.settings.getSetting(name);
+ var url = 'https://wiki.mozilla.org/Labs/Skywriter/Settings#' +
+ setting.name;
+ html += '' +
+ setting.name +
+ ' = ' +
+ setting.value +
+ '
';
+ });
+ } else {
+ // set with only a setting, shows the value for that setting
+ if (args.value === undefined) {
+ html = '' + setting.name + ' = ' +
+ setting.get();
+ } else {
+ // Actually change the setting
+ args.setting.set(args.value);
+ html = 'Setting: ' + args.setting.name + ' = ' +
+ args.setting.get();
+ }
+ }
+ request.done(html);
+ }
+};
+
+var unsetCommandSpec = {
+ name: 'unset',
+ params: [
+ {
+ name: 'setting',
+ type: 'setting',
+ description: 'The name of the setting to return to defaults'
+ }
+ ],
+ description: 'unset a setting entirely',
+ exec: function(env, args, request) {
+ var setting = env.settings.get(args.setting);
+ if (!setting) {
+ request.doneWithError('No setting with the name ' +
+ args.setting + '.');
+ return;
+ }
+
+ setting.reset();
+ request.done('Reset ' + setting.name + ' to default: ' +
+ env.settings.get(args.setting));
+ }
+};
+
+var canon = require('pilot/canon');
+
+exports.startup = function(data, reason) {
+ canon.addCommand(setCommandSpec);
+ canon.addCommand(unsetCommandSpec);
+};
+
+exports.shutdown = function(data, reason) {
+ canon.removeCommand(setCommandSpec);
+ canon.removeCommand(unsetCommandSpec);
+};
+
+
+});
+/* ***** 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 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):
+ * Skywriter Team (skywriter@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/commands/basic', function(require, exports, module) {
+
+
+var checks = require("pilot/typecheck");
+var canon = require('pilot/canon');
+
+/**
+ *
+ */
+var helpMessages = {
+ plainPrefix:
+ 'Welcome to Skywriter - Code in the Cloud
',
+ plainSuffix:
+ 'For more information, see the Skywriter Wiki.'
+};
+
+/**
+ * 'help' command
+ */
+var helpCommandSpec = {
+ name: 'help',
+ params: [
+ {
+ name: 'search',
+ type: 'text',
+ description: 'Search string to narrow the output.',
+ defaultValue: null
+ }
+ ],
+ description: 'Get help on the available commands.',
+ exec: function(env, args, request) {
+ var output = [];
+
+ var command = canon.getCommand(args.search);
+ if (command && command.exec) {
+ // caught a real command
+ output.push(command.description ?
+ command.description :
+ 'No description for ' + args.search);
+ } else {
+ var showHidden = false;
+
+ if (!args.search && helpMessages.plainPrefix) {
+ output.push(helpMessages.plainPrefix);
+ }
+
+ if (command) {
+ // We must be looking at sub-commands
+ output.push('Sub-Commands of ' + command.name + '
');
+ output.push('' + command.description + '
');
+ }
+ else if (args.search) {
+ if (args.search == 'hidden') { // sneaky, sneaky.
+ args.search = '';
+ showHidden = true;
+ }
+ output.push('Commands starting with \'' + args.search + '\':
');
+ }
+ else {
+ output.push('Available Commands:
');
+ }
+
+ var commandNames = canon.getCommandNames();
+ commandNames.sort();
+
+ output.push('');
+ for (var i = 0; i < commandNames.length; i++) {
+ command = canon.getCommand(commandNames[i]);
+ if (!showHidden && command.hidden) {
+ continue;
+ }
+ if (command.description === undefined) {
+ // Ignore editor actions
+ continue;
+ }
+ if (args.search && command.name.indexOf(args.search) !== 0) {
+ // Filtered out by the user
+ continue;
+ }
+ if (!args.search && command.name.indexOf(' ') != -1) {
+ // sub command
+ continue;
+ }
+ if (command && command.name == args.search) {
+ // sub command, and we've already given that help
+ continue;
+ }
+
+ // todo add back a column with parameter information, perhaps?
+
+ output.push('');
+ output.push('| ' + command.name + ' | ');
+ output.push('' + command.description + ' | ');
+ output.push('
');
+ }
+ output.push('
');
+
+ if (!args.search && helpMessages.plainSuffix) {
+ output.push(helpMessages.plainSuffix);
+ }
+ }
+
+ request.done(output.join(''));
+ }
+};
+
+/**
+ * 'eval' command
+ */
+var evalCommandSpec = {
+ name: 'eval',
+ params: [
+ {
+ name: 'javascript',
+ type: 'text',
+ description: 'The JavaScript to evaluate'
+ }
+ ],
+ description: 'evals given js code and show the result',
+ hidden: true,
+ exec: function(env, args, request) {
+ var result;
+ var javascript = args.javascript;
+ try {
+ result = eval(javascript);
+ } catch (e) {
+ result = 'Error: ' + e.message + '';
+ }
+
+ var msg = '';
+ var type = '';
+ var x;
+
+ if (checks.isFunction(result)) {
+ // converts the function to a well formated string
+ msg = (result + '').replace(/\n/g, '
').replace(/ /g, ' ');
+ type = 'function';
+ } else if (checks.isObject(result)) {
+ if (Array.isArray(result)) {
+ type = 'array';
+ } else {
+ type = 'object';
+ }
+
+ var items = [];
+ var value;
+
+ for (x in result) {
+ if (result.hasOwnProperty(x)) {
+ if (checks.isFunction(result[x])) {
+ value = '[function]';
+ } else if (checks.isObject(result[x])) {
+ value = '[object]';
+ } else {
+ value = result[x];
+ }
+
+ items.push({name: x, value: value});
+ }
+ }
+
+ items.sort(function(a,b) {
+ return (a.name.toLowerCase() < b.name.toLowerCase()) ? -1 : 1;
+ });
+
+ for (x = 0; x < items.length; x++) {
+ msg += '' + items[x].name + ': ' + items[x].value + '
';
+ }
+
+ } else {
+ msg = result;
+ type = typeof result;
+ }
+
+ request.done('Result for eval \'' + javascript + '\'' +
+ ' (type: '+ type+'):
'+ msg);
+ }
+};
+
+/**
+ * 'version' command
+ */
+var versionCommandSpec = {
+ name: 'version',
+ description: 'show the Skywriter version',
+ hidden: true,
+ exec: function(env, args, request) {
+ var version = 'Skywriter ' + skywriter.versionNumber + ' (' +
+ skywriter.versionCodename + ')';
+ request.done(version);
+ }
+};
+
+/**
+ * 'skywriter' command
+ */
+var skywriterCommandSpec = {
+ name: 'skywriter',
+ hidden: true,
+ exec: function(env, args, request) {
+ var index = Math.floor(Math.random() * messages.length);
+ request.done('Skywriter ' + messages[index]);
+ }
+};
+var messages = [
+ 'really wants you to trick it out in some way.',
+ 'is your Web editor.',
+ 'would love to be like Emacs on the Web.',
+ 'is written on the Web platform, so you can tweak it.'
+];
+
+
+var canon = require('pilot/canon');
+
+exports.startup = function(data, reason) {
+ canon.addCommand(helpCommandSpec);
+ canon.addCommand(evalCommandSpec);
+ // canon.addCommand(versionCommandSpec);
+ canon.addCommand(skywriterCommandSpec);
+};
+
+exports.shutdown = function(data, reason) {
+ canon.removeCommand(helpCommandSpec);
+ canon.removeCommand(evalCommandSpec);
+ // canon.removeCommand(versionCommandSpec);
+ canon.removeCommand(skywriterCommandSpec);
+};
+
+
+});
+/* ***** 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 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):
+ * Joe Walker (jwalker@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/typecheck', function(require, exports, module) {
+
+var objectToString = Object.prototype.toString;
+
+/**
+ * Return true if it is a String
+ */
+exports.isString = function(it) {
+ return it && objectToString.call(it) === "[object String]";
+};
+
+/**
+ * Returns true if it is a Boolean.
+ */
+exports.isBoolean = function(it) {
+ return it && objectToString.call(it) === "[object Boolean]";
+};
+
+/**
+ * Returns true if it is a Number.
+ */
+exports.isNumber = function(it) {
+ return it && objectToString.call(it) === "[object Number]" && isFinite(it);
+};
+
+/**
+ * Hack copied from dojo.
+ */
+exports.isObject = function(it) {
+ return it !== undefined &&
+ (it === null || typeof it == "object" ||
+ Array.isArray(it) || exports.isFunction(it));
+};
+
+/**
+ * Is the passed object a function?
+ * From dojo.isFunction()
+ */
+exports.isFunction = function(it) {
+ return it && objectToString.call(it) === "[object Function]";
+};
+
+});/* ***** 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):
+ * Joe Walker (jwalker@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/settings/canon', function(require, exports, module) {
+
+
+var historyLengthSetting = {
+ name: "historyLength",
+ description: "How many typed commands do we recall for reference?",
+ type: "number",
+ defaultValue: 50
+};
+
+exports.startup = function(data, reason) {
+ data.env.settings.addSetting(historyLengthSetting);
+};
+
+exports.shutdown = function(data, reason) {
+ data.env.settings.removeSetting(historyLengthSetting);
+};
+
+
+});
+/* ***** 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 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):
+ * Kevin Dangoor (kdangoor@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/plugin_manager', function(require, exports, module) {
+
+var Promise = require("pilot/promise").Promise;
+
+exports.REASONS = {
+ APP_STARTUP: 1,
+ APP_SHUTDOWN: 2,
+ PLUGIN_ENABLE: 3,
+ PLUGIN_DISABLE: 4,
+ PLUGIN_INSTALL: 5,
+ PLUGIN_UNINSTALL: 6,
+ PLUGIN_UPGRADE: 7,
+ PLUGIN_DOWNGRADE: 8
+};
+
+exports.Plugin = function(name) {
+ this.name = name;
+ this.status = this.INSTALLED;
+};
+
+exports.Plugin.prototype = {
+ /**
+ * constants for the state
+ */
+ NEW: 0,
+ INSTALLED: 1,
+ REGISTERED: 2,
+ STARTED: 3,
+ UNREGISTERED: 4,
+ SHUTDOWN: 5,
+
+ install: function(data, reason) {
+ var pr = new Promise();
+ if (this.status > this.NEW) {
+ pr.resolve(this);
+ return pr;
+ }
+ require([this.name], function(pluginModule) {
+ if (pluginModule.install) {
+ pluginModule.install(data, reason);
+ }
+ this.status = this.INSTALLED;
+ pr.resolve(this);
+ }.bind(this));
+ return pr;
+ },
+
+ register: function(data, reason) {
+ var pr = new Promise();
+ if (this.status != this.INSTALLED) {
+ pr.resolve(this);
+ return pr;
+ }
+ require([this.name], function(pluginModule) {
+ if (pluginModule.register) {
+ pluginModule.register(data, reason);
+ }
+ this.status = this.REGISTERED;
+ pr.resolve(this);
+ }.bind(this));
+ return pr;
+ },
+
+ startup: function(data, reason) {
+ reason = reason || exports.REASONS.APP_STARTUP;
+ var pr = new Promise();
+ if (this.status != this.REGISTERED) {
+ pr.resolve(this);
+ return pr;
+ }
+ require([this.name], function(pluginModule) {
+ if (pluginModule.startup) {
+ pluginModule.startup(data, reason);
+ }
+ this.status = this.STARTED;
+ pr.resolve(this);
+ }.bind(this));
+ return pr;
+ },
+
+ shutdown: function(data, reason) {
+ if (this.status != this.STARTED) {
+ return;
+ }
+ pluginModule = require(this.name);
+ if (pluginModule.shutdown) {
+ pluginModule.shutdown(data, reason);
+ }
+ }
+};
+
+exports.PluginCatalog = function() {
+ this.plugins = {};
+};
+
+exports.PluginCatalog.prototype = {
+ registerPlugins: function(pluginList, data, reason) {
+ var registrationPromises = [];
+ pluginList.forEach(function(pluginName) {
+ var plugin = this.plugins[pluginName];
+ if (plugin === undefined) {
+ plugin = new exports.Plugin(pluginName);
+ this.plugins[pluginName] = plugin;
+ registrationPromises.push(plugin.register(data, reason));
+ }
+ }.bind(this));
+ return Promise.group(registrationPromises);
+ },
+
+ startupPlugins: function(data, reason) {
+ var startupPromises = [];
+ for (var pluginName in this.plugins) {
+ var plugin = this.plugins[pluginName];
+ startupPromises.push(plugin.startup(data, reason));
+ }
+ return Promise.group(startupPromises);
+ }
+};
+
+exports.catalog = new exports.PluginCatalog();
+
+});
+/* ***** 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):
+ * Joe Walker (jwalker@mozilla.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 ***** */
+
+__ace_shadowed__.define('pilot/promise', function(require, exports, module) {
+
+var console = require("pilot/console");
+var Trace = require('pilot/stacktrace').Trace;
+
+/**
+ * A promise can be in one of 2 states.
+ * The ERROR and SUCCESS states are terminal, the PENDING state is the only
+ * start state.
+ */
+var ERROR = -1;
+var PENDING = 0;
+var SUCCESS = 1;
+
+/**
+ * We give promises and ID so we can track which are outstanding
+ */
+var _nextId = 0;
+
+/**
+ * Debugging help if 2 things try to complete the same promise.
+ * This can be slow (especially on chrome due to the stack trace unwinding) so
+ * we should leave this turned off in normal use.
+ */
+var _traceCompletion = false;
+
+/**
+ * Outstanding promises. Handy list for debugging only.
+ */
+var _outstanding = [];
+
+/**
+ * Recently resolved promises. Also for debugging only.
+ */
+var _recent = [];
+
+/**
+ * Create an unfulfilled promise
+ */
+Promise = function () {
+ this._status = PENDING;
+ this._value = undefined;
+ this._onSuccessHandlers = [];
+ this._onErrorHandlers = [];
+
+ // Debugging help
+ this._id = _nextId++;
+ //this._createTrace = new Trace(new Error());
+ _outstanding[this._id] = this;
+};
+
+/**
+ * Yeay for RTTI.
+ */
+Promise.prototype.isPromise = true;
+
+/**
+ * Have we either been resolve()ed or reject()ed?
+ */
+Promise.prototype.isComplete = function() {
+ return this._status != PENDING;
+};
+
+/**
+ * Have we resolve()ed?
+ */
+Promise.prototype.isResolved = function() {
+ return this._status == SUCCESS;
+};
+
+/**
+ * Have we reject()ed?
+ */
+Promise.prototype.isRejected = function() {
+ return this._status == ERROR;
+};
+
+/**
+ * Take the specified action of fulfillment of a promise, and (optionally)
+ * a different action on promise rejection.
+ */
+Promise.prototype.then = function(onSuccess, onError) {
+ if (typeof onSuccess === 'function') {
+ if (this._status === SUCCESS) {
+ onSuccess.call(null, this._value);
+ } else if (this._status === PENDING) {
+ this._onSuccessHandlers.push(onSuccess);
+ }
+ }
+
+ if (typeof onError === 'function') {
+ if (this._status === ERROR) {
+ onError.call(null, this._value);
+ } else if (this._status === PENDING) {
+ this._onErrorHandlers.push(onError);
+ }
+ }
+
+ return this;
+};
+
+/**
+ * Like then() except that rather than returning this we return
+ * a promise which
+ */
+Promise.prototype.chainPromise = function(onSuccess) {
+ var chain = new Promise();
+ chain._chainedFrom = this;
+ this.then(function(data) {
+ try {
+ chain.resolve(onSuccess(data));
+ } catch (ex) {
+ chain.reject(ex);
+ }
+ }, function(ex) {
+ chain.reject(ex);
+ });
+ return chain;
+};
+
+/**
+ * Supply the fulfillment of a promise
+ */
+Promise.prototype.resolve = function(data) {
+ return this._complete(this._onSuccessHandlers, SUCCESS, data, 'resolve');
+};
+
+/**
+ * Renege on a promise
+ */
+Promise.prototype.reject = function(data) {
+ return this._complete(this._onErrorHandlers, ERROR, data, 'reject');
+};
+
+/**
+ * Internal method to be called on resolve() or reject().
+ * @private
+ */
+Promise.prototype._complete = function(list, status, data, name) {
+ // Complain if we've already been completed
+ if (this._status != PENDING) {
+ console.group('Promise already closed');
+ console.error('Attempted ' + name + '() with ', data);
+ console.error('Previous status = ', this._status,
+ ', previous value = ', this._value);
+ console.trace();
+
+ if (this._completeTrace) {
+ console.error('Trace of previous completion:');
+ this._completeTrace.log(5);
+ }
+ console.groupEnd();
+ return this;
+ }
+
+ if (_traceCompletion) {
+ this._completeTrace = new Trace(new Error());
+ }
+
+ this._status = status;
+ this._value = data;
+
+ // Call all the handlers, and then delete them
+ list.forEach(function(handler) {
+ handler.call(null, this._value);
+ }, this);
+ this._onSuccessHandlers.length = 0;
+ this._onErrorHandlers.length = 0;
+
+ // Remove the given {promise} from the _outstanding list, and add it to the
+ // _recent list, pruning more than 20 recent promises from that list.
+ delete _outstanding[this._id];
+ _recent.push(this);
+ while (_recent.length > 20) {
+ _recent.shift();
+ }
+
+ return this;
+};
+
+/**
+ * Takes an array of promises and returns a promise that that is fulfilled once
+ * all the promises in the array are fulfilled
+ * @param group The array of promises
+ * @return the promise that is fulfilled when all the array is fulfilled
+ */
+Promise.group = function(promiseList) {
+ if (!(promiseList instanceof Array)) {
+ promiseList = Array.prototype.slice.call(arguments);
+ }
+
+ // If the original array has nothing in it, return now to avoid waiting
+ if (promiseList.length === 0) {
+ return new Promise().resolve([]);
+ }
+
+ var groupPromise = new Promise();
+ var results = [];
+ var fulfilled = 0;
+
+ var onSuccessFactory = function(index) {
+ return function(data) {
+ results[index] = data;
+ fulfilled++;
+ // If the group has already failed, silently drop extra results
+ if (groupPromise._status !== ERROR) {
+ if (fulfilled === promiseList.length) {
+ groupPromise.resolve(results);
+ }
+ }
+ };
+ };
+
+ promiseList.forEach(function(promise, index) {
+ var onSuccess = onSuccessFactory(index);
+ var onError = groupPromise.reject.bind(groupPromise);
+ promise.then(onSuccess, onError);
+ });
+
+ return groupPromise;
+};
+
+exports.Promise = Promise;
+exports._outstanding = _outstanding;
+exports._recent = _recent;
+
+});
+/* ***** 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 DomTemplate.
+ *
+ * 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):
+ * Joe Walker (jwalker@mozilla.com) (original author)
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('pilot/environment', function(require, exports, module) {
+
+
+var settings = require("pilot/settings").settings;
+
+/**
+ * Create an environment object
+ */
+function create() {
+ return {
+ settings: settings
+ };
+};
+
+exports.create = create;
+
+
+});
+/* 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
+ * Irakli Gozalishvili (http://jeditoolkit.com)
+ * Julian Viereck
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/editor', function(require, exports, module) {
+
+require("pilot/fixoldbrowsers");
+
+var oop = require("pilot/oop");
+var event = require("pilot/event");
+var lang = require("pilot/lang");
+var useragent = require("pilot/useragent");
+var TextInput = require("ace/keyboard/textinput").TextInput;
+var MouseHandler = require("ace/mouse_handler").MouseHandler;
+//var TouchHandler = require("ace/touch_handler").TouchHandler;
+var KeyBinding = require("ace/keyboard/keybinding").KeyBinding;
+var EditSession = require("ace/edit_session").EditSession;
+var Search = require("ace/search").Search;
+var BackgroundTokenizer = require("ace/background_tokenizer").BackgroundTokenizer;
+var Range = require("ace/range").Range;
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+
+var Editor =function(renderer, session) {
+ var container = renderer.getContainerElement();
+ this.container = container;
+ this.renderer = renderer;
+
+ this.textInput = new TextInput(renderer.getTextAreaContainer(), this);
+ this.keyBinding = new KeyBinding(this);
+
+ // TODO detect touch event support
+ if (useragent.isIPad) {
+ //this.$mouseHandler = new TouchHandler(this);
+ } else {
+ this.$mouseHandler = new MouseHandler(this);
+ }
+
+ this.$blockScrolling = 0;
+ this.$search = new Search().set({
+ wrap: true
+ });
+
+ this.setSession(session || new EditSession(""));
+};
+
+(function(){
+
+ oop.implement(this, EventEmitter);
+
+ this.$forwardEvents = {
+ gutterclick: 1,
+ gutterdblclick: 1
+ };
+
+ this.$originalAddEventListener = this.addEventListener;
+ this.$originalRemoveEventListener = this.removeEventListener;
+
+ this.addEventListener = function(eventName, callback) {
+ if (this.$forwardEvents[eventName]) {
+ return this.renderer.addEventListener(eventName, callback);
+ } else {
+ return this.$originalAddEventListener(eventName, callback);
+ }
+ };
+
+ this.removeEventListener = function(eventName, callback) {
+ if (this.$forwardEvents[eventName]) {
+ return this.renderer.removeEventListener(eventName, callback);
+ } else {
+ return this.$originalRemoveEventListener(eventName, callback);
+ }
+ };
+
+ this.setKeyboardHandler = function(keyboardHandler) {
+ this.keyBinding.setKeyboardHandler(keyboardHandler);
+ };
+
+ this.getKeyboardHandler = function() {
+ return this.keyBinding.getKeyboardHandler();
+ }
+
+ this.setSession = function(session) {
+ if (this.session == session) return;
+
+ if (this.session) {
+ var oldSession = this.session;
+ this.session.removeEventListener("change", this.$onDocumentChange);
+ this.session.removeEventListener("changeMode", this.$onDocumentModeChange);
+ this.session.removeEventListener("changeTabSize", this.$onDocumentChangeTabSize);
+ this.session.removeEventListener("changeWrapLimit", this.$onDocumentChangeWrapLimit);
+ this.session.removeEventListener("changeWrapMode", this.$onDocumentChangeWrapMode);
+ this.session.removeEventListener("changeFrontMarker", this.$onChangeFrontMarker);
+ this.session.removeEventListener("changeBackMarker", this.$onChangeBackMarker);
+ this.session.removeEventListener("changeBreakpoint", this.$onDocumentChangeBreakpoint);
+ this.session.removeEventListener("changeAnnotation", this.$onDocumentChangeAnnotation);
+
+ var selection = this.session.getSelection();
+ selection.removeEventListener("changeCursor", this.$onCursorChange);
+ selection.removeEventListener("changeSelection", this.$onSelectionChange);
+
+ this.session.setScrollTopRow(this.renderer.getScrollTopRow());
+ }
+
+ this.session = session;
+
+ this.$onDocumentChange = this.onDocumentChange.bind(this);
+ session.addEventListener("change", this.$onDocumentChange);
+ this.renderer.setSession(session);
+
+ this.$onDocumentModeChange = this.onDocumentModeChange.bind(this);
+ session.addEventListener("changeMode", this.$onDocumentModeChange);
+
+ this.$onDocumentChangeTabSize = this.renderer.updateText.bind(this.renderer);
+ session.addEventListener("changeTabSize", this.$onDocumentChangeTabSize);
+
+ this.$onDocumentChangeWrapLimit = this.onDocumentChangeWrapLimit.bind(this);
+ session.addEventListener("changeWrapLimit", this.$onDocumentChangeWrapLimit);
+
+ this.$onDocumentChangeWrapMode = this.onDocumentChangeWrapMode.bind(this);
+ session.addEventListener("changeWrapMode", this.$onDocumentChangeWrapMode);
+
+ this.$onChangeFrontMarker = this.onChangeFrontMarker.bind(this);
+ this.session.addEventListener("changeFrontMarker", this.$onChangeFrontMarker);
+
+ this.$onChangeBackMarker = this.onChangeBackMarker.bind(this);
+ this.session.addEventListener("changeBackMarker", this.$onChangeBackMarker);
+
+ this.$onDocumentChangeBreakpoint = this.onDocumentChangeBreakpoint.bind(this);
+ this.session.addEventListener("changeBreakpoint", this.$onDocumentChangeBreakpoint);
+
+ this.$onDocumentChangeAnnotation = this.onDocumentChangeAnnotation.bind(this);
+ this.session.addEventListener("changeAnnotation", this.$onDocumentChangeAnnotation);
+
+ this.selection = session.getSelection();
+
+ this.$onCursorChange = this.onCursorChange.bind(this);
+ this.selection.addEventListener("changeCursor", this.$onCursorChange);
+
+ this.$onSelectionChange = this.onSelectionChange.bind(this);
+ this.selection.addEventListener("changeSelection", this.$onSelectionChange);
+
+ this.onDocumentModeChange();
+ this.bgTokenizer.setDocument(session.getDocument());
+ this.bgTokenizer.start(0);
+
+ this.onCursorChange();
+ this.onSelectionChange();
+ this.onChangeFrontMarker();
+ this.onChangeBackMarker();
+ this.onDocumentChangeBreakpoint();
+ this.onDocumentChangeAnnotation();
+ this.renderer.scrollToRow(session.getScrollTopRow());
+ this.renderer.updateFull();
+
+ this._dispatchEvent("changeSession", {
+ session: session,
+ oldSession: oldSession
+ });
+ };
+
+ this.getSession = function() {
+ return this.session;
+ };
+
+ this.getSelection = function() {
+ return this.selection;
+ };
+
+ this.resize = function() {
+ this.renderer.onResize();
+ };
+
+ this.setTheme = function(theme) {
+ this.renderer.setTheme(theme);
+ };
+
+ this.setStyle = function(style) {
+ this.renderer.setStyle(style)
+ };
+
+ this.unsetStyle = function(style) {
+ this.renderer.unsetStyle(style)
+ }
+
+ this.$highlightBrackets = function() {
+ if (this.session.$bracketHighlight) {
+ this.session.removeMarker(this.session.$bracketHighlight);
+ this.session.$bracketHighlight = null;
+ }
+
+ if (this.$highlightPending) {
+ return;
+ }
+
+ // perform highlight async to not block the browser during navigation
+ var self = this;
+ this.$highlightPending = true;
+ setTimeout(function() {
+ self.$highlightPending = false;
+
+ var pos = self.session.findMatchingBracket(self.getCursorPosition());
+ if (pos) {
+ var range = new Range(pos.row, pos.column, pos.row, pos.column+1);
+ self.session.$bracketHighlight = self.session.addMarker(range, "ace_bracket");
+ }
+ }, 10);
+ };
+
+ this.focus = function() {
+ // Safari need the timeout
+ // iOS and Firefox need it called immediately
+ // to be on the save side we do both
+ var _self = this;
+ setTimeout(function() {
+ _self.textInput.focus();
+ });
+ this.textInput.focus();
+ };
+
+ this.blur = function() {
+ this.textInput.blur();
+ };
+
+ this.onFocus = function() {
+ this.renderer.showCursor();
+ this.renderer.visualizeFocus();
+ this._dispatchEvent("focus");
+ };
+
+ this.onBlur = function() {
+ this.renderer.hideCursor();
+ this.renderer.visualizeBlur();
+ this._dispatchEvent("blur");
+ };
+
+ this.onDocumentChange = function(e) {
+ var delta = e.data;
+ var range = delta.range;
+
+ this.bgTokenizer.start(range.start.row);
+ if (range.start.row == range.end.row && delta.action != "insertLines" && delta.action != "removeLines")
+ var lastRow = range.end.row;
+ else
+ lastRow = Infinity;
+ this.renderer.updateLines(range.start.row, lastRow);
+
+ // update cursor because tab characters can influence the cursor position
+ this.renderer.updateCursor(this.getCursorPosition(), this.$overwrite);
+ };
+
+ this.onTokenizerUpdate = function(e) {
+ var rows = e.data;
+ this.renderer.updateLines(rows.first, rows.last);
+ };
+
+ this.onCursorChange = function(e) {
+ this.renderer.updateCursor(this.getCursorPosition(), this.$overwrite);
+
+ if (!this.$blockScrolling) {
+ this.renderer.scrollCursorIntoView();
+ }
+
+ // move text input over the cursor
+ // this is required for iOS and IME
+ this.renderer.moveTextAreaToCursor(this.textInput.getElement());
+
+ this.$highlightBrackets();
+ this.$updateHighlightActiveLine();
+ };
+
+ this.$updateHighlightActiveLine = function() {
+ var session = this.getSession();
+
+ if (session.$highlightLineMarker) {
+ session.removeMarker(session.$highlightLineMarker);
+ }
+ session.$highlightLineMarker = null;
+
+ if (this.getHighlightActiveLine() && (this.getSelectionStyle() != "line" || !this.selection.isMultiLine())) {
+ var cursor = this.getCursorPosition();
+ var range = new Range(cursor.row, 0, cursor.row+1, 0);
+ session.$highlightLineMarker = session.addMarker(range, "ace_active_line", "line");
+ }
+ };
+
+ this.onSelectionChange = function(e) {
+ var session = this.getSession();
+
+ if (session.$selectionMarker) {
+ session.removeMarker(session.$selectionMarker);
+ }
+ session.$selectionMarker = null;
+
+ if (!this.selection.isEmpty()) {
+ var range = this.selection.getRange();
+ var style = this.getSelectionStyle();
+ session.$selectionMarker = session.addMarker(range, "ace_selection", style);
+ }
+
+ this.onCursorChange(e);
+
+ if (this.$highlightSelectedWord)
+ this.mode.highlightSelection(this);
+ };
+
+ this.onChangeFrontMarker = function() {
+ this.renderer.updateFrontMarkers();
+ };
+
+ this.onChangeBackMarker = function() {
+ this.renderer.updateBackMarkers();
+ };
+
+ this.onDocumentChangeBreakpoint = function() {
+ this.renderer.setBreakpoints(this.session.getBreakpoints());
+ };
+
+ this.onDocumentChangeAnnotation = function() {
+ this.renderer.setAnnotations(this.session.getAnnotations());
+ };
+
+ this.onDocumentModeChange = function() {
+ var mode = this.session.getMode();
+ if (this.mode == mode)
+ return;
+
+ this.mode = mode;
+ var tokenizer = mode.getTokenizer();
+
+ if (!this.bgTokenizer) {
+ var onUpdate = this.onTokenizerUpdate.bind(this);
+ this.bgTokenizer = new BackgroundTokenizer(tokenizer, this);
+ this.bgTokenizer.addEventListener("update", onUpdate);
+ } else {
+ this.bgTokenizer.setTokenizer(tokenizer);
+ }
+
+ this.renderer.setTokenizer(this.bgTokenizer);
+ };
+
+ this.onDocumentChangeWrapLimit = function() {
+ this.renderer.updateCursor(this.getCursorPosition(), this.$overwrite);
+ this.renderer.updateFull();
+ };
+
+ this.onDocumentChangeWrapMode = function() {
+ this.renderer.onResize(true);
+ };
+
+ this.getCopyText = function() {
+ if (!this.selection.isEmpty()) {
+ return this.session.getTextRange(this.getSelectionRange());
+ }
+ else {
+ return "";
+ }
+ };
+
+ this.onCut = function() {
+ if (this.$readOnly)
+ return;
+
+ if (!this.selection.isEmpty()) {
+ this.session.remove(this.getSelectionRange())
+ this.clearSelection();
+ }
+ };
+
+ this.insert = function(text) {
+ if (this.$readOnly)
+ return;
+
+ var cursor = this.getCursorPosition();
+ text = text.replace("\t", this.session.getTabString());
+
+ // remove selected text
+ if (!this.selection.isEmpty()) {
+ var cursor = this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ } else if (this.$overwrite){
+ var range = new Range.fromPoints(cursor, cursor);
+ range.end.column += text.length;
+ this.session.remove(range);
+ }
+
+ this.clearSelection();
+
+ var lineState = this.bgTokenizer.getState(cursor.row);
+ var shouldOutdent = this.mode.checkOutdent(lineState, this.session.getLine(cursor.row), text);
+ var line = this.session.getLine(cursor.row);
+ var lineIndent = this.mode.getNextLineIndent(lineState, line.slice(0, cursor.column), this.session.getTabString());
+ var end = this.session.insert(cursor, text);
+
+ this.moveCursorToPosition(end);
+
+ var lineState = this.bgTokenizer.getState(cursor.row);
+ // multi line insert
+ if (cursor.row !== end.row) {
+ var size = this.session.getTabSize(),
+ minIndent = Number.MAX_VALUE;
+
+ for (var row = cursor.row + 1; row <= end.row; ++row) {
+ var indent = 0;
+
+ line = this.session.getLine(row);
+ for (var i = 0; i < line.length; ++i)
+ if (line.charAt(i) == '\t')
+ indent += size;
+ else if (line.charAt(i) == ' ')
+ indent += 1;
+ else
+ break;
+ if (/[^\s]/.test(line))
+ minIndent = Math.min(indent, minIndent);
+ }
+
+ for (var row = cursor.row + 1; row <= end.row; ++row) {
+ var outdent = minIndent;
+
+ line = this.session.getLine(row);
+ for (var i = 0; i < line.length && outdent > 0; ++i)
+ if (line.charAt(i) == '\t')
+ outdent -= size;
+ else if (line.charAt(i) == ' ')
+ outdent -= 1;
+ this.session.remove(new Range(row, 0, row, i));
+ }
+ this.session.indentRows(cursor.row + 1, end.row, lineIndent);
+ } else {
+ if (shouldOutdent) {
+ this.mode.autoOutdent(lineState, this.session, cursor.row);
+ }
+ };
+ }
+
+ this.onTextInput = function(text) {
+ this.keyBinding.onTextInput(text);
+ };
+
+ this.onCommandKey = function(e, hashId, keyCode) {
+ this.keyBinding.onCommandKey(e, hashId, keyCode);
+ };
+
+ this.$overwrite = false;
+ this.setOverwrite = function(overwrite) {
+ if (this.$overwrite == overwrite) return;
+
+ this.$overwrite = overwrite;
+
+ this.$blockScrolling += 1;
+ this.onCursorChange();
+ this.$blockScrolling -= 1;
+
+ this._dispatchEvent("changeOverwrite", {data: overwrite});
+ };
+
+ this.getOverwrite = function() {
+ return this.$overwrite;
+ };
+
+ this.toggleOverwrite = function() {
+ this.setOverwrite(!this.$overwrite);
+ };
+
+ this.setScrollSpeed = function(speed) {
+ this.$mouseHandler.setScrollSpeed(speed);
+ };
+
+ this.getScrollSpeed = function() {
+ return this.$mouseHandler.getScrollSpeed()
+ };
+
+ this.$selectionStyle = "line";
+ this.setSelectionStyle = function(style) {
+ if (this.$selectionStyle == style) return;
+
+ this.$selectionStyle = style;
+ this.onSelectionChange();
+ this._dispatchEvent("changeSelectionStyle", {data: style});
+ };
+
+ this.getSelectionStyle = function() {
+ return this.$selectionStyle;
+ };
+
+ this.$highlightActiveLine = true;
+ this.setHighlightActiveLine = function(shouldHighlight) {
+ if (this.$highlightActiveLine == shouldHighlight) return;
+
+ this.$highlightActiveLine = shouldHighlight;
+ this.$updateHighlightActiveLine();
+ };
+
+ this.getHighlightActiveLine = function() {
+ return this.$highlightActiveLine;
+ };
+
+ this.$highlightSelectedWord = true;
+ this.setHighlightSelectedWord = function(shouldHighlight) {
+ if (this.$highlightSelectedWord == shouldHighlight)
+ return;
+
+ this.$highlightSelectedWord = shouldHighlight;
+ if (shouldHighlight)
+ this.mode.highlightSelection(this);
+ else
+ this.mode.clearSelectionHighlight(this);
+ };
+
+ this.getHighlightSelectedWord = function() {
+ return this.$highlightSelectedWord;
+ };
+
+ this.setShowInvisibles = function(showInvisibles) {
+ if (this.getShowInvisibles() == showInvisibles)
+ return;
+
+ this.renderer.setShowInvisibles(showInvisibles);
+ };
+
+ this.getShowInvisibles = function() {
+ return this.renderer.getShowInvisibles();
+ };
+
+ this.setShowPrintMargin = function(showPrintMargin) {
+ this.renderer.setShowPrintMargin(showPrintMargin);
+ };
+
+ this.getShowPrintMargin = function() {
+ return this.renderer.getShowPrintMargin();
+ };
+
+ this.setPrintMarginColumn = function(showPrintMargin) {
+ this.renderer.setPrintMarginColumn(showPrintMargin);
+ };
+
+ this.getPrintMarginColumn = function() {
+ return this.renderer.getPrintMarginColumn();
+ };
+
+ this.$readOnly = false;
+ this.setReadOnly = function(readOnly) {
+ this.$readOnly = readOnly;
+ };
+
+ this.getReadOnly = function() {
+ return this.$readOnly;
+ };
+
+ this.removeRight = function() {
+ if (this.$readOnly)
+ return;
+
+ if (this.selection.isEmpty()) {
+ this.selection.selectRight();
+ }
+ this.session.remove(this.getSelectionRange())
+ this.clearSelection();
+ };
+
+ this.removeLeft = function() {
+ if (this.$readOnly)
+ return;
+
+ if (this.selection.isEmpty())
+ this.selection.selectLeft();
+
+ this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ };
+
+ this.removeWordRight = function() {
+ if (this.$readOnly)
+ return;
+
+ if (this.selection.isEmpty())
+ this.selection.selectWordRight();
+
+ this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ };
+
+ this.removeWordLeft = function() {
+ if (this.$readOnly)
+ return;
+
+ if (this.selection.isEmpty())
+ this.selection.selectWordLeft();
+
+ this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ };
+
+ this.removeToLineStart = function() {
+ if (this.$readOnly)
+ return;
+
+ if (this.selection.isEmpty())
+ this.selection.selectLineStart();
+
+ this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ };
+
+ this.removeToLineEnd = function() {
+ if (this.$readOnly)
+ return;
+
+ if (this.selection.isEmpty())
+ this.selection.selectLineEnd();
+
+ this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ };
+
+ this.splitLine = function() {
+ if (this.$readOnly)
+ return;
+
+ if (!this.selection.isEmpty()) {
+ this.session.remove(this.getSelectionRange());
+ this.clearSelection();
+ }
+
+ var cursor = this.getCursorPosition();
+ this.insert("\n");
+ this.moveCursorToPosition(cursor);
+ };
+
+ this.transposeLetters = function() {
+ if (this.$readOnly)
+ return;
+
+ if (!this.selection.isEmpty()) {
+ return;
+ }
+
+ var cursor = this.getCursorPosition();
+ var column = cursor.column;
+ if (column == 0)
+ return;
+
+ var line = this.session.getLine(cursor.row);
+ if (column < line.length) {
+ var swap = line.charAt(column) + line.charAt(column-1);
+ var range = new Range(cursor.row, column-1, cursor.row, column+1)
+ }
+ else {
+ var swap = line.charAt(column-1) + line.charAt(column-2);
+ var range = new Range(cursor.row, column-2, cursor.row, column)
+ }
+ this.session.replace(range, swap);
+ };
+
+ this.indent = function() {
+ if (this.$readOnly)
+ return;
+
+ var session = this.session;
+ var range = this.getSelectionRange();
+
+ if (range.start.row < range.end.row || range.start.column < range.end.column) {
+ var rows = this.$getSelectedRows();
+ session.indentRows(rows.first, rows.last, "\t");
+ } else {
+ var indentString;
+
+ if (this.session.getUseSoftTabs()) {
+ var size = session.getTabSize(),
+ position = this.getCursorPosition(),
+ column = session.documentToScreenColumn(position.row, position.column),
+ count = (size - column % size);
+
+ indentString = lang.stringRepeat(" ", count);
+ } else
+ indentString = "\t";
+ return this.onTextInput(indentString);
+ }
+ };
+
+ this.blockOutdent = function() {
+ if (this.$readOnly)
+ return;
+
+ var selection = this.session.getSelection();
+ this.session.outdentRows(selection.getRange());
+ };
+
+ this.toggleCommentLines = function() {
+ if (this.$readOnly)
+ return;
+
+ var state = this.bgTokenizer.getState(this.getCursorPosition().row);
+ var rows = this.$getSelectedRows()
+ this.mode.toggleCommentLines(state, this.session, rows.first, rows.last);
+ };
+
+ this.removeLines = function() {
+ if (this.$readOnly)
+ return;
+
+ var rows = this.$getSelectedRows();
+ this.session.remove(new Range(rows.first, 0, rows.last+1, 0));
+ this.clearSelection();
+ };
+
+ this.moveLinesDown = function() {
+ if (this.$readOnly)
+ return;
+
+ this.$moveLines(function(firstRow, lastRow) {
+ return this.session.moveLinesDown(firstRow, lastRow);
+ });
+ };
+
+ this.moveLinesUp = function() {
+ if (this.$readOnly)
+ return;
+
+ this.$moveLines(function(firstRow, lastRow) {
+ return this.session.moveLinesUp(firstRow, lastRow);
+ });
+ };
+
+ this.copyLinesUp = function() {
+ if (this.$readOnly)
+ return;
+
+ this.$moveLines(function(firstRow, lastRow) {
+ this.session.duplicateLines(firstRow, lastRow);
+ return 0;
+ });
+ };
+
+ this.copyLinesDown = function() {
+ if (this.$readOnly)
+ return;
+
+ this.$moveLines(function(firstRow, lastRow) {
+ return this.session.duplicateLines(firstRow, lastRow);
+ });
+ };
+
+
+ this.$moveLines = function(mover) {
+ var rows = this.$getSelectedRows();
+
+ var linesMoved = mover.call(this, rows.first, rows.last);
+
+ var selection = this.selection;
+ selection.setSelectionAnchor(rows.last+linesMoved+1, 0);
+ selection.$moveSelection(function() {
+ selection.moveCursorTo(rows.first+linesMoved, 0);
+ });
+ };
+
+ this.$getSelectedRows = function() {
+ var range = this.getSelectionRange().collapseRows();
+
+ return {
+ first: range.start.row,
+ last: range.end.row
+ };
+ };
+
+ this.onCompositionStart = function(text) {
+ this.renderer.showComposition(this.getCursorPosition());
+ };
+
+ this.onCompositionUpdate = function(text) {
+ this.renderer.setCompositionText(text);
+ };
+
+ this.onCompositionEnd = function() {
+ this.renderer.hideComposition();
+ };
+
+
+ this.getFirstVisibleRow = function() {
+ return this.renderer.getFirstVisibleRow();
+ };
+
+ this.getLastVisibleRow = function() {
+ return this.renderer.getLastVisibleRow();
+ };
+
+ this.isRowVisible = function(row) {
+ return (row >= this.getFirstVisibleRow() && row <= this.getLastVisibleRow());
+ };
+
+ this.$getVisibleRowCount = function() {
+ return this.renderer.getScrollBottomRow() - this.renderer.getScrollTopRow() + 1;
+ };
+
+ this.$getPageDownRow = function() {
+ return this.renderer.getScrollBottomRow();
+ };
+
+ this.$getPageUpRow = function() {
+ var firstRow = this.renderer.getScrollTopRow();
+ var lastRow = this.renderer.getScrollBottomRow();
+
+ return firstRow - (lastRow - firstRow);
+ };
+
+ this.selectPageDown = function() {
+ var row = this.$getPageDownRow() + Math.floor(this.$getVisibleRowCount() / 2);
+
+ this.scrollPageDown();
+
+ var selection = this.getSelection();
+ var leadScreenPos = this.session.documentToScreenPosition(selection.getSelectionLead());
+ var dest = this.session.screenToDocumentPosition(row, leadScreenPos.column);
+ selection.selectTo(dest.row, dest.column);
+ };
+
+ this.selectPageUp = function() {
+ var visibleRows = this.renderer.getScrollTopRow() - this.renderer.getScrollBottomRow();
+ var row = this.$getPageUpRow() + Math.round(visibleRows / 2);
+
+ this.scrollPageUp();
+
+ var selection = this.getSelection();
+ var leadScreenPos = this.session.documentToScreenPosition(selection.getSelectionLead());
+ var dest = this.session.screenToDocumentPosition(row, leadScreenPos.column);
+ selection.selectTo(dest.row, dest.column);
+ };
+
+ this.gotoPageDown = function() {
+ var row = this.$getPageDownRow();
+ var column = this.getCursorPositionScreen().column;
+
+ this.scrollToRow(row);
+ this.getSelection().moveCursorToScreen(row, column);
+ };
+
+ this.gotoPageUp = function() {
+ var row = this.$getPageUpRow();
+ var column = this.getCursorPositionScreen().column;
+
+ this.scrollToRow(row);
+ this.getSelection().moveCursorToScreen(row, column);
+ };
+
+ this.scrollPageDown = function() {
+ this.scrollToRow(this.$getPageDownRow());
+ };
+
+ this.scrollPageUp = function() {
+ this.renderer.scrollToRow(this.$getPageUpRow());
+ };
+
+ this.scrollToRow = function(row) {
+ this.renderer.scrollToRow(row);
+ };
+
+ this.scrollToLine = function(line, center) {
+ this.renderer.scrollToLine(line, center);
+ };
+
+ this.centerSelection = function() {
+ var range = this.getSelectionRange();
+ var line = Math.floor(range.start.row + (range.end.row - range.start.row) / 2);
+ this.renderer.scrollToLine(line, true);
+ };
+
+ this.getCursorPosition = function() {
+ return this.selection.getCursor();
+ };
+
+ this.getCursorPositionScreen = function() {
+ return this.session.documentToScreenPosition(this.getCursorPosition());
+ }
+
+ this.getSelectionRange = function() {
+ return this.selection.getRange();
+ };
+
+
+ this.selectAll = function() {
+ this.$blockScrolling += 1;
+ this.selection.selectAll();
+ this.$blockScrolling -= 1;
+ };
+
+ this.clearSelection = function() {
+ this.selection.clearSelection();
+ };
+
+ this.moveCursorTo = function(row, column) {
+ this.selection.moveCursorTo(row, column);
+ };
+
+ this.moveCursorToPosition = function(pos) {
+ this.selection.moveCursorToPosition(pos);
+ };
+
+
+ this.gotoLine = function(lineNumber, row) {
+ this.selection.clearSelection();
+
+ this.$blockScrolling += 1;
+ this.moveCursorTo(lineNumber-1, row || 0);
+ this.$blockScrolling -= 1;
+
+ if (!this.isRowVisible(this.getCursorPosition().row)) {
+ this.scrollToLine(lineNumber, true);
+ }
+ },
+
+ this.navigateTo = function(row, column) {
+ this.clearSelection();
+ this.moveCursorTo(row, column);
+ };
+
+ this.navigateUp = function(times) {
+ this.selection.clearSelection();
+ times = times || 1;
+ this.selection.moveCursorBy(-times, 0);
+ };
+
+ this.navigateDown = function(times) {
+ this.selection.clearSelection();
+ times = times || 1;
+ this.selection.moveCursorBy(times, 0);
+ };
+
+ this.navigateLeft = function(times) {
+ if (!this.selection.isEmpty()) {
+ var selectionStart = this.getSelectionRange().start;
+ this.moveCursorToPosition(selectionStart);
+ }
+ else {
+ times = times || 1;
+ while (times--) {
+ this.selection.moveCursorLeft();
+ }
+ }
+ this.clearSelection();
+ };
+
+ this.navigateRight = function(times) {
+ if (!this.selection.isEmpty()) {
+ var selectionEnd = this.getSelectionRange().end;
+ this.moveCursorToPosition(selectionEnd);
+ }
+ else {
+ times = times || 1;
+ while (times--) {
+ this.selection.moveCursorRight();
+ }
+ }
+ this.clearSelection();
+ };
+
+ this.navigateLineStart = function() {
+ this.selection.moveCursorLineStart();
+ this.clearSelection();
+ };
+
+ this.navigateLineEnd = function() {
+ this.selection.moveCursorLineEnd();
+ this.clearSelection();
+ };
+
+ this.navigateFileEnd = function() {
+ this.selection.moveCursorFileEnd();
+ this.clearSelection();
+ };
+
+ this.navigateFileStart = function() {
+ this.selection.moveCursorFileStart();
+ this.clearSelection();
+ };
+
+ this.navigateWordRight = function() {
+ this.selection.moveCursorWordRight();
+ this.clearSelection();
+ };
+
+ this.navigateWordLeft = function() {
+ this.selection.moveCursorWordLeft();
+ this.clearSelection();
+ };
+
+ this.replace = function(replacement, options) {
+ if (options)
+ this.$search.set(options);
+
+ var range = this.$search.find(this.session);
+ this.$tryReplace(range, replacement);
+ if (range !== null)
+ this.selection.setSelectionRange(range);
+ },
+
+ this.replaceAll = function(replacement, options) {
+ if (options) {
+ this.$search.set(options);
+ }
+
+ var ranges = this.$search.findAll(this.session);
+ if (!ranges.length)
+ return;
+
+ var selection = this.getSelectionRange();
+ this.clearSelection();
+ this.selection.moveCursorTo(0, 0);
+
+ this.$blockScrolling += 1;
+ for (var i = ranges.length - 1; i >= 0; --i)
+ this.$tryReplace(ranges[i], replacement);
+
+ this.selection.setSelectionRange(selection);
+ this.$blockScrolling -= 1;
+ },
+
+ this.$tryReplace = function(range, replacement) {
+ var input = this.session.getTextRange(range);
+ var replacement = this.$search.replace(input, replacement);
+ if (replacement !== null) {
+ range.end = this.session.replace(range, replacement);
+ return range;
+ } else {
+ return null;
+ }
+ };
+
+ this.getLastSearchOptions = function() {
+ return this.$search.getOptions();
+ };
+
+ this.find = function(needle, options) {
+ this.clearSelection();
+ options = options || {};
+ options.needle = needle;
+ this.$search.set(options);
+ this.$find();
+ },
+
+ this.findNext = function(options) {
+ options = options || {};
+ if (typeof options.backwards == "undefined")
+ options.backwards = false;
+ this.$search.set(options);
+ this.$find();
+ };
+
+ this.findPrevious = function(options) {
+ options = options || {};
+ if (typeof options.backwards == "undefined")
+ options.backwards = true;
+ this.$search.set(options);
+ this.$find();
+ };
+
+ this.$find = function(backwards) {
+ if (!this.selection.isEmpty()) {
+ this.$search.set({needle: this.session.getTextRange(this.getSelectionRange())});
+ }
+
+ if (typeof backwards != "undefined")
+ this.$search.set({backwards: backwards});
+
+ var range = this.$search.find(this.session);
+ if (range) {
+ this.gotoLine(range.end.row+1, range.end.column);
+ this.selection.setSelectionRange(range);
+ }
+ };
+
+ this.undo = function() {
+ this.session.getUndoManager().undo();
+ };
+
+ this.redo = function() {
+ this.session.getUndoManager().redo();
+ };
+
+}).call(Editor.prototype);
+
+
+exports.Editor = Editor;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('pilot/event', function(require, exports, module) {
+
+var keys = require("pilot/keys");
+var useragent = require("pilot/useragent");
+var dom = require("pilot/dom");
+
+exports.addListener = function(elem, type, callback) {
+ if (elem.addEventListener) {
+ return elem.addEventListener(type, callback, false);
+ }
+ if (elem.attachEvent) {
+ var wrapper = function() {
+ callback(window.event);
+ };
+ callback._wrapper = wrapper;
+ elem.attachEvent("on" + type, wrapper);
+ }
+};
+
+exports.removeListener = function(elem, type, callback) {
+ if (elem.removeEventListener) {
+ return elem.removeEventListener(type, callback, false);
+ }
+ if (elem.detachEvent) {
+ elem.detachEvent("on" + type, callback._wrapper || callback);
+ }
+};
+
+/**
+* Prevents propagation and clobbers the default action of the passed event
+*/
+exports.stopEvent = function(e) {
+ exports.stopPropagation(e);
+ exports.preventDefault(e);
+ return false;
+};
+
+exports.stopPropagation = function(e) {
+ if (e.stopPropagation)
+ e.stopPropagation();
+ else
+ e.cancelBubble = true;
+};
+
+exports.preventDefault = function(e) {
+ if (e.preventDefault)
+ e.preventDefault();
+ else
+ e.returnValue = false;
+};
+
+exports.getDocumentX = function(e) {
+ if (e.clientX) {
+ return e.clientX + dom.getPageScrollLeft();
+ } else {
+ return e.pageX;
+ }
+};
+
+exports.getDocumentY = function(e) {
+ if (e.clientY) {
+ return e.clientY + dom.getPageScrollTop();
+ } else {
+ return e.pageY;
+ }
+};
+
+/**
+ * @return {Number} 0 for left button, 1 for middle button, 2 for right button
+ */
+exports.getButton = function(e) {
+ if (e.type == "dblclick")
+ return 0;
+ else if (e.type == "contextmenu")
+ return 2;
+
+ // DOM Event
+ if (e.preventDefault) {
+ return e.button;
+ }
+ // old IE
+ else {
+ return {1:0, 2:2, 4:1}[e.button];
+ }
+};
+
+if (document.documentElement.setCapture) {
+ exports.capture = function(el, eventHandler, releaseCaptureHandler) {
+ function onMouseMove(e) {
+ eventHandler(e);
+ return exports.stopPropagation(e);
+ }
+
+ function onReleaseCapture(e) {
+ eventHandler && eventHandler(e);
+ releaseCaptureHandler && releaseCaptureHandler();
+
+ exports.removeListener(el, "mousemove", eventHandler);
+ exports.removeListener(el, "mouseup", onReleaseCapture);
+ exports.removeListener(el, "losecapture", onReleaseCapture);
+
+ el.releaseCapture();
+ }
+
+ exports.addListener(el, "mousemove", eventHandler);
+ exports.addListener(el, "mouseup", onReleaseCapture);
+ exports.addListener(el, "losecapture", onReleaseCapture);
+ el.setCapture();
+ };
+}
+else {
+ exports.capture = function(el, eventHandler, releaseCaptureHandler) {
+ function onMouseMove(e) {
+ eventHandler(e);
+ e.stopPropagation();
+ }
+
+ function onMouseUp(e) {
+ eventHandler && eventHandler(e);
+ releaseCaptureHandler && releaseCaptureHandler();
+
+ document.removeEventListener("mousemove", onMouseMove, true);
+ document.removeEventListener("mouseup", onMouseUp, true);
+
+ e.stopPropagation();
+ }
+
+ document.addEventListener("mousemove", onMouseMove, true);
+ document.addEventListener("mouseup", onMouseUp, true);
+ };
+}
+
+exports.addMouseWheelListener = function(el, callback) {
+ var listener = function(e) {
+ if (e.wheelDelta !== undefined) {
+ if (e.wheelDeltaX !== undefined) {
+ e.wheelX = -e.wheelDeltaX / 8;
+ e.wheelY = -e.wheelDeltaY / 8;
+ } else {
+ e.wheelX = 0;
+ e.wheelY = -e.wheelDelta / 8;
+ }
+ }
+ else {
+ if (e.axis && e.axis == e.HORIZONTAL_AXIS) {
+ e.wheelX = (e.detail || 0) * 5;
+ e.wheelY = 0;
+ } else {
+ e.wheelX = 0;
+ e.wheelY = (e.detail || 0) * 5;
+ }
+ }
+ callback(e);
+ };
+ exports.addListener(el, "DOMMouseScroll", listener);
+ exports.addListener(el, "mousewheel", listener);
+};
+
+exports.addMultiMouseDownListener = function(el, button, count, timeout, callback) {
+ var clicks = 0;
+ var startX, startY;
+
+ var listener = function(e) {
+ clicks += 1;
+ if (clicks == 1) {
+ startX = e.clientX;
+ startY = e.clientY;
+
+ setTimeout(function() {
+ clicks = 0;
+ }, timeout || 600);
+ }
+
+ if (exports.getButton(e) != button
+ || Math.abs(e.clientX - startX) > 5 || Math.abs(e.clientY - startY) > 5)
+ clicks = 0;
+
+ if (clicks == count) {
+ clicks = 0;
+ callback(e);
+ }
+ return exports.preventDefault(e);
+ };
+
+ exports.addListener(el, "mousedown", listener);
+ useragent.isIE && exports.addListener(el, "dblclick", listener);
+};
+
+function normalizeCommandKeys(callback, e, keyCode) {
+ var hashId = 0;
+ if (useragent.isOpera && useragent.isMac) {
+ hashId = 0 | (e.metaKey ? 1 : 0) | (e.altKey ? 2 : 0)
+ | (e.shiftKey ? 4 : 0) | (e.ctrlKey ? 8 : 0);
+ } else {
+ hashId = 0 | (e.ctrlKey ? 1 : 0) | (e.altKey ? 2 : 0)
+ | (e.shiftKey ? 4 : 0) | (e.metaKey ? 8 : 0);
+ }
+
+ if (keyCode in keys.MODIFIER_KEYS) {
+ switch (keys.MODIFIER_KEYS[keyCode]) {
+ case "Alt":
+ hashId = 2;
+ break;
+ case "Shift":
+ hashId = 4;
+ break
+ case "Ctrl":
+ hashId = 1;
+ break;
+ default:
+ hashId = 8;
+ break;
+ }
+ keyCode = 0;
+ }
+
+ if (hashId & 8 && (keyCode == 91 || keyCode == 93)) {
+ keyCode = 0;
+ }
+
+ // If there is no hashID and the keyCode is not a function key, then
+ // we don't call the callback as we don't handle a command key here
+ // (it's a normal key/character input).
+ if (hashId == 0 && !(keyCode in keys.FUNCTION_KEYS)) {
+ return false;
+ }
+
+ return callback(e, hashId, keyCode);
+}
+
+exports.addCommandKeyListener = function(el, callback) {
+ var addListener = exports.addListener;
+ if (useragent.isOldGecko) {
+ // Old versions of Gecko aka. Firefox < 4.0 didn't repeat the keydown
+ // event if the user pressed the key for a longer time. Instead, the
+ // keydown event was fired once and later on only the keypress event.
+ // To emulate the 'right' keydown behavior, the keyCode of the initial
+ // keyDown event is stored and in the following keypress events the
+ // stores keyCode is used to emulate a keyDown event.
+ var lastKeyDownKeyCode = null;
+ addListener(el, "keydown", function(e) {
+ lastKeyDownKeyCode = e.keyCode;
+ });
+ addListener(el, "keypress", function(e) {
+ return normalizeCommandKeys(callback, e, lastKeyDownKeyCode);
+ });
+ } else {
+ var lastDown = null;
+
+ addListener(el, "keydown", function(e) {
+ lastDown = e.keyIdentifier || e.keyCode;
+ return normalizeCommandKeys(callback, e, e.keyCode);
+ });
+
+ // repeated keys are fired as keypress and not keydown events
+ if (useragent.isMac && useragent.isOpera) {
+ addListener(el, "keypress", function(e) {
+ var keyId = e.keyIdentifier || e.keyCode;
+ if (lastDown !== keyId) {
+ return normalizeCommandKeys(callback, e, e.keyCode);
+ } else {
+ lastDown = null;
+ }
+ });
+ }
+ }
+};
+
+});
+/*! @license
+==========================================================================
+SproutCore -- JavaScript Application Framework
+copyright 2006-2009, Sprout Systems Inc., Apple Inc. and contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+SproutCore and the SproutCore logo are trademarks of Sprout Systems, Inc.
+
+For more information about SproutCore, visit http://www.sproutcore.com
+
+
+==========================================================================
+@license */
+
+// Most of the following code is taken from SproutCore with a few changes.
+
+__ace_shadowed__.define('pilot/keys', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+
+/**
+ * Helper functions and hashes for key handling.
+ */
+var Keys = (function() {
+ var ret = {
+ MODIFIER_KEYS: {
+ 16: 'Shift', 17: 'Ctrl', 18: 'Alt', 224: 'Meta'
+ },
+
+ KEY_MODS: {
+ "ctrl": 1, "alt": 2, "option" : 2,
+ "shift": 4, "meta": 8, "command": 8
+ },
+
+ FUNCTION_KEYS : {
+ 8 : "Backspace",
+ 9 : "Tab",
+ 13 : "Return",
+ 19 : "Pause",
+ 27 : "Esc",
+ 32 : "Space",
+ 33 : "PageUp",
+ 34 : "PageDown",
+ 35 : "End",
+ 36 : "Home",
+ 37 : "Left",
+ 38 : "Up",
+ 39 : "Right",
+ 40 : "Down",
+ 44 : "Print",
+ 45 : "Insert",
+ 46 : "Delete",
+ 112: "F1",
+ 113: "F2",
+ 114: "F3",
+ 115: "F4",
+ 116: "F5",
+ 117: "F6",
+ 118: "F7",
+ 119: "F8",
+ 120: "F9",
+ 121: "F10",
+ 122: "F11",
+ 123: "F12",
+ 144: "Numlock",
+ 145: "Scrolllock"
+ },
+
+ PRINTABLE_KEYS: {
+ 32: ' ', 48: '0', 49: '1', 50: '2', 51: '3', 52: '4', 53: '5',
+ 54: '6', 55: '7', 56: '8', 57: '9', 59: ';', 61: '=', 65: 'a',
+ 66: 'b', 67: 'c', 68: 'd', 69: 'e', 70: 'f', 71: 'g', 72: 'h',
+ 73: 'i', 74: 'j', 75: 'k', 76: 'l', 77: 'm', 78: 'n', 79: 'o',
+ 80: 'p', 81: 'q', 82: 'r', 83: 's', 84: 't', 85: 'u', 86: 'v',
+ 87: 'w', 88: 'x', 89: 'y', 90: 'z', 107: '+', 109: '-', 110: '.',
+ 188: ',', 190: '.', 191: '/', 192: '`', 219: '[', 220: '\\',
+ 221: ']', 222: '\"'
+ }
+ };
+
+ // A reverse map of FUNCTION_KEYS
+ for (i in ret.FUNCTION_KEYS) {
+ var name = ret.FUNCTION_KEYS[i].toUpperCase();
+ ret[name] = parseInt(i, 10);
+ }
+
+ // Add the MODIFIER_KEYS, FUNCTION_KEYS and PRINTABLE_KEYS to the KEY
+ // variables as well.
+ oop.mixin(ret, ret.MODIFIER_KEYS);
+ oop.mixin(ret, ret.PRINTABLE_KEYS);
+ oop.mixin(ret, ret.FUNCTION_KEYS);
+
+ return ret;
+})();
+oop.mixin(exports, Keys);
+
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('pilot/dom', function(require, exports, module) {
+
+exports.setText = function(elem, text) {
+ if (elem.innerText !== undefined) {
+ elem.innerText = text;
+ }
+ if (elem.textContent !== undefined) {
+ elem.textContent = text;
+ }
+};
+
+if (!document.documentElement.classList) {
+ exports.hasCssClass = function(el, name) {
+ var classes = el.className.split(/\s+/g);
+ return classes.indexOf(name) !== -1;
+ };
+
+ /**
+ * Add a CSS class to the list of classes on the given node
+ */
+ exports.addCssClass = function(el, name) {
+ if (!exports.hasCssClass(el, name)) {
+ el.className += " " + name;
+ }
+ };
+
+ /**
+ * Remove a CSS class from the list of classes on the given node
+ */
+ exports.removeCssClass = function(el, name) {
+ var classes = el.className.split(/\s+/g);
+ while (true) {
+ var index = classes.indexOf(name);
+ if (index == -1) {
+ break;
+ }
+ classes.splice(index, 1);
+ }
+ el.className = classes.join(" ");
+ };
+
+ exports.toggleCssClass = function(el, name) {
+ var classes = el.className.split(/\s+/g), add = true;
+ while (true) {
+ var index = classes.indexOf(name);
+ if (index == -1) {
+ break;
+ }
+ add = false;
+ classes.splice(index, 1);
+ }
+ if(add)
+ classes.push(name);
+
+ el.className = classes.join(" ");
+ return add;
+ };
+} else {
+ exports.hasCssClass = function(el, name) {
+ return el.classList.contains(name);
+ };
+
+ exports.addCssClass = function(el, name) {
+ el.classList.add(name);
+ };
+
+ exports.removeCssClass = function(el, name) {
+ el.classList.remove(name);
+ };
+
+ exports.toggleCssClass = function(el, name) {
+ return el.classList.toggle(name);
+ };
+}
+
+/**
+ * Add or remove a CSS class from the list of classes on the given node
+ * depending on the value of include
+ */
+exports.setCssClass = function(node, className, include) {
+ if (include) {
+ exports.addCssClass(node, className);
+ } else {
+ exports.removeCssClass(node, className);
+ }
+};
+
+exports.importCssString = function(cssText, doc){
+ doc = doc || document;
+
+ if (doc.createStyleSheet) {
+ var sheet = doc.createStyleSheet();
+ sheet.cssText = cssText;
+ }
+ else {
+ var style = doc.createElement("style");
+ style.appendChild(doc.createTextNode(cssText));
+ doc.getElementsByTagName("head")[0].appendChild(style);
+ }
+};
+
+exports.getInnerWidth = function(element) {
+ return (parseInt(exports.computedStyle(element, "paddingLeft"))
+ + parseInt(exports.computedStyle(element, "paddingRight")) + element.clientWidth);
+};
+
+exports.getInnerHeight = function(element) {
+ return (parseInt(exports.computedStyle(element, "paddingTop"))
+ + parseInt(exports.computedStyle(element, "paddingBottom")) + element.clientHeight);
+};
+
+if (window.pageYOffset !== undefined) {
+ exports.getPageScrollTop = function() {
+ return window.pageYOffset;
+ };
+
+ exports.getPageScrollLeft = function() {
+ return window.pageXOffset;
+ };
+}
+else {
+ exports.getPageScrollTop = function() {
+ return document.body.scrollTop;
+ };
+
+ exports.getPageScrollLeft = function() {
+ return document.body.scrollLeft;
+ };
+}
+
+exports.computedStyle = function(element, style) {
+ if (window.getComputedStyle) {
+ return (window.getComputedStyle(element, "") || {})[style] || "";
+ }
+ else {
+ return element.currentStyle[style];
+ }
+};
+
+exports.scrollbarWidth = function() {
+
+ var inner = document.createElement('p');
+ inner.style.width = "100%";
+ inner.style.height = "200px";
+
+ var outer = document.createElement("div");
+ var style = outer.style;
+
+ style.position = "absolute";
+ style.left = "-10000px";
+ style.overflow = "hidden";
+ style.width = "200px";
+ style.height = "150px";
+
+ outer.appendChild(inner);
+ document.body.appendChild(outer);
+ var noScrollbar = inner.offsetWidth;
+
+ style.overflow = "scroll";
+ var withScrollbar = inner.offsetWidth;
+
+ if (noScrollbar == withScrollbar) {
+ withScrollbar = outer.clientWidth;
+ }
+
+ document.body.removeChild(outer);
+
+ return noScrollbar-withScrollbar;
+};
+
+/**
+ * Optimized set innerHTML. This is faster than plain innerHTML if the element
+ * already contains a lot of child elements.
+ *
+ * See http://blog.stevenlevithan.com/archives/faster-than-innerhtml for details
+ */
+exports.setInnerHtml = function(el, innerHtml) {
+ var element = el.cloneNode(false);//document.createElement("div");
+ element.innerHTML = innerHtml;
+ el.parentNode.replaceChild(element, el);
+ return element;
+};
+
+exports.setInnerText = function(el, innerText) {
+ if ("textContent" in document.body)
+ el.textContent = innerText;
+ else
+ el.innerText = innerText;
+
+};
+
+exports.getInnerText = function(el) {
+ if ("textContent" in document.body)
+ return el.textContent;
+ else
+ return el.innerText;
+};
+
+exports.getParentWindow = function(document) {
+ return document.defaultView || document.parentWindow;
+};
+
+exports.getSelectionStart = function(textarea) {
+ // TODO IE
+ var start;
+ try {
+ start = textarea.selectionStart || 0;
+ } catch (e) {
+ start = 0;
+ }
+ return start;
+};
+
+exports.setSelectionStart = function(textarea, start) {
+ // TODO IE
+ return textarea.selectionStart = start;
+};
+
+exports.getSelectionEnd = function(textarea) {
+ // TODO IE
+ var end;
+ try {
+ end = textarea.selectionEnd || 0;
+ } catch (e) {
+ end = 0;
+ }
+ return end;
+};
+
+exports.setSelectionEnd = function(textarea, end) {
+ // TODO IE
+ return textarea.selectionEnd = end;
+};
+
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/keyboard/textinput', function(require, exports, module) {
+
+var event = require("pilot/event");
+var useragent = require("pilot/useragent");
+
+var TextInput = function(parentNode, host) {
+
+ var text = document.createElement("textarea");
+ text.style.left = "-10000px";
+ parentNode.appendChild(text);
+
+ var PLACEHOLDER = String.fromCharCode(0);
+ sendText();
+
+ var inCompostion = false;
+ var copied = false;
+ var tempStyle = '';
+
+ function sendText(valueToSend) {
+ if (!copied) {
+ var value = valueToSend || text.value;
+ if (value) {
+ if (value.charCodeAt(value.length-1) == PLACEHOLDER.charCodeAt(0)) {
+ value = value.slice(0, -1);
+ if (value)
+ host.onTextInput(value);
+ } else
+ host.onTextInput(value);
+ }
+ }
+ copied = false;
+
+ // Safari doesn't fire copy events if no text is selected
+ text.value = PLACEHOLDER;
+ text.select();
+ }
+
+ var onTextInput = function(e) {
+ if (useragent.isIE && text.value.charCodeAt(0) > 128) return;
+ setTimeout(function() {
+ if (!inCompostion)
+ sendText();
+ }, 0);
+ };
+
+ var onCompositionStart = function(e) {
+ inCompostion = true;
+ if (!useragent.isIE) {
+ sendText();
+ text.value = "";
+ };
+ host.onCompositionStart();
+ if (!useragent.isGecko) setTimeout(onCompositionUpdate, 0);
+ };
+
+ var onCompositionUpdate = function() {
+ if (!inCompostion) return;
+ host.onCompositionUpdate(text.value);
+ };
+
+ var onCompositionEnd = function() {
+ inCompostion = false;
+ host.onCompositionEnd();
+ setTimeout(function () {
+ sendText();
+ }, 0);
+ };
+
+ var onCopy = function(e) {
+ copied = true;
+ var copyText = host.getCopyText();
+ if(copyText)
+ text.value = copyText;
+ else
+ e.preventDefault();
+ text.select();
+ setTimeout(function () {
+ sendText();
+ }, 0);
+ };
+
+ var onCut = function(e) {
+ copied = true;
+ var copyText = host.getCopyText();
+ if(copyText) {
+ text.value = copyText;
+ host.onCut();
+ } else
+ e.preventDefault();
+ text.select();
+ setTimeout(function () {
+ sendText();
+ }, 0);
+ };
+
+ event.addCommandKeyListener(text, host.onCommandKey.bind(host));
+ event.addListener(text, "keypress", onTextInput);
+ if (useragent.isIE) {
+ var keytable = { 13:1, 27:1 };
+ event.addListener(text, "keyup", function (e) {
+ if (inCompostion && (!text.value || keytable[e.keyCode]))
+ setTimeout(onCompositionEnd, 0);
+ if ((text.value.charCodeAt(0)|0) < 129) {
+ return;
+ };
+ inCompostion ? onCompositionUpdate() : onCompositionStart();
+ });
+ };
+ event.addListener(text, "textInput", onTextInput);
+ event.addListener(text, "paste", function(e) {
+ // Some browsers support the event.clipboardData API. Use this to get
+ // the pasted content which increases speed if pasting a lot of lines.
+ if (e.clipboardData && e.clipboardData.getData) {
+ sendText(e.clipboardData.getData("text/plain"));
+ e.preventDefault();
+ } else
+ // If a browser doesn't support any of the things above, use the regular
+ // method to detect the pasted input.
+ {
+ onTextInput();
+ }
+ });
+ if (!useragent.isIE) {
+ event.addListener(text, "propertychange", onTextInput);
+ };
+
+ if (useragent.isIE) {
+ event.addListener(text, "beforecopy", function(e) {
+ var copyText = host.getCopyText();
+ if(copyText)
+ clipboardData.setData("Text", copyText);
+ else
+ e.preventDefault();
+ });
+ event.addListener(parentNode, "keydown", function(e) {
+ if (e.ctrlKey && e.keyCode == 88) {
+ var copyText = host.getCopyText();
+ if (copyText) {
+ clipboardData.setData("Text", copyText);
+ host.onCut();
+ }
+ event.preventDefault(e)
+ }
+ });
+ }
+ else {
+ event.addListener(text, "copy", onCopy);
+ event.addListener(text, "cut", onCut);
+ }
+
+ event.addListener(text, "compositionstart", onCompositionStart);
+ if (useragent.isGecko) {
+ event.addListener(text, "text", onCompositionUpdate);
+ };
+ if (useragent.isWebKit) {
+ event.addListener(text, "keyup", onCompositionUpdate);
+ };
+ event.addListener(text, "compositionend", onCompositionEnd);
+
+ event.addListener(text, "blur", function() {
+ host.onBlur();
+ });
+
+ event.addListener(text, "focus", function() {
+ host.onFocus();
+ text.select();
+ });
+
+ this.focus = function() {
+ host.onFocus();
+ text.select();
+ text.focus();
+ };
+
+ this.blur = function() {
+ text.blur();
+ };
+
+ this.getElement = function() {
+ return text;
+ };
+
+ this.onContextMenu = function(mousePos, isEmpty){
+ if (mousePos) {
+ if(!tempStyle)
+ tempStyle = text.style.cssText;
+ text.style.cssText = 'position:fixed; z-index:1000;' +
+ 'left:' + (mousePos.x - 2) + 'px; top:' + (mousePos.y - 2) + 'px;'
+
+ }
+ if (isEmpty)
+ text.value='';
+ }
+
+ this.onContextMenuClose = function(){
+ setTimeout(function () {
+ if (tempStyle) {
+ text.style.cssText = tempStyle;
+ tempStyle = '';
+ }
+ sendText();
+ }, 0);
+ }
+};
+
+exports.TextInput = TextInput;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/mouse_handler', function(require, exports, module) {
+
+var event = require("pilot/event");
+
+var MouseHandler = function(editor) {
+ this.editor = editor;
+ event.addListener(editor.container, "mousedown", function(e) {
+ editor.focus();
+ return event.preventDefault(e);
+ });
+ event.addListener(editor.container, "selectstart", function(e) {
+ return event.preventDefault(e);
+ });
+
+ var mouseTarget = editor.renderer.getMouseEventTarget();
+ event.addListener(mouseTarget, "mousedown", this.onMouseDown.bind(this));
+ event.addMultiMouseDownListener(mouseTarget, 0, 2, 500, this.onMouseDoubleClick.bind(this));
+ event.addMultiMouseDownListener(mouseTarget, 0, 3, 600, this.onMouseTripleClick.bind(this));
+ event.addMouseWheelListener(mouseTarget, this.onMouseWheel.bind(this));
+};
+
+(function() {
+
+ this.$scrollSpeed = 1;
+ this.setScrollSpeed = function(speed) {
+ this.$scrollSpeed = speed;
+ };
+
+ this.getScrollSpeed = function() {
+ return this.$scrollSpeed;
+ };
+
+ this.onMouseDown = function(e) {
+ var pageX = event.getDocumentX(e);
+ var pageY = event.getDocumentY(e);
+ var editor = this.editor;
+
+ var pos = editor.renderer.screenToTextCoordinates(pageX, pageY);
+ pos.row = Math.max(0, Math.min(pos.row, editor.session.getLength()-1));
+
+ var button = event.getButton(e)
+ if (button != 0) {
+ var isEmpty = editor.selection.isEmpty()
+ if (isEmpty) {
+ editor.moveCursorToPosition(pos);
+ }
+ if(button == 2) {
+ editor.textInput.onContextMenu({x: pageX, y: pageY}, isEmpty);
+ event.capture(editor.container, function(){}, editor.textInput.onContextMenuClose);
+ }
+ return;
+ }
+
+ if (e.shiftKey)
+ editor.selection.selectToPosition(pos)
+ else {
+ editor.moveCursorToPosition(pos);
+ if (!editor.$clickSelection)
+ editor.selection.clearSelection(pos.row, pos.column);
+ }
+
+ editor.renderer.scrollCursorIntoView();
+
+ var self = this;
+ var mousePageX, mousePageY;
+
+ var onMouseSelection = function(e) {
+ mousePageX = event.getDocumentX(e);
+ mousePageY = event.getDocumentY(e);
+ };
+
+ var onMouseSelectionEnd = function() {
+ clearInterval(timerId);
+ self.$clickSelection = null;
+ };
+
+ var onSelectionInterval = function() {
+ if (mousePageX === undefined || mousePageY === undefined)
+ return;
+
+ var cursor = editor.renderer.screenToTextCoordinates(mousePageX, mousePageY);
+ cursor.row = Math.max(0, Math.min(cursor.row, editor.session.getLength()-1));
+
+ if (self.$clickSelection) {
+ if (self.$clickSelection.contains(cursor.row, cursor.column)) {
+ editor.selection.setSelectionRange(self.$clickSelection);
+ } else {
+ if (self.$clickSelection.compare(cursor.row, cursor.column) == -1) {
+ var anchor = self.$clickSelection.end;
+ } else {
+ var anchor = self.$clickSelection.start;
+ }
+ editor.selection.setSelectionAnchor(anchor.row, anchor.column);
+ editor.selection.selectToPosition(cursor);
+ }
+ }
+ else {
+ editor.selection.selectToPosition(cursor);
+ }
+
+ editor.renderer.scrollCursorIntoView();
+ };
+
+ event.capture(editor.container, onMouseSelection, onMouseSelectionEnd);
+ var timerId = setInterval(onSelectionInterval, 20);
+
+ return event.preventDefault(e);
+ };
+
+ this.onMouseDoubleClick = function(e) {
+ this.editor.selection.selectWord();
+ this.$clickSelection = this.editor.getSelectionRange();
+ };
+
+ this.onMouseTripleClick = function(e) {
+ this.editor.selection.selectLine();
+ this.$clickSelection = this.editor.getSelectionRange();
+ };
+
+ this.onMouseWheel = function(e) {
+ var speed = this.$scrollSpeed * 2;
+
+ this.editor.renderer.scrollBy(e.wheelX * speed, e.wheelY * speed);
+ return event.preventDefault(e);
+ };
+
+
+}).call(MouseHandler.prototype);
+
+exports.MouseHandler = MouseHandler;
+});
+/* ***** 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
+ * Julian Viereck
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/keyboard/keybinding', function(require, exports, module) {
+
+var useragent = require("pilot/useragent");
+var keyUtil = require("pilot/keys");
+var event = require("pilot/event");
+var settings = require("pilot/settings").settings;
+var HashHandler = require("ace/keyboard/hash_handler").HashHandler;
+var default_mac = require("ace/keyboard/keybinding/default_mac").bindings;
+var default_win = require("ace/keyboard/keybinding/default_win").bindings;
+var canon = require("pilot/canon");
+require("ace/commands/default_commands");
+
+var KeyBinding = function(editor, config) {
+ this.$editor = editor;
+ this.$data = { };
+ this.$keyboardHandler = null;
+ this.$defaulKeyboardHandler = new HashHandler(config || (useragent.isMac
+ ? default_mac
+ : default_win));
+};
+
+(function() {
+ this.setKeyboardHandler = function(keyboardHandler) {
+ if (this.$keyboardHandler != keyboardHandler) {
+ this.$data = { };
+ this.$keyboardHandler = keyboardHandler;
+ }
+ };
+
+ this.getKeyboardHandler = function() {
+ return this.$keyboardHandler;
+ };
+
+ this.$callKeyboardHandler = function (e, hashId, keyOrText, keyCode) {
+ var toExecute;
+ if (this.$keyboardHandler) {
+ toExecute =
+ this.$keyboardHandler.handleKeyboard(this.$data, hashId, keyOrText, keyCode, e);
+ }
+
+ // If there is nothing to execute yet, then use the default keymapping.
+ if (!toExecute || !toExecute.command) {
+ toExecute = this.$defaulKeyboardHandler.
+ handleKeyboard(this.$data, hashId, keyOrText, keyCode, e);
+ }
+
+ if (toExecute) {
+ var success = canon.exec(toExecute.command,
+ {editor: this.$editor}, toExecute.args);
+ if (success) {
+ return event.stopEvent(e);
+ }
+ }
+ };
+
+ this.onCommandKey = function(e, hashId, keyCode) {
+ key = (keyUtil[keyCode] ||
+ String.fromCharCode(keyCode)).toLowerCase();
+
+ this.$callKeyboardHandler(e, hashId, key, keyCode);
+ };
+
+ this.onTextInput = function(text) {
+ this.$callKeyboardHandler({}, 0, text, 0);
+ }
+
+}).call(KeyBinding.prototype);
+
+exports.KeyBinding = KeyBinding;
+});
+/* ***** 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
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/keyboard/hash_handler', function(require, exports, module) {
+
+var keyUtil = require("pilot/keys");
+
+function HashHandler(config) {
+ this.setConfig(config);
+}
+
+(function() {
+ function splitSafe(s, separator, limit, bLowerCase) {
+ return (bLowerCase && s.toLowerCase() || s)
+ .replace(/(?:^\s+|\n|\s+$)/g, "")
+ .split(new RegExp("[\\s ]*" + separator + "[\\s ]*", "g"), limit || 999);
+ }
+
+ function parseKeys(keys, val, ret) {
+ var key,
+ hashId = 0,
+ parts = splitSafe(keys, "\\-", null, true),
+ i = 0,
+ l = parts.length;
+
+ for (; i < l; ++i) {
+ if (keyUtil.KEY_MODS[parts[i]])
+ hashId = hashId | keyUtil.KEY_MODS[parts[i]];
+ else
+ key = parts[i] || "-"; //when empty, the splitSafe removed a '-'
+ }
+
+ (ret[hashId] || (ret[hashId] = {}))[key] = val;
+ return ret;
+ }
+
+ function objectReverse(obj, keySplit) {
+ var i, j, l, key,
+ ret = {};
+ for (i in obj) {
+ key = obj[i];
+ if (keySplit && typeof key == "string") {
+ key = key.split(keySplit);
+ for (j = 0, l = key.length; j < l; ++j)
+ parseKeys.call(this, key[j], i, ret);
+ }
+ else {
+ parseKeys.call(this, key, i, ret);
+ }
+ }
+ return ret;
+ }
+
+ this.setConfig = function(config) {
+ this.$config = config;
+ if (typeof this.$config.reverse == "undefined")
+ this.$config.reverse = objectReverse.call(this, this.$config, "|");
+ };
+
+ /**
+ * This function is called by keyBinding.
+ */
+ this.handleKeyboard = function(data, hashId, textOrKey, keyCode) {
+ // Figure out if a commandKey was pressed or just some text was insert.
+ if (hashId != 0 || keyCode != 0) {
+ return {
+ command: (this.$config.reverse[hashId] || {})[textOrKey]
+ }
+ } else {
+ return {
+ command: "inserttext",
+ args: {
+ text: textOrKey
+ }
+ }
+ }
+ }
+}).call(HashHandler.prototype)
+
+exports.HashHandler = HashHandler;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/keyboard/keybinding/default_mac', function(require, exports, module) {
+
+exports.bindings = {
+ "selectall": "Command-A",
+ "removeline": "Command-D",
+ "gotoline": "Command-L",
+ "togglecomment": "Command-7",
+ "findnext": "Command-K",
+ "findprevious": "Command-Shift-K",
+ "find": "Command-F",
+ "replace": "Command-R",
+ "undo": "Command-Z",
+ "redo": "Command-Shift-Z|Command-Y",
+ "overwrite": "Insert",
+ "copylinesup": "Command-Option-Up",
+ "movelinesup": "Option-Up",
+ "selecttostart": "Command-Shift-Up",
+ "gotostart": "Command-Home|Command-Up",
+ "selectup": "Shift-Up",
+ "golineup": "Up|Ctrl-P",
+ "copylinesdown": "Command-Option-Down",
+ "movelinesdown": "Option-Down",
+ "selecttoend": "Command-Shift-Down",
+ "gotoend": "Command-End|Command-Down",
+ "selectdown": "Shift-Down",
+ "golinedown": "Down|Ctrl-N",
+ "selectwordleft": "Option-Shift-Left",
+ "gotowordleft": "Option-Left",
+ "selecttolinestart": "Command-Shift-Left",
+ "gotolinestart": "Command-Left|Home|Ctrl-A",
+ "selectleft": "Shift-Left",
+ "gotoleft": "Left|Ctrl-B",
+ "selectwordright": "Option-Shift-Right",
+ "gotowordright": "Option-Right",
+ "selecttolineend": "Command-Shift-Right",
+ "gotolineend": "Command-Right|End|Ctrl-E",
+ "selectright": "Shift-Right",
+ "gotoright": "Right|Ctrl-F",
+ "selectpagedown": "Shift-PageDown",
+ "pagedown": "PageDown",
+ "gotopagedown": "Option-PageDown|Ctrl-V",
+ "selectpageup": "Shift-PageUp",
+ "pageup": "PageUp",
+ "gotopageup": "Option-PageUp",
+ "selectlinestart": "Shift-Home",
+ "selectlineend": "Shift-End",
+ "del": "Delete|Ctrl-D",
+ "backspace": "Ctrl-Backspace|Command-Backspace|Shift-Backspace|Backspace|Ctrl-H",
+ "removetolineend": "Ctrl-K",
+ "removetolinestart": "Option-Backspace",
+ "removewordleft": "Alt-Backspace|Ctrl-Alt-Backspace",
+ "removewordright": "Alt-Delete",
+ "outdent": "Shift-Tab",
+ "indent": "Tab",
+ "transposeletters": "Ctrl-T",
+ "splitline": "Ctrl-O",
+ "centerselection": "Ctrl-L"
+};
+
+});/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/keyboard/keybinding/default_win', function(require, exports, module) {
+
+exports.bindings = {
+ "selectall": "Ctrl-A",
+ "removeline": "Ctrl-D",
+ "gotoline": "Ctrl-L",
+ "togglecomment": "Ctrl-7",
+ "findnext": "Ctrl-K",
+ "findprevious": "Ctrl-Shift-K",
+ "find": "Ctrl-F",
+ "replace": "Ctrl-R",
+ "undo": "Ctrl-Z",
+ "redo": "Ctrl-Shift-Z|Ctrl-Y",
+ "overwrite": "Insert",
+ "copylinesup": "Ctrl-Alt-Up",
+ "movelinesup": "Alt-Up",
+ "selecttostart": "Alt-Shift-Up",
+ "gotostart": "Ctrl-Home|Ctrl-Up",
+ "selectup": "Shift-Up",
+ "golineup": "Up",
+ "copylinesdown": "Ctrl-Alt-Down",
+ "movelinesdown": "Alt-Down",
+ "selecttoend": "Alt-Shift-Down",
+ "gotoend": "Ctrl-End|Ctrl-Down",
+ "selectdown": "Shift-Down",
+ "golinedown": "Down",
+ "selectwordleft": "Ctrl-Shift-Left",
+ "gotowordleft": "Ctrl-Left",
+ "selecttolinestart": "Alt-Shift-Left",
+ "gotolinestart": "Alt-Left|Home",
+ "selectleft": "Shift-Left",
+ "gotoleft": "Left",
+ "selectwordright": "Ctrl-Shift-Right",
+ "gotowordright": "Ctrl-Right",
+ "selecttolineend": "Alt-Shift-Right",
+ "gotolineend": "Alt-Right|End",
+ "selectright": "Shift-Right",
+ "gotoright": "Right",
+ "selectpagedown": "Shift-PageDown",
+ "gotopagedown": "PageDown",
+ "selectpageup": "Shift-PageUp",
+ "gotopageup": "PageUp",
+ "selectlinestart": "Shift-Home",
+ "selectlineend": "Shift-End",
+ "del": "Delete",
+ "backspace": "Ctrl-Backspace|Command-Backspace|Option-Backspace|Shift-Backspace|Backspace",
+ "outdent": "Shift-Tab",
+ "indent": "Tab"
+};
+
+});
+/* ***** 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
+ * Julian Viereck
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/commands/default_commands', function(require, exports, module) {
+
+var lang = require("pilot/lang");
+var canon = require("pilot/canon");
+
+canon.addCommand({
+ name: "null",
+ exec: function(env, args, request) { }
+});
+
+canon.addCommand({
+ name: "selectall",
+ exec: function(env, args, request) { env.editor.selectAll(); }
+});
+canon.addCommand({
+ name: "removeline",
+ exec: function(env, args, request) { env.editor.removeLines(); }
+});
+canon.addCommand({
+ name: "gotoline",
+ exec: function(env, args, request) {
+ var line = parseInt(prompt("Enter line number:"));
+ if (!isNaN(line)) {
+ env.editor.gotoLine(line);
+ }
+ }
+});
+canon.addCommand({
+ name: "togglecomment",
+ exec: function(env, args, request) { env.editor.toggleCommentLines(); }
+});
+canon.addCommand({
+ name: "findnext",
+ exec: function(env, args, request) { env.editor.findNext(); }
+});
+canon.addCommand({
+ name: "findprevious",
+ exec: function(env, args, request) { env.editor.findPrevious(); }
+});
+canon.addCommand({
+ name: "find",
+ exec: function(env, args, request) {
+ var needle = prompt("Find:");
+ env.editor.find(needle);
+ }
+});
+canon.addCommand({
+ name: "undo",
+ exec: function(env, args, request) { env.editor.undo(); }
+});
+canon.addCommand({
+ name: "redo",
+ exec: function(env, args, request) { env.editor.redo(); }
+});
+canon.addCommand({
+ name: "redo",
+ exec: function(env, args, request) { env.editor.redo(); }
+});
+canon.addCommand({
+ name: "overwrite",
+ exec: function(env, args, request) { env.editor.toggleOverwrite(); }
+});
+canon.addCommand({
+ name: "copylinesup",
+ exec: function(env, args, request) { env.editor.copyLinesUp(); }
+});
+canon.addCommand({
+ name: "movelinesup",
+ exec: function(env, args, request) { env.editor.moveLinesUp(); }
+});
+canon.addCommand({
+ name: "selecttostart",
+ exec: function(env, args, request) { env.editor.getSelection().selectFileStart(); }
+});
+canon.addCommand({
+ name: "gotostart",
+ exec: function(env, args, request) { env.editor.navigateFileStart(); }
+});
+canon.addCommand({
+ name: "selectup",
+ exec: function(env, args, request) { env.editor.getSelection().selectUp(); }
+});
+canon.addCommand({
+ name: "golineup",
+ exec: function(env, args, request) { env.editor.navigateUp(args.times); }
+});
+canon.addCommand({
+ name: "copylinesdown",
+ exec: function(env, args, request) { env.editor.copyLinesDown(); }
+});
+canon.addCommand({
+ name: "movelinesdown",
+ exec: function(env, args, request) { env.editor.moveLinesDown(); }
+});
+canon.addCommand({
+ name: "selecttoend",
+ exec: function(env, args, request) { env.editor.getSelection().selectFileEnd(); }
+});
+canon.addCommand({
+ name: "gotoend",
+ exec: function(env, args, request) { env.editor.navigateFileEnd(); }
+});
+canon.addCommand({
+ name: "selectdown",
+ exec: function(env, args, request) { env.editor.getSelection().selectDown(); }
+});
+canon.addCommand({
+ name: "golinedown",
+ exec: function(env, args, request) { env.editor.navigateDown(args.times); }
+});
+canon.addCommand({
+ name: "selectwordleft",
+ exec: function(env, args, request) { env.editor.getSelection().selectWordLeft(); }
+});
+canon.addCommand({
+ name: "gotowordleft",
+ exec: function(env, args, request) { env.editor.navigateWordLeft(); }
+});
+canon.addCommand({
+ name: "selecttolinestart",
+ exec: function(env, args, request) { env.editor.getSelection().selectLineStart(); }
+});
+canon.addCommand({
+ name: "gotolinestart",
+ exec: function(env, args, request) { env.editor.navigateLineStart(); }
+});
+canon.addCommand({
+ name: "selectleft",
+ exec: function(env, args, request) { env.editor.getSelection().selectLeft(); }
+});
+canon.addCommand({
+ name: "gotoleft",
+ exec: function(env, args, request) { env.editor.navigateLeft(args.times); }
+});
+canon.addCommand({
+ name: "selectwordright",
+ exec: function(env, args, request) { env.editor.getSelection().selectWordRight(); }
+});
+canon.addCommand({
+ name: "gotowordright",
+ exec: function(env, args, request) { env.editor.navigateWordRight(); }
+});
+canon.addCommand({
+ name: "selecttolineend",
+ exec: function(env, args, request) { env.editor.getSelection().selectLineEnd(); }
+});
+canon.addCommand({
+ name: "gotolineend",
+ exec: function(env, args, request) { env.editor.navigateLineEnd(); }
+});
+canon.addCommand({
+ name: "selectright",
+ exec: function(env, args, request) { env.editor.getSelection().selectRight(); }
+});
+canon.addCommand({
+ name: "gotoright",
+ exec: function(env, args, request) { env.editor.navigateRight(args.times); }
+});
+canon.addCommand({
+ name: "selectpagedown",
+ exec: function(env, args, request) { env.editor.selectPageDown(); }
+});
+canon.addCommand({
+ name: "pagedown",
+ exec: function(env, args, request) { env.editor.scrollPageDown(); }
+});
+canon.addCommand({
+ name: "gotopagedown",
+ exec: function(env, args, request) { env.editor.gotoPageDown(); }
+});
+canon.addCommand({
+ name: "selectpageup",
+ exec: function(env, args, request) { env.editor.selectPageUp(); }
+});
+canon.addCommand({
+ name: "pageup",
+ exec: function(env, args, request) { env.editor.scrollPageUp(); }
+});
+canon.addCommand({
+ name: "gotopageup",
+ exec: function(env, args, request) { env.editor.gotoPageUp(); }
+});
+canon.addCommand({
+ name: "selectlinestart",
+ exec: function(env, args, request) { env.editor.getSelection().selectLineStart(); }
+});
+canon.addCommand({
+ name: "gotolinestart",
+ exec: function(env, args, request) { env.editor.navigateLineStart(); }
+});
+canon.addCommand({
+ name: "selectlineend",
+ exec: function(env, args, request) { env.editor.getSelection().selectLineEnd(); }
+});
+canon.addCommand({
+ name: "gotolineend",
+ exec: function(env, args, request) { env.editor.navigateLineEnd(); }
+});
+canon.addCommand({
+ name: "del",
+ exec: function(env, args, request) { env.editor.removeRight(); }
+});
+canon.addCommand({
+ name: "backspace",
+ exec: function(env, args, request) { env.editor.removeLeft(); }
+});
+canon.addCommand({
+ name: "removetolinestart",
+ exec: function(env, args, request) { env.editor.removeToLineStart(); }
+});
+canon.addCommand({
+ name: "removetolineend",
+ exec: function(env, args, request) { env.editor.removeToLineEnd(); }
+});
+canon.addCommand({
+ name: "removewordleft",
+ exec: function(env, args, request) { env.editor.removeWordLeft(); }
+});
+canon.addCommand({
+ name: "removewordright",
+ exec: function(env, args, request) { env.editor.removeWordRight(); }
+});
+canon.addCommand({
+ name: "outdent",
+ exec: function(env, args, request) { env.editor.blockOutdent(); }
+});
+canon.addCommand({
+ name: "indent",
+ exec: function(env, args, request) { env.editor.indent(); }
+});
+canon.addCommand({
+ name: "inserttext",
+ exec: function(env, args, request) {
+ env.editor.insert(lang.stringRepeat(args.text || "", args.times || 1));
+ }
+});
+canon.addCommand({
+ name: "centerselection",
+ exec: function(env, args, request) { env.editor.centerSelection(); }
+});
+canon.addCommand({
+ name: "splitline",
+ exec: function(env, args, request) { env.editor.splitLine(); }
+});
+canon.addCommand({
+ name: "transposeletters",
+ exec: function(env, args, request) { env.editor.transposeLetters(); }
+});
+
+
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/edit_session', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+var lang = require("pilot/lang");
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+var Selection = require("ace/selection").Selection;
+var TextMode = require("ace/mode/text").Mode;
+var Range = require("ace/range").Range;
+var Document = require("ace/document").Document;
+
+var NO_CHANGE_DELTAS = {};
+
+var EditSession = function(text, mode) {
+ this.$modified = true;
+ this.$breakpoints = [];
+ this.$frontMarkers = {};
+ this.$backMarkers = {};
+ this.$markerId = 1;
+ this.$wrapData = [];
+ this.listeners = [];
+
+ if (text instanceof Document) {
+ this.setDocument(text);
+ } else {
+ this.setDocument(new Document(text));
+ }
+
+ this.selection = new Selection(this);
+ if (mode)
+ this.setMode(mode);
+};
+
+
+(function() {
+
+ oop.implement(this, EventEmitter);
+
+ this.setDocument = function(doc) {
+ if (this.doc)
+ throw new Error("Document is already set");
+
+ this.doc = doc;
+ doc.on("change", this.onChange.bind(this));
+ };
+
+ this.getDocument = function() {
+ return this.doc;
+ };
+
+ this.onChange = function(e) {
+ var delta = e.data;
+ this.$modified = true;
+ if (!this.$fromUndo && this.$undoManager) {
+ this.$deltas.push(delta);
+ this.$informUndoManager.schedule();
+ }
+
+ this.$updateWrapDataOnChange(e);
+ this._dispatchEvent("change", e);
+ };
+
+ this.setValue = function(text) {
+ this.doc.setValue(text);
+ this.$deltas = [];
+ };
+
+ this.getValue =
+ this.toString = function() {
+ return this.doc.getValue();
+ };
+
+ this.getSelection = function() {
+ return this.selection;
+ };
+
+ this.setUndoManager = function(undoManager) {
+ this.$undoManager = undoManager;
+ this.$deltas = [];
+
+ if (this.$informUndoManager) {
+ this.$informUndoManager.cancel();
+ }
+
+ if (undoManager) {
+ var self = this;
+ this.$informUndoManager = lang.deferredCall(function() {
+ if (self.$deltas.length > 0)
+ undoManager.execute({
+ action : "aceupdate",
+ args : [self.$deltas, self]
+ });
+ self.$deltas = [];
+ });
+ }
+ };
+
+ this.$defaultUndoManager = {
+ undo: function() {},
+ redo: function() {}
+ };
+
+ this.getUndoManager = function() {
+ return this.$undoManager || this.$defaultUndoManager;
+ },
+
+ this.getTabString = function() {
+ if (this.getUseSoftTabs()) {
+ return lang.stringRepeat(" ", this.getTabSize());
+ } else {
+ return "\t";
+ }
+ };
+
+ this.$useSoftTabs = true;
+ this.setUseSoftTabs = function(useSoftTabs) {
+ if (this.$useSoftTabs === useSoftTabs) return;
+
+ this.$useSoftTabs = useSoftTabs;
+ };
+
+ this.getUseSoftTabs = function() {
+ return this.$useSoftTabs;
+ };
+
+ this.$tabSize = 4;
+ this.setTabSize = function(tabSize) {
+ if (isNaN(tabSize) || this.$tabSize === tabSize) return;
+
+ this.$modified = true;
+ this.$tabSize = tabSize;
+ this._dispatchEvent("changeTabSize");
+ };
+
+ this.getTabSize = function() {
+ return this.$tabSize;
+ };
+
+ this.isTabStop = function(position) {
+ return this.$useSoftTabs && (position.column % this.$tabSize == 0);
+ };
+
+ this.getBreakpoints = function() {
+ return this.$breakpoints;
+ };
+
+ this.setBreakpoints = function(rows) {
+ this.$breakpoints = [];
+ for (var i=0; i 0) {
+ inToken = !!line.charAt(column - 1).match(this.tokenRe);
+ }
+
+ if (!inToken) {
+ inToken = !!line.charAt(column).match(this.tokenRe);
+ }
+
+ var re = inToken ? this.tokenRe : this.nonTokenRe;
+
+ var start = column;
+ if (start > 0) {
+ do {
+ start--;
+ }
+ while (start >= 0 && line.charAt(start).match(re));
+ start++;
+ }
+
+ var end = column;
+ while (end < line.length && line.charAt(end).match(re)) {
+ end++;
+ }
+
+ return new Range(row, start, row, end);
+ };
+
+ this.setNewLineMode = function(newLineMode) {
+ this.doc.setNewLineMode(newLineMode);
+ };
+
+ this.getNewLineMode = function() {
+ return this.doc.getNewLineMode();
+ };
+
+ this.$mode = null;
+ this.setMode = function(mode) {
+ if (this.$mode === mode) return;
+
+ if (this.$worker)
+ this.$worker.terminate();
+
+ if (window.Worker && !require.noWorker)
+ this.$worker = mode.createWorker(this);
+ else
+ this.$worker = null;
+
+ this.$mode = mode;
+ this._dispatchEvent("changeMode");
+ };
+
+ this.getMode = function() {
+ if (!this.$mode) {
+ this.$mode = new TextMode();
+ }
+ return this.$mode;
+ };
+
+ this.$scrollTop = 0;
+ this.setScrollTopRow = function(scrollTopRow) {
+ if (this.$scrollTop === scrollTopRow) return;
+
+ this.$scrollTop = scrollTopRow;
+ this._dispatchEvent("changeScrollTop");
+ };
+
+ this.getScrollTopRow = function() {
+ return this.$scrollTop;
+ };
+
+ this.getWidth = function() {
+ this.$computeWidth();
+ return this.width;
+ };
+
+ this.getScreenWidth = function() {
+ this.$computeWidth();
+ return this.screenWidth;
+ };
+
+ this.$computeWidth = function(force) {
+ if (this.$modified || force) {
+ this.$modified = false;
+
+ var lines = this.doc.getAllLines();
+ var longestLine = 0;
+ var longestScreenLine = 0;
+ var tabSize = this.getTabSize();
+
+ for ( var i = 0; i < lines.length; i++) {
+ var len = lines[i].length;
+ longestLine = Math.max(longestLine, len);
+
+ lines[i].replace(/\t/g, function(m) {
+ len += tabSize-1;
+ return m;
+ });
+ longestScreenLine = Math.max(longestScreenLine, len);
+ }
+ this.width = longestLine;
+
+ if (this.$useWrapMode) {
+ this.screenWidth = this.$wrapLimit;
+ } else {
+ this.screenWidth = longestScreenLine;
+ }
+ }
+ };
+
+ /**
+ * Get a verbatim copy of the given line as it is in the document
+ */
+ this.getLine = function(row) {
+ return this.doc.getLine(row);
+ };
+
+ /**
+ * Get a line as it is displayed on screen. Tabs are replaced by spaces.
+ */
+ this.getDisplayLine = function(row) {
+ var tab = new Array(this.getTabSize()+1).join(" ");
+ return this.doc.getLine(row).replace(/\t/g, tab);
+ };
+
+ this.getLines = function(firstRow, lastRow) {
+ return this.doc.getLines(firstRow, lastRow);
+ };
+
+ this.getLength = function() {
+ return this.doc.getLength();
+ };
+
+ this.getTextRange = function(range) {
+ return this.doc.getTextRange(range);
+ };
+
+ this.findMatchingBracket = function(position) {
+ if (position.column == 0) return null;
+
+ var charBeforeCursor = this.getLine(position.row).charAt(position.column-1);
+ if (charBeforeCursor == "") return null;
+
+ var match = charBeforeCursor.match(/([\(\[\{])|([\)\]\}])/);
+ if (!match) {
+ return null;
+ }
+
+ if (match[1]) {
+ return this.$findClosingBracket(match[1], position);
+ } else {
+ return this.$findOpeningBracket(match[2], position);
+ }
+ };
+
+ this.$brackets = {
+ ")": "(",
+ "(": ")",
+ "]": "[",
+ "[": "]",
+ "{": "}",
+ "}": "{"
+ };
+
+ this.$findOpeningBracket = function(bracket, position) {
+ var openBracket = this.$brackets[bracket];
+
+ var column = position.column - 2;
+ var row = position.row;
+ var depth = 1;
+
+ var line = this.getLine(row);
+
+ while (true) {
+ while(column >= 0) {
+ var ch = line.charAt(column);
+ if (ch == openBracket) {
+ depth -= 1;
+ if (depth == 0) {
+ return {row: row, column: column};
+ }
+ }
+ else if (ch == bracket) {
+ depth +=1;
+ }
+ column -= 1;
+ }
+ row -=1;
+ if (row < 0) break;
+
+ var line = this.getLine(row);
+ var column = line.length-1;
+ }
+ return null;
+ };
+
+ this.$findClosingBracket = function(bracket, position) {
+ var closingBracket = this.$brackets[bracket];
+
+ var column = position.column;
+ var row = position.row;
+ var depth = 1;
+
+ var line = this.getLine(row);
+ var lineCount = this.getLength();
+
+ while (true) {
+ while(column < line.length) {
+ var ch = line.charAt(column);
+ if (ch == closingBracket) {
+ depth -= 1;
+ if (depth == 0) {
+ return {row: row, column: column};
+ }
+ }
+ else if (ch == bracket) {
+ depth +=1;
+ }
+ column += 1;
+ }
+ row +=1;
+ if (row >= lineCount) break;
+
+ var line = this.getLine(row);
+ var column = 0;
+ }
+ return null;
+ };
+
+ this.insert = function(position, text) {
+ return this.doc.insert(position, text);
+ };
+
+ this.remove = function(range) {
+ return this.doc.remove(range);
+ };
+
+ this.undoChanges = function(deltas) {
+ if (!deltas.length)
+ return;
+
+ this.$fromUndo = true;
+ this.doc.revertDeltas(deltas);
+ this.$fromUndo = false;
+
+ // update the selection
+ var firstDelta = deltas[0];
+ var lastDelta = deltas[deltas.length-1];
+
+ this.selection.clearSelection();
+ if (firstDelta.action == "insertText" || firstDelta.action == "insertLines")
+ this.selection.moveCursorToPosition(firstDelta.range.start);
+ if (firstDelta.action == "removeText" || firstDelta.action == "removeLines")
+ this.selection.setSelectionRange(Range.fromPoints(lastDelta.range.start, firstDelta.range.end));
+ },
+
+ this.redoChanges = function(deltas) {
+ if (!deltas.length)
+ return;
+
+ this.$fromUndo = true;
+ this.doc.applyDeltas(deltas);
+ this.$fromUndo = false;
+
+ // update the selection
+ var firstDelta = deltas[0];
+ var lastDelta = deltas[deltas.length-1];
+
+ this.selection.clearSelection();
+ if (firstDelta.action == "insertText" || firstDelta.action == "insertLines")
+ this.selection.setSelectionRange(Range.fromPoints(firstDelta.range.start, lastDelta.range.end));
+ if (firstDelta.action == "removeText" || firstDelta.action == "removeLines")
+ this.selection.moveCursorToPosition(lastDelta.range.start);
+ },
+
+ this.replace = function(range, text) {
+ return this.doc.replace(range, text);
+ };
+
+ this.indentRows = function(startRow, endRow, indentString) {
+ indentString = indentString.replace(/\t/g, this.getTabString());
+ for (var row=startRow; row<=endRow; row++) {
+ this.insert({row: row, column:0}, indentString);
+ }
+ };
+
+ this.outdentRows = function (range) {
+ var rowRange = range.collapseRows();
+ var deleteRange = new Range(0, 0, 0, 0);
+ var size = this.getTabSize();
+
+ for (var i = rowRange.start.row; i <= rowRange.end.row; ++i) {
+ var line = this.getLine(i);
+
+ deleteRange.start.row = i;
+ deleteRange.end.row = i;
+ for (var j = 0; j < size; ++j)
+ if (line.charAt(j) != ' ')
+ break;
+ if (j < size && line.charAt(j) == '\t') {
+ deleteRange.start.column = j;
+ deleteRange.end.column = j + 1;
+ } else {
+ deleteRange.start.column = 0;
+ deleteRange.end.column = j;
+ }
+ this.remove(deleteRange);
+ }
+ };
+
+ this.moveLinesUp = function(firstRow, lastRow) {
+ if (firstRow <= 0) return 0;
+
+ var removed = this.doc.removeLines(firstRow, lastRow);
+ this.doc.insertLines(firstRow - 1, removed);
+ return -1;
+ };
+
+ this.moveLinesDown = function(firstRow, lastRow) {
+ if (lastRow >= this.doc.getLength()-1) return 0;
+
+ var removed = this.doc.removeLines(firstRow, lastRow);
+ this.doc.insertLines(firstRow+1, removed);
+ return 1;
+ };
+
+ this.duplicateLines = function(firstRow, lastRow) {
+ var firstRow = this.$clipRowToDocument(firstRow);
+ var lastRow = this.$clipRowToDocument(lastRow);
+
+ var lines = this.getLines(firstRow, lastRow);
+ this.doc.insertLines(firstRow, lines);
+
+ var addedRows = lastRow - firstRow + 1;
+ return addedRows;
+ };
+
+ this.$clipRowToDocument = function(row) {
+ return Math.max(0, Math.min(row, this.doc.getLength()-1));
+ };
+
+ // WRAPMODE
+ this.$wrapLimit = 80;
+ this.$useWrapMode = false;
+ this.$wrapLimitRange = {
+ min : null,
+ max : null
+ };
+
+ this.setUseWrapMode = function(useWrapMode) {
+ if (useWrapMode != this.$useWrapMode) {
+ this.$useWrapMode = useWrapMode;
+ this.$modified = true;
+
+ // If wrapMode is activaed, the wrapData array has to be initialized.
+ if (useWrapMode) {
+ var len = this.getLength();
+ this.$wrapData = [];
+ for (i = 0; i < len; i++) {
+ this.$wrapData.push([]);
+ }
+ this.$updateWrapData(0, len - 1);
+ }
+
+ this._dispatchEvent("changeWrapMode");
+ }
+ };
+
+ this.getUseWrapMode = function() {
+ return this.$useWrapMode;
+ };
+
+ // Allow the wrap limit to move freely between min and max. Either
+ // parameter can be null to allow the wrap limit to be unconstrained
+ // in that direction. Or set both parameters to the same number to pin
+ // the limit to that value.
+ this.setWrapLimitRange = function(min, max) {
+ if (this.$wrapLimitRange.min !== min || this.$wrapLimitRange.max !== max) {
+ this.$wrapLimitRange.min = min;
+ this.$wrapLimitRange.max = max;
+ this.$modified = true;
+ // This will force a recalculation of the wrap limit
+ this._dispatchEvent("changeWrapMode");
+ }
+ };
+
+ // This should generally only be called by the renderer when a resize
+ // is detected.
+ this.adjustWrapLimit = function(desiredLimit) {
+ var wrapLimit = this.$constrainWrapLimit(desiredLimit);
+ if (wrapLimit != this.$wrapLimit && wrapLimit > 0) {
+ this.$wrapLimit = wrapLimit;
+ this.$modified = true;
+ if (this.$useWrapMode) {
+ this.$updateWrapData(0, this.getLength() - 1);
+ this._dispatchEvent("changeWrapLimit");
+ }
+ return true;
+ }
+ return false;
+ };
+
+ this.$constrainWrapLimit = function(wrapLimit) {
+ var min = this.$wrapLimitRange.min;
+ if (min)
+ wrapLimit = Math.max(min, wrapLimit);
+
+ var max = this.$wrapLimitRange.max;
+ if (max)
+ wrapLimit = Math.min(max, wrapLimit);
+
+ // What would a limit of 0 even mean?
+ return Math.max(1, wrapLimit);
+ };
+
+ this.getWrapLimit = function() {
+ return this.$wrapLimit;
+ };
+
+ this.getWrapLimitRange = function() {
+ // Avoid unexpected mutation by returning a copy
+ return {
+ min : this.$wrapLimitRange.min,
+ max : this.$wrapLimitRange.max
+ };
+ };
+
+ this.$updateWrapDataOnChange = function(e) {
+ if (!this.$useWrapMode) {
+ return;
+ }
+
+ var len;
+ var action = e.data.action;
+ var firstRow = e.data.range.start.row,
+ lastRow = e.data.range.end.row;
+
+ if (action.indexOf("Lines") != -1) {
+ if (action == "insertLines") {
+ lastRow = firstRow + (e.data.lines.length);
+ } else {
+ lastRow = firstRow;
+ }
+ len = e.data.lines.length;
+ } else {
+ len = lastRow - firstRow;
+ }
+
+ if (len != 0) {
+ if (action.indexOf("remove") != -1) {
+ this.$wrapData.splice(firstRow, len);
+ lastRow = firstRow;
+ } else {
+ var args = [firstRow, 0];
+ for (var i = 0; i < len; i++) args.push([]);
+ this.$wrapData.splice.apply(this.$wrapData, args);
+ }
+ }
+
+ if (this.$wrapData.length != this.doc.$lines.length) {
+ console.error("The length of doc.$lines and $wrapData have to be the same!");
+ }
+
+ this.$updateWrapData(firstRow, lastRow);
+ };
+
+ this.$updateWrapData = function(firstRow, lastRow) {
+ var lines = this.doc.getAllLines();
+ var tabSize = this.getTabSize();
+ var wrapData = this.$wrapData;
+ var wrapLimit = this.$wrapLimit;
+
+ for (var row = firstRow; row <= lastRow; row++) {
+ wrapData[row] =
+ this.$computeWrapSplits(lines[row], wrapLimit, tabSize);
+ }
+ };
+
+ // "Tokens"
+ var CHAR = 1,
+ CHAR_EXT = 2,
+ SPACE = 3,
+ TAB = 4,
+ TAB_SPACE = 5;
+
+ this.$computeWrapSplits = function(textLine, wrapLimit, tabSize) {
+ textLine = textLine.trimRight();
+ if (textLine.length == 0) {
+ return [];
+ }
+
+ var tabSize = this.getTabSize();
+ var splits = [];
+ var tokens = this.$getDisplayTokens(textLine);
+ var displayLength = tokens.length;
+ var lastSplit = 0, lastDocSplit = 0;
+
+ function addSplit(screenPos) {
+ var displayed = tokens.slice(lastSplit, screenPos);
+
+ // The document size is the current size - the extra width for tabs
+ // and multipleWidth characters.
+ var len = displayed.length;
+ displayed.join("").
+ // Get all the tabs.
+ replace(/4/g, function(m) {
+ len -= tabSize - 1;
+ }).
+ // Get all the multipleWidth characters.
+ replace(/2/g, function(m) {
+ len -= 1;
+ });
+
+ lastDocSplit += len;
+ splits.push(lastDocSplit);
+ lastSplit = screenPos;
+ }
+
+ while (displayLength - lastSplit > wrapLimit) {
+ // This is, where the split should be.
+ var split = lastSplit + wrapLimit;
+
+ // If there is a space or tab at this split position.
+ if (tokens[split] >= SPACE) {
+ // Include all following spaces + tabs in this split as well.
+ while (tokens[split] >= SPACE) {
+ split ++;
+ }
+ addSplit(split);
+ } else {
+ // Search for the first non space/tab token.
+ for (split; split != lastSplit - 1; split--) {
+ if (tokens[split] >= SPACE) {
+ split++;
+ break;
+ }
+ }
+ // If we found one, then add the split.
+ if (split > lastSplit) {
+ addSplit(split);
+ }
+ // No space or tab around? Well, force a split then.
+ else {
+ addSplit(lastSplit + wrapLimit);
+ }
+ }
+ }
+ return splits;
+ }
+
+ this.$getDisplayTokens = function(str) {
+ var arr = [];
+ var tabSize = this.getTabSize();
+
+ for (var i = 0; i < str.length; i++) {
+ var c = str.charCodeAt(i);
+ // Tab
+ if (c == 9) {
+ arr.push(TAB);
+ for (var n = 1; n < tabSize; n++) {
+ arr.push(TAB_SPACE);
+ }
+ }
+ // Space
+ else if(c == 32) {
+ arr.push(SPACE);
+ }
+ // CJK characters
+ else if (
+ c >= 0x3040 && c <= 0x309F || // Hiragana
+ c >= 0x30A0 && c <= 0x30FF || // Katakana
+ c >= 0x4E00 && c <= 0x9FFF || // Single CJK ideographs
+ c >= 0xF900 && c <= 0xFAFF ||
+ c >= 0x3400 && c <= 0x4DBF
+ ) {
+ arr.push(CHAR, CHAR_EXT);
+ } else {
+ arr.push(CHAR);
+ }
+ }
+ return arr;
+ }
+
+ /**
+ * Calculates the width of the a string on the screen while assuming that
+ * the string starts at the first column on the screen.
+ *
+ * @param string str String to calculate the screen width of
+ * @return int number of columns for str on screen.
+ */
+ this.$getStringScreenWidth = function(str) {
+ var screenColumn = 0;
+ var tabSize = this.getTabSize();
+
+ for (var i=0; i= 0x3040 && c <= 0x309F || // Hiragana
+ c >= 0x30A0 && c <= 0x30FF || // Katakana
+ c >= 0x4E00 && c <= 0x9FFF || // Single CJK ideographs
+ c >= 0xF900 && c <= 0xFAFF ||
+ c >= 0x3400 && c <= 0x4DBF
+ ) {
+ screenColumn += 2;
+ } else {
+ screenColumn += 1;
+ }
+ }
+
+ return screenColumn;
+ }
+
+ this.getRowHeight = function(config, row) {
+ var rows;
+ if (!this.$useWrapMode || !this.$wrapData[row]) {
+ rows = 1;
+ } else {
+ rows = this.$wrapData[row].length + 1;
+ }
+
+ return rows * config.lineHeight;
+ }
+
+ this.getScreenLastRowColumn = function(screenRow, returnDocPosition) {
+ if (!this.$useWrapMode) {
+ return this.$getStringScreenWidth(this.getLine(screenRow));
+ }
+
+ var rowData = this.$screenToDocumentRow(screenRow);
+ var docRow = rowData[0],
+ row = rowData[1];
+
+ var start, end;
+ if (this.$wrapData[docRow][row]) {
+ start = (this.$wrapData[docRow][row - 1] || 0);
+ end = this.$wrapData[docRow][row];
+ returnDocPosition && end--;
+ } else {
+ end = this.getLine(docRow).length;
+ start = (this.$wrapData[docRow][row - 1] || 0);
+ }
+ if (!returnDocPosition) {
+ return this.$getStringScreenWidth(this.getLine(docRow).substring(start, end));
+ } else {
+ return end;
+ }
+ };
+
+ this.getDocumentLastRowColumn = function(docRow, docColumn) {
+ if (!this.$useWrapMode) {
+ return this.getLine(docRow).length;
+ }
+
+ var screenRow = this.documentToScreenRow(docRow, docColumn);
+ return this.getScreenLastRowColumn(screenRow, true);
+ }
+
+ this.getScreenFirstRowColumn = function(screenRow) {
+ if (!this.$useWrapMode) {
+ return 0;
+ }
+
+ var rowData = this.$screenToDocumentRow(screenRow);
+ var docRow = rowData[0],
+ row = rowData[1];
+
+ return this.$wrapData[docRow][row - 1] || 0;
+ };
+
+ this.getRowSplitData = function(row) {
+ if (!this.$useWrapMode) {
+ return undefined;
+ } else {
+ return this.$wrapData[row];
+ }
+ };
+
+ /**
+ *
+ * @returns array
+ * - array[0]: The documentRow equivalent.
+ * - array[1]: The screenRowOffset to the first documentRow on the screen.
+ */
+ this.$screenToDocumentRow = function(row) {
+ if (!this.$useWrapMode) {
+ return [row, 0];
+ }
+
+ var wrapData = this.$wrapData, linesCount = this.getLength();
+ var docRow = 0;
+ while (docRow < linesCount && row >= wrapData[docRow].length + 1) {
+ row -= wrapData[docRow].length + 1;
+ docRow ++;
+ }
+
+ return [docRow, row];
+ };
+
+ this.screenToDocumentRow = function(screenRow) {
+ return this.$screenToDocumentRow(screenRow)[0];
+ };
+
+ this.screenToDocumentColumn = function(screenRow, screenColumn) {
+ return this.screenToDocumentPosition(screenRow, screenColumn).column;
+ };
+
+ this.screenToDocumentPosition = function(row, column) {
+ var line;
+ var docRow;
+ var docColumn;
+ var remaining = column;
+ var linesCount = this.getLength();
+ if (!this.$useWrapMode) {
+ docRow = row >= linesCount? linesCount-1 : (row < 0 ? 0 : row);
+ row = 0;
+ docColumn = 0;
+ line = this.getLine(docRow);
+ } else {
+ var wrapData = this.$wrapData;
+
+ var docRow = 0;
+ while (docRow < linesCount && row >= wrapData[docRow].length + 1) {
+ row -= wrapData[docRow].length + 1;
+ docRow ++;
+ }
+
+ if (docRow >= linesCount) {
+ docRow = linesCount-1
+ row = wrapData[docRow].length;
+ }
+ docColumn = wrapData[docRow][row - 1] || 0;
+ line = this.getLine(docRow).substring(docColumn);
+ }
+
+ var tabSize = this.getTabSize();
+ for(var i = 0; i < line.length; i++) {
+ var c = line.charCodeAt(i);
+
+ if (remaining > 0) {
+ docColumn += 1;
+ // tab
+ if (c == 9) {
+ if (remaining >= tabSize) {
+ remaining -= tabSize;
+ } else {
+ remaining = 0;
+ docColumn -= 1;
+ }
+ }
+ // CJK characters
+ else if (
+ c >= 0x3040 && c <= 0x309F || // Hiragana
+ c >= 0x30A0 && c <= 0x30FF || // Katakana
+ c >= 0x4E00 && c <= 0x9FFF || // Single CJK ideographs
+ c >= 0xF900 && c <= 0xFAFF ||
+ c >= 0x3400 && c <= 0x4DBF
+ ) {
+ if (remaining >= 2) {
+ remaining -= 2;
+ } else {
+ remaining = 0;
+ docColumn -= 1;
+ }
+ } else {
+ remaining -= 1;
+ }
+ } else {
+ break;
+ }
+ }
+
+ // Clamp docColumn.
+ if (this.$useWrapMode) {
+ column = wrapData[docRow][row]
+ if (docColumn >= column) {
+ // We remove one character at the end such that the docColumn
+ // position returned is not associated to the next row on the
+ // screen.
+ docColumn = column - 1;
+ }
+ } else if (line) {
+ docColumn = Math.min(docColumn, line.length);
+ }
+
+ return {
+ row: docRow,
+ column: docColumn
+ };
+ };
+
+ this.documentToScreenColumn = function(row, docColumn) {
+ return this.documentToScreenPosition(row, docColumn).column;
+ };
+
+ /**
+ *
+ * @return array[2]
+ * - array[0]: The number of the row on the screen (aka screenRow)
+ * - array[1]: The number of rows from the first docRow on the screen
+ * (aka screenRowOffset);
+ */
+ this.$documentToScreenRow = function(docRow, docColumn) {
+ if (!this.$useWrapMode) {
+ return [docRow, 0];
+ }
+
+ var wrapData = this.$wrapData;
+ var screenRow = 0;
+
+ // Handle special case where the row is outside of the range of lines.
+ if (docRow > wrapData.length - 1) {
+ return [
+ this.getScreenLength(),
+ wrapData.length == 0 ? 0 : (wrapData[wrapData.length - 1].length - 1)
+ ];
+ }
+
+ for (var i = 0; i < docRow; i++) {
+ screenRow += wrapData[i].length + 1;
+ }
+
+ var screenRowOffset = 0;
+ while (docColumn >= wrapData[docRow][screenRowOffset]) {
+ screenRow ++;
+ screenRowOffset++;
+ }
+
+ return [screenRow, screenRowOffset];
+ }
+
+ this.documentToScreenRow = function(docRow, docColumn) {
+ return this.$documentToScreenRow(docRow, docColumn)[0];
+ }
+
+ this.documentToScreenPosition = function(pos, column) {
+ var str;
+ var tabSize = this.getTabSize();
+
+ // Normalize the passed in arguments.
+ var row;
+ if (column != null) {
+ row = pos;
+ } else {
+ row = pos.row;
+ column = pos.column;
+ }
+
+ if (!this.$useWrapMode) {
+ str = this.getLine(row).substring(0, column);
+ column = this.$getStringScreenWidth(str);
+ return {
+ row: row,
+ column: column
+ };
+ }
+
+ var rowData = this.$documentToScreenRow(row, column);
+ var screenRow = rowData[0];
+
+ if (row >= this.getLength()) {
+ return {
+ row: screenRow,
+ column: 0
+ };
+ }
+
+ var split;
+ var wrapRowData = this.$wrapData[row];
+ var screenColumn;
+ var screenRowOffset = rowData[1];
+
+ str = this.getLine(row).substring(
+ wrapRowData[screenRowOffset - 1] || 0, column);
+ screenColumn = this.$getStringScreenWidth(str);
+
+ return {
+ row: screenRow,
+ column: screenColumn
+ };
+ };
+
+ this.getScreenLength = function() {
+ if (!this.$useWrapMode) {
+ return this.getLength();
+ }
+
+ var screenRows = 0;
+ for (var row = 0; row < this.$wrapData.length; row++) {
+ screenRows += this.$wrapData[row].length + 1;
+ }
+ return screenRows;
+ }
+
+}).call(EditSession.prototype);
+
+exports.EditSession = EditSession;
+});/* ***** 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
+ * Julian Viereck
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/selection', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+var lang = require("pilot/lang");
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+var Range = require("ace/range").Range;
+var Anchor = require("ace/anchor").Anchor;
+
+var Selection = function(session) {
+ this.session = session;
+ this.doc = session.getDocument();
+
+ this.clearSelection();
+ this.selectionLead = new Anchor(this.doc, 0, 0);
+ this.selectionAnchor = new Anchor(this.doc, 0, 0);
+
+ var _self = this;
+ this.selectionLead.on("change", function(e) {
+ _self._dispatchEvent("changeCursor");
+ if (!_self.$isEmpty)
+ _self._dispatchEvent("changeSelection");
+ if (e.old.row == e.value.row)
+ _self.$updateDesiredColumn();
+ });
+
+ this.selectionAnchor.on("change", function() {
+ if (!_self.$isEmpty)
+ _self._dispatchEvent("changeSelection");
+ });
+};
+
+(function() {
+
+ oop.implement(this, EventEmitter);
+
+ this.isEmpty = function() {
+ return (this.$isEmpty || (
+ this.selectionAnchor.row == this.selectionLead.row &&
+ this.selectionAnchor.column == this.selectionLead.column
+ ));
+ };
+
+ this.isMultiLine = function() {
+ if (this.isEmpty()) {
+ return false;
+ }
+
+ return this.getRange().isMultiLine();
+ };
+
+ this.getCursor = function() {
+ return this.selectionLead.getPosition();
+ };
+
+ this.setSelectionAnchor = function(row, column) {
+ this.selectionAnchor.setPosition(row, column);
+
+ if (this.$isEmpty) {
+ this.$isEmpty = false;
+ this._dispatchEvent("changeSelection");
+ }
+ };
+
+ this.getSelectionAnchor = function() {
+ if (this.$isEmpty)
+ return this.getSelectionLead()
+ else
+ return this.selectionAnchor.getPosition();
+ };
+
+ this.getSelectionLead = function() {
+ return this.selectionLead.getPosition();
+ };
+
+ this.shiftSelection = function(columns) {
+ if (this.$isEmpty) {
+ this.moveCursorTo(this.selectionLead.row, this.selectionLead.column + columns);
+ return;
+ };
+
+ var anchor = this.getSelectionAnchor();
+ var lead = this.getSelectionLead();
+
+ var isBackwards = this.isBackwards();
+
+ if (!isBackwards || anchor.column !== 0)
+ this.setSelectionAnchor(anchor.row, anchor.column + columns);
+
+ if (isBackwards || lead.column !== 0) {
+ this.$moveSelection(function() {
+ this.moveCursorTo(lead.row, lead.column + columns);
+ });
+ }
+ };
+
+ this.isBackwards = function() {
+ var anchor = this.selectionAnchor;
+ var lead = this.selectionLead;
+ return (anchor.row > lead.row || (anchor.row == lead.row && anchor.column > lead.column));
+ };
+
+ this.getRange = function() {
+ var anchor = this.selectionAnchor;
+ var lead = this.selectionLead;
+
+ if (this.isEmpty())
+ return Range.fromPoints(lead, lead);
+
+ if (this.isBackwards()) {
+ return Range.fromPoints(lead, anchor);
+ }
+ else {
+ return Range.fromPoints(anchor, lead);
+ }
+ };
+
+ this.clearSelection = function() {
+ if (!this.$isEmpty) {
+ this.$isEmpty = true;
+ this._dispatchEvent("changeSelection");
+ }
+ };
+
+ this.selectAll = function() {
+ var lastRow = this.doc.getLength() - 1;
+ this.setSelectionAnchor(lastRow, this.doc.getLine(lastRow).length);
+ this.moveCursorTo(0, 0);
+ };
+
+ this.setSelectionRange = function(range, reverse) {
+ if (reverse) {
+ this.setSelectionAnchor(range.end.row, range.end.column);
+ this.selectTo(range.start.row, range.start.column);
+ } else {
+ this.setSelectionAnchor(range.start.row, range.start.column);
+ this.selectTo(range.end.row, range.end.column);
+ }
+ this.$updateDesiredColumn();
+ };
+
+ this.$updateDesiredColumn = function() {
+ var cursor = this.getCursor();
+ this.$desiredColumn = this.session.documentToScreenColumn(cursor.row, cursor.column);
+ };
+
+ this.$moveSelection = function(mover) {
+ var lead = this.selectionLead;
+ if (this.$isEmpty)
+ this.setSelectionAnchor(lead.row, lead.column);
+
+ mover.call(this);
+ };
+
+ this.selectTo = function(row, column) {
+ this.$moveSelection(function() {
+ this.moveCursorTo(row, column);
+ });
+ };
+
+ this.selectToPosition = function(pos) {
+ this.$moveSelection(function() {
+ this.moveCursorToPosition(pos);
+ });
+ };
+
+ this.selectUp = function() {
+ this.$moveSelection(this.moveCursorUp);
+ };
+
+ this.selectDown = function() {
+ this.$moveSelection(this.moveCursorDown);
+ };
+
+ this.selectRight = function() {
+ this.$moveSelection(this.moveCursorRight);
+ };
+
+ this.selectLeft = function() {
+ this.$moveSelection(this.moveCursorLeft);
+ };
+
+ this.selectLineStart = function() {
+ this.$moveSelection(this.moveCursorLineStart);
+ };
+
+ this.selectLineEnd = function() {
+ this.$moveSelection(this.moveCursorLineEnd);
+ };
+
+ this.selectFileEnd = function() {
+ this.$moveSelection(this.moveCursorFileEnd);
+ };
+
+ this.selectFileStart = function() {
+ this.$moveSelection(this.moveCursorFileStart);
+ };
+
+ this.selectWordRight = function() {
+ this.$moveSelection(this.moveCursorWordRight);
+ };
+
+ this.selectWordLeft = function() {
+ this.$moveSelection(this.moveCursorWordLeft);
+ };
+
+ this.selectWord = function() {
+ var cursor = this.getCursor();
+ var range = this.session.getWordRange(cursor.row, cursor.column);
+ this.setSelectionRange(range);
+ };
+
+ this.selectLine = function() {
+ this.setSelectionAnchor(this.selectionLead.row, 0);
+ this.$moveSelection(function() {
+ this.moveCursorTo(this.selectionLead.row + 1, 0);
+ });
+ };
+
+ this.moveCursorUp = function() {
+ this.moveCursorBy(-1, 0);
+ };
+
+ this.moveCursorDown = function() {
+ this.moveCursorBy(1, 0);
+ };
+
+ this.moveCursorLeft = function() {
+ var cursor = this.selectionLead.getPosition();
+ if (cursor.column == 0) {
+ // cursor is a line (start
+ if (cursor.row > 0) {
+ this.moveCursorTo(cursor.row - 1, this.doc.getLine(cursor.row - 1).length);
+ }
+ }
+ else {
+ var tabSize = this.session.getTabSize();
+ if (this.session.isTabStop(cursor) && this.doc.getLine(cursor.row).slice(cursor.column-tabSize, cursor.column).split(" ").length-1 == tabSize)
+ this.moveCursorBy(0, -tabSize);
+ else
+ this.moveCursorBy(0, -1);
+ }
+ };
+
+ this.moveCursorRight = function() {
+ if (this.selectionLead.column == this.doc.getLine(this.selectionLead.row).length) {
+ if (this.selectionLead.row < this.doc.getLength() - 1) {
+ this.moveCursorTo(this.selectionLead.row + 1, 0);
+ }
+ }
+ else {
+ var tabSize = this.session.getTabSize();
+ var cursor = this.selectionLead;
+ if (this.session.isTabStop(cursor) && this.doc.getLine(cursor.row).slice(cursor.column, cursor.column+tabSize).split(" ").length-1 == tabSize)
+ this.moveCursorBy(0, tabSize);
+ else
+ this.moveCursorBy(0, 1);
+ }
+ };
+
+ this.moveCursorLineStart = function() {
+ var row = this.selectionLead.row;
+ var column = this.selectionLead.column;
+ var screenRow = this.session.documentToScreenRow(row, column);
+ var firstRowColumn = this.session.getScreenFirstRowColumn(screenRow);
+ var beforeCursor = this.doc.getLine(row).slice(firstRowColumn, column);
+ var leadingSpace = beforeCursor.match(/^\s*/);
+ if (leadingSpace[0].length == 0) {
+ var lastRowColumn = this.session.getDocumentLastRowColumn(row, column);
+ leadingSpace = this.doc.getLine(row).
+ substring(firstRowColumn, lastRowColumn).
+ match(/^\s*/);
+ this.moveCursorTo(row, firstRowColumn + leadingSpace[0].length);
+ } else if (leadingSpace[0].length >= column) {
+ this.moveCursorTo(row, firstRowColumn);
+ } else {
+ this.moveCursorTo(row, firstRowColumn + leadingSpace[0].length);
+ }
+ };
+
+ this.moveCursorLineEnd = function() {
+ var lead = this.selectionLead;
+ this.moveCursorTo(lead.row, this.session.getDocumentLastRowColumn(lead.row, lead.column));
+ };
+
+ this.moveCursorFileEnd = function() {
+ var row = this.doc.getLength() - 1;
+ var column = this.doc.getLine(row).length;
+ this.moveCursorTo(row, column);
+ };
+
+ this.moveCursorFileStart = function() {
+ this.moveCursorTo(0, 0);
+ };
+
+ this.moveCursorWordRight = function() {
+ var row = this.selectionLead.row;
+ var column = this.selectionLead.column;
+ var line = this.doc.getLine(row);
+ var rightOfCursor = line.substring(column);
+
+ var match;
+ this.session.nonTokenRe.lastIndex = 0;
+ this.session.tokenRe.lastIndex = 0;
+
+ if (column == line.length) {
+ this.moveCursorRight();
+ return;
+ }
+ else if (match = this.session.nonTokenRe.exec(rightOfCursor)) {
+ column += this.session.nonTokenRe.lastIndex;
+ this.session.nonTokenRe.lastIndex = 0;
+ }
+ else if (match = this.session.tokenRe.exec(rightOfCursor)) {
+ column += this.session.tokenRe.lastIndex;
+ this.session.tokenRe.lastIndex = 0;
+ }
+
+ this.moveCursorTo(row, column);
+ };
+
+ this.moveCursorWordLeft = function() {
+ var row = this.selectionLead.row;
+ var column = this.selectionLead.column;
+ var line = this.doc.getLine(row);
+ var leftOfCursor = lang.stringReverse(line.substring(0, column));
+
+ var match;
+ this.session.nonTokenRe.lastIndex = 0;
+ this.session.tokenRe.lastIndex = 0;
+
+ if (column == 0) {
+ this.moveCursorLeft();
+ return;
+ }
+ else if (match = this.session.nonTokenRe.exec(leftOfCursor)) {
+ column -= this.session.nonTokenRe.lastIndex;
+ this.session.nonTokenRe.lastIndex = 0;
+ }
+ else if (match = this.session.tokenRe.exec(leftOfCursor)) {
+ column -= this.session.tokenRe.lastIndex;
+ this.session.tokenRe.lastIndex = 0;
+ }
+
+ this.moveCursorTo(row, column);
+ };
+
+ this.moveCursorBy = function(rows, chars) {
+ if (this.session.getUseWrapMode()) {
+ var screenPos = this.session.documentToScreenPosition(
+ this.selectionLead.row,
+ this.selectionLead.column
+ );
+ var screenCol = (chars == 0 && this.$desiredColumn) || screenPos.column;
+ var docPos = this.session.screenToDocumentPosition(screenPos.row + rows, screenCol);
+
+ this.moveCursorTo(docPos.row, docPos.column + chars, chars == 0);
+ } else {
+ var docColumn = (chars == 0 && this.$desiredColumn) || this.selectionLead.column;
+ this.moveCursorTo(this.selectionLead.row + rows, docColumn + chars, chars == 0);
+ }
+ };
+
+ this.moveCursorToPosition = function(position) {
+ this.moveCursorTo(position.row, position.column);
+ };
+
+ this.moveCursorTo = function(row, column, preventUpdateDesiredColumn) {
+ this.selectionLead.setPosition(row, column);
+ if (!preventUpdateDesiredColumn)
+ this.$updateDesiredColumn(this.selectionLead.column);
+ };
+
+ this.moveCursorToScreen = function(row, column, preventUpdateDesiredColumn) {
+ if (this.session.getUseWrapMode()) {
+ var pos = this.session.screenToDocumentPosition(row, column);
+ row = pos.row;
+ column = pos.column;
+ }
+ this.moveCursorTo(row, column, preventUpdateDesiredColumn);
+ };
+
+}).call(Selection.prototype);
+
+exports.Selection = Selection;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/range', function(require, exports, module) {
+
+var Range = function(startRow, startColumn, endRow, endColumn) {
+ this.start = {
+ row: startRow,
+ column: startColumn
+ };
+
+ this.end = {
+ row: endRow,
+ column: endColumn
+ };
+};
+
+(function() {
+
+ this.toString = function() {
+ return ("Range: [" + this.start.row + "/" + this.start.column +
+ "] -> [" + this.end.row + "/" + this.end.column + "]");
+ };
+
+ this.contains = function(row, column) {
+ return this.compare(row, column) == 0;
+ };
+
+ this.compare = function(row, column) {
+ if (!this.isMultiLine()) {
+ if (row === this.start.row) {
+ return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);
+ };
+ }
+
+ if (row < this.start.row)
+ return -1;
+
+ if (row > this.end.row)
+ return 1;
+
+ if (this.start.row === row)
+ return column >= this.start.column ? 0 : -1;
+
+ if (this.end.row === row)
+ return column <= this.end.column ? 0 : 1;
+
+ return 0;
+ };
+
+ this.clipRows = function(firstRow, lastRow) {
+ if (this.end.row > lastRow) {
+ var end = {
+ row: lastRow+1,
+ column: 0
+ };
+ }
+
+ if (this.start.row > lastRow) {
+ var start = {
+ row: lastRow+1,
+ column: 0
+ };
+ }
+
+ if (this.start.row < firstRow) {
+ var start = {
+ row: firstRow,
+ column: 0
+ };
+ }
+
+ if (this.end.row < firstRow) {
+ var end = {
+ row: firstRow,
+ column: 0
+ };
+ }
+ return Range.fromPoints(start || this.start, end || this.end);
+ };
+
+ this.extend = function(row, column) {
+ var cmp = this.compare(row, column);
+
+ if (cmp == 0)
+ return this;
+ else if (cmp == -1)
+ var start = {row: row, column: column};
+ else
+ var end = {row: row, column: column};
+
+ return Range.fromPoints(start || this.start, end || this.end);
+ };
+
+ this.isEmpty = function() {
+ return (this.start.row == this.end.row && this.start.column == this.end.column);
+ };
+
+ this.isMultiLine = function() {
+ return (this.start.row !== this.end.row);
+ };
+
+ this.clone = function() {
+ return Range.fromPoints(this.start, this.end);
+ };
+
+ this.collapseRows = function() {
+ if (this.end.column == 0)
+ return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0)
+ else
+ return new Range(this.start.row, 0, this.end.row, 0)
+ };
+
+ this.toScreenRange = function(session) {
+ var screenPosStart =
+ session.documentToScreenPosition(this.start);
+ var screenPosEnd =
+ session.documentToScreenPosition(this.end);
+ return new Range(
+ screenPosStart.row, screenPosStart.column,
+ screenPosEnd.row, screenPosEnd.column
+ );
+ };
+
+}).call(Range.prototype);
+
+
+Range.fromPoints = function(start, end) {
+ return new Range(start.row, start.column, end.row, end.column);
+};
+
+exports.Range = Range;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/anchor', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+
+/**
+ * An Anchor is a floating pointer in the document. Whenever text is inserted or
+ * deleted before the cursor, the position of the cursor is updated
+ */
+var Anchor = exports.Anchor = function(doc, row, column) {
+ this.document = doc;
+
+ if (typeof column == "undefined")
+ this.setPosition(row.row, row.column)
+ else
+ this.setPosition(row, column);
+
+ this.$onChange = this.onChange.bind(this);
+ doc.on("change", this.$onChange);
+};
+
+(function() {
+
+ oop.implement(this, EventEmitter);
+
+ this.getPosition = function() {
+ return this.$clipPositionToDocument(this.row, this.column);
+ };
+
+ this.getDocument = function() {
+ return this.document;
+ };
+
+ this.onChange = function(e) {
+ var delta = e.data;
+ var range = delta.range;
+
+ if (range.start.row == range.end.row && range.start.row != this.row)
+ return;
+
+ if (range.start.row > this.row)
+ return;
+
+ if (range.start.row == this.row && range.start.column > this.column)
+ return;
+
+ var row = this.row;
+ var column = this.column;
+
+ if (delta.action === "insertText") {
+ if (range.start.row === row && range.start.column <= column) {
+ if (range.start.row === range.end.row) {
+ column += range.end.column - range.start.column;
+ }
+ else {
+ column -= range.start.column;
+ row += range.end.row - range.start.row;
+ }
+ }
+ else if (range.start.row !== range.end.row && range.start.row < row) {
+ row += range.end.row - range.start.row;
+ }
+ } else if (delta.action === "insertLines") {
+ if (range.start.row <= row) {
+ row += range.end.row - range.start.row;
+ }
+ }
+ else if (delta.action == "removeText") {
+ if (range.start.row == row && range.start.column < column) {
+ if (range.end.column >= column)
+ column = range.start.column;
+ else
+ column = Math.max(0, column - (range.end.column - range.start.column));
+
+ } else if (range.start.row !== range.end.row && range.start.row < row) {
+ if (range.end.row == row) {
+ column = Math.max(0, column - range.end.column) + range.start.column;
+ }
+ row -= (range.end.row - range.start.row);
+ }
+ else if (range.end.row == row) {
+ row -= range.end.row - range.start.row;
+ column = Math.max(0, column - range.end.column) + range.start.column;
+ }
+ } else if (delta.action == "removeLines") {
+ if (range.start.row <= row) {
+ if (range.end.row <= row)
+ row -= range.end.row - range.start.row;
+ else {
+ row = range.start.row;
+ column = 0;
+ }
+ }
+ }
+
+ this.setPosition(row, column);
+ };
+
+ this.setPosition = function(row, column) {
+ pos = this.$clipPositionToDocument(row, column);
+ if (this.row == pos.row && this.column == pos.column)
+ return;
+
+ var old = {
+ row: this.row,
+ column: this.column
+ };
+
+ this.row = pos.row;
+ this.column = pos.column;
+ this._dispatchEvent("change", {
+ old: old,
+ value: pos
+ });
+ };
+
+ this.detach = function() {
+ this.document.removeEventListener("change", this.$onChange);
+ };
+
+ this.$clipPositionToDocument = function(row, column) {
+ var pos = {};
+
+ if (row >= this.document.getLength()) {
+ pos.row = Math.max(0, this.document.getLength() - 1);
+ pos.column = this.document.getLine(pos.row).length;
+ }
+ else if (row < 0) {
+ pos.row = 0;
+ pos.column = 0;
+ }
+ else {
+ pos.row = row;
+ pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
+ }
+
+ if (column < 0)
+ pos.column = 0;
+
+ return pos;
+ };
+
+}).call(Anchor.prototype);
+
+});
+/* 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
+ * Mihai Sucan
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/mode/text', function(require, exports, module) {
+
+var Tokenizer = require("ace/tokenizer").Tokenizer;
+var TextHighlightRules = require("ace/mode/text_highlight_rules").TextHighlightRules;
+
+var Mode = function() {
+ this.$tokenizer = new Tokenizer(new TextHighlightRules().getRules());
+};
+
+(function() {
+
+ this.getTokenizer = function() {
+ return this.$tokenizer;
+ };
+
+ this.toggleCommentLines = function(state, doc, startRow, endRow) {
+ };
+
+ this.getNextLineIndent = function(state, line, tab) {
+ return "";
+ };
+
+ this.checkOutdent = function(state, line, input) {
+ return false;
+ };
+
+ this.autoOutdent = function(state, doc, row) {
+ };
+
+ this.$getIndent = function(line) {
+ var match = line.match(/^(\s+)/);
+ if (match) {
+ return match[1];
+ }
+
+ return "";
+ };
+
+ this.createWorker = function(session) {
+ return null;
+ };
+
+ this.highlightSelection = function(editor) {
+ var session = editor.session;
+ if (!session.$selectionOccurrences)
+ session.$selectionOccurrences = [];
+
+ if (session.$selectionOccurrences.length)
+ this.clearSelectionHighlight(editor);
+
+ var selection = editor.getSelectionRange();
+ if (selection.isEmpty() || selection.isMultiLine())
+ return;
+
+ var startOuter = selection.start.column - 1;
+ var endOuter = selection.end.column + 1;
+ var line = session.getLine(selection.start.row);
+ var lineCols = line.length - 1;
+ var needle = line.substring(Math.max(startOuter, 0),
+ Math.min(endOuter, lineCols));
+
+ // Make sure the outer characters are not part of the word.
+ if ((startOuter >= 0 && !/[^\w\d]/.test(needle.charAt(0))) ||
+ (endOuter <= lineCols && !/[^\w\d]/.test(needle.charAt(needle.length - 1))))
+ return;
+
+ needle = line.substring(selection.start.column, selection.end.column);
+ if (!/^[\w\d]+$/.test(needle))
+ return;
+
+ var newOptions = {
+ wrap: true,
+ wholeWord: true,
+ needle: needle
+ };
+
+ var currentOptions = editor.$search.getOptions();
+ editor.$search.set(newOptions);
+
+ var ranges = editor.$search.findAll(session);
+ session.$selectionOccurrences = [];
+ ranges.forEach(function(range) {
+ if (!range.contains(selection.start.row, selection.start.column)) {
+ var marker = session.addMarker(range, "ace_selected_word");
+ session.$selectionOccurrences.push(marker);
+ }
+ });
+
+ editor.$search.set(currentOptions);
+ };
+
+ this.clearSelectionHighlight = function(editor) {
+ if (!editor.session.$selectionOccurrences)
+ return;
+
+ editor.session.$selectionOccurrences.forEach(function(marker) {
+ editor.session.removeMarker(marker);
+ });
+ };
+
+}).call(Mode.prototype);
+
+exports.Mode = Mode;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/tokenizer', function(require, exports, module) {
+
+var Tokenizer = function(rules) {
+ this.rules = rules;
+
+ this.regExps = {};
+ for ( var key in this.rules) {
+ var state = this.rules[key];
+ var ruleRegExps = [];
+
+ for ( var i = 0; i < state.length; i++) {
+ ruleRegExps.push(state[i].regex);
+ };
+
+ this.regExps[key] = new RegExp("(?:(" + ruleRegExps.join(")|(") + ")|(.))", "g");
+ }
+};
+
+(function() {
+
+ this.getLineTokens = function(line, startState) {
+ var currentState = startState;
+ var state = this.rules[currentState];
+ var re = this.regExps[currentState];
+ re.lastIndex = 0;
+
+ var match, tokens = [];
+
+ var lastIndex = 0;
+
+ var token = {
+ type: null,
+ value: ""
+ };
+
+ while (match = re.exec(line)) {
+ var type = "text";
+ var value = match[0];
+
+ for ( var i = 0; i < state.length; i++) {
+ if (match[i + 1]) {
+ if (typeof state[i].token == "function") {
+ type = state[i].token(match[0]);
+ }
+ else {
+ type = state[i].token;
+ }
+
+ if (state[i].next && state[i].next !== currentState) {
+ currentState = state[i].next;
+ var state = this.rules[currentState];
+ var lastIndex = re.lastIndex;
+
+ var re = this.regExps[currentState];
+ re.lastIndex = lastIndex;
+ }
+ break;
+ }
+ };
+
+
+ if (token.type !== type) {
+ if (token.type) {
+ tokens.push(token);
+ }
+ token = {
+ type: type,
+ value: value
+ };
+ } else {
+ token.value += value;
+ }
+
+ if (lastIndex == line.length) {
+ break;
+ }
+
+ lastIndex = re.lastIndex;
+ };
+
+ if (token.type) {
+ tokens.push(token);
+ }
+
+ return {
+ tokens : tokens,
+ state : currentState
+ };
+ };
+
+}).call(Tokenizer.prototype);
+
+exports.Tokenizer = Tokenizer;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/mode/text_highlight_rules', function(require, exports, module) {
+
+var TextHighlightRules = function() {
+
+ // regexp must not have capturing parentheses
+ // regexps are ordered -> the first match is used
+
+ this.$rules = {
+ "start" : [ {
+ token : "empty_line",
+ regex : '^$'
+ }, {
+ token : "text",
+ regex : ".+"
+ } ]
+ };
+};
+
+(function() {
+
+ this.addRules = function(rules, prefix) {
+ for (var key in rules) {
+ var state = rules[key];
+ for (var i=0; i
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/document', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+var Range = require("ace/range").Range;
+
+var Document = function(text) {
+ this.$lines = [];
+
+ if (Array.isArray(text)) {
+ this.insertLines(0, text);
+ }
+ // There has to be one line at least in the document. If you pass an empty
+ // string to the insert function, nothing will happen. Workaround.
+ else if (text.length == 0) {
+ this.$lines = [""];
+ } else {
+ this.insert({row: 0, column:0}, text);
+ }
+};
+
+(function() {
+
+ oop.implement(this, EventEmitter);
+
+ this.setValue = function(text) {
+ var len = this.getLength();
+ this.remove(new Range(0, 0, len, this.getLine(len-1).length));
+ this.insert({row: 0, column:0}, text);
+ };
+
+ this.getValue = function() {
+ return this.getAllLines().join(this.getNewLineCharacter());
+ };
+
+ // check for IE split bug
+ if ("aaa".split(/a/).length == 0)
+ this.$split = function(text) {
+ return text.replace(/\r\n|\r/g, "\n").split("\n");
+ }
+ else
+ this.$split = function(text) {
+ return text.split(/\r\n|\r|\n/);
+ };
+
+
+ this.$detectNewLine = function(text) {
+ var match = text.match(/^.*?(\r?\n)/m);
+ if (match) {
+ this.$autoNewLine = match[1];
+ } else {
+ this.$autoNewLine = "\n";
+ }
+ };
+
+ this.getNewLineCharacter = function() {
+ switch (this.$newLineMode) {
+ case "windows":
+ return "\r\n";
+
+ case "unix":
+ return "\n";
+
+ case "auto":
+ return this.$autoNewLine;
+ }
+ },
+
+ this.$autoNewLine = "\n";
+ this.$newLineMode = "auto";
+ this.setNewLineMode = function(newLineMode) {
+ if (this.$newLineMode === newLineMode) return;
+
+ this.$newLineMode = newLineMode;
+ };
+
+ this.getNewLineMode = function() {
+ return this.$newLineMode;
+ };
+
+ this.isNewLine = function(text) {
+ return (text == "\r\n" || text == "\r" || text == "\n");
+ };
+
+ /**
+ * Get a verbatim copy of the given line as it is in the document
+ */
+ this.getLine = function(row) {
+ return this.getLines(row, row + 1)[0] || "";
+ };
+
+ this.getLines = function(firstRow, lastRow) {
+ return this.$lines.slice(firstRow, lastRow + 1);
+ };
+
+ /**
+ * Returns all lines in the document as string array. Warning: The caller
+ * should not modify this array!
+ */
+ this.getAllLines = function() {
+ return this.getLines(0, this.getLength());
+ };
+
+ this.getLength = function() {
+ return this.$lines.length;
+ };
+
+ this.getTextRange = function(range) {
+ if (range.start.row == range.end.row) {
+ return this.$lines[range.start.row].substring(range.start.column,
+ range.end.column);
+ }
+ else {
+ var lines = [];
+ lines.push(this.$lines[range.start.row].substring(range.start.column));
+ lines.push.apply(lines, this.getLines(range.start.row+1, range.end.row-1));
+ lines.push(this.$lines[range.end.row].substring(0, range.end.column));
+ return lines.join(this.getNewLineCharacter());
+ }
+ };
+
+ this.$clipPosition = function(position) {
+ var length = this.getLength();
+ if (position.row >= length) {
+ position.row = Math.max(0, length - 1);
+ position.column = this.getLine(length-1).length;
+ }
+ return position;
+ }
+
+ this.insert = function(position, text) {
+ if (text.length == 0)
+ return position;
+
+ position = this.$clipPosition(position);
+
+ if (this.getLength() <= 1)
+ this.$detectNewLine(text);
+
+ var newLines = this.$split(text);
+
+ if (this.isNewLine(text)) {
+ var end = this.insertNewLine(position);
+ }
+ else if (newLines.length == 1) {
+ var end = this.insertInLine(position, text);
+ }
+ else {
+ if (newLines[0].length > 0) {
+ var end = this.insertInLine(position, newLines[0]);
+ this.insertNewLine(end);
+ }
+ // If we are inserting at the end of the document, we don't need to
+ // use insertInLine (concorde depends on this optimization!)
+ if (position.row + 1 == this.getLength()) {
+ this.insertLines(position.row + 1,
+ newLines.slice(1, newLines.length));
+ var end = {
+ row: position.row + newLines.length - 1,
+ column: position.column + newLines[newLines.length - 1].length
+ };
+ } else {
+ if (newLines.length > 2)
+ this.insertLines(position.row + 1,
+ newLines.slice(1, newLines.length - 1));
+ var end = this.insertInLine({
+ row: position.row + newLines.length - 1,
+ column: 0
+ }, newLines[newLines.length - 1]);
+ }
+ }
+ return end;
+ };
+
+ this.insertLines = function(row, lines) {
+ if (lines.length == 0)
+ return {row: row, column: 0};
+
+ var args = [row, 0];
+ args.push.apply(args, lines);
+ this.$lines.splice.apply(this.$lines, args);
+
+ var range = new Range(row, 0, row + lines.length, 0);
+ var delta = {
+ action: "insertLines",
+ range: range,
+ lines: lines
+ };
+ this._dispatchEvent("change", { data: delta });
+ return range.end;
+ },
+
+ this.insertNewLine = function(position) {
+ position = this.$clipPosition(position);
+ var line = this.$lines[position.row] || "";
+ this.$lines[position.row] = line.substring(0, position.column);
+ this.$lines.splice(position.row + 1, 0, line.substring(position.column, line.length));
+
+ var end = {
+ row : position.row + 1,
+ column : 0
+ };
+
+ var delta = {
+ action: "insertText",
+ range: Range.fromPoints(position, end),
+ text: this.getNewLineCharacter()
+ };
+ this._dispatchEvent("change", { data: delta });
+
+ return end;
+ };
+
+ this.insertInLine = function(position, text) {
+ if (text.length == 0)
+ return position;
+
+ var line = this.$lines[position.row] || "";
+ this.$lines[position.row] = line.substring(0, position.column) + text
+ + line.substring(position.column);
+
+ var end = {
+ row : position.row,
+ column : position.column + text.length
+ };
+
+ var delta = {
+ action: "insertText",
+ range: Range.fromPoints(position, end),
+ text: text
+ };
+ this._dispatchEvent("change", { data: delta });
+
+ return end;
+ };
+
+ this.remove = function(range) {
+ // clip to document
+ range.start = this.$clipPosition(range.start);
+ range.end = this.$clipPosition(range.end);
+
+ if (range.isEmpty())
+ return range.start;
+
+ var firstRow = range.start.row;
+ var lastRow = range.end.row;
+
+ if (range.isMultiLine()) {
+ var firstFullRow = range.start.column == 0 ? firstRow : firstRow + 1;
+ var lastFullRow = lastRow - 1;
+
+ if (range.end.column > 0)
+ this.removeInLine(lastRow, 0, range.end.column);
+
+ if (lastFullRow >= firstFullRow)
+ this.removeLines(firstFullRow, lastFullRow);
+
+ if (firstFullRow != firstRow) {
+ this.removeInLine(firstRow, range.start.column, this.getLine(firstRow).length);
+ this.removeNewLine(range.start.row);
+ }
+ }
+ else {
+ this.removeInLine(firstRow, range.start.column, range.end.column);
+ }
+ return range.start;
+ };
+
+ this.removeInLine = function(row, startColumn, endColumn) {
+ if (startColumn == endColumn)
+ return;
+
+ var range = new Range(row, startColumn, row, endColumn);
+ var line = this.getLine(row);
+ var removed = line.substring(startColumn, endColumn);
+ var newLine = line.substring(0, startColumn) + line.substring(endColumn, line.length);
+ this.$lines.splice(row, 1, newLine);
+
+ var delta = {
+ action: "removeText",
+ range: range,
+ text: removed
+ };
+ this._dispatchEvent("change", { data: delta });
+ return range.start;
+ };
+
+ /**
+ * Removes a range of full lines
+ *
+ * @param firstRow {Integer} The first row to be removed
+ * @param lastRow {Integer} The last row to be removed
+ * @return {String[]} The removed lines
+ */
+ this.removeLines = function(firstRow, lastRow) {
+ var range = new Range(firstRow, 0, lastRow + 1, 0);
+ var removed = this.$lines.splice(firstRow, lastRow - firstRow + 1);
+
+ var delta = {
+ action: "removeLines",
+ range: range,
+ nl: this.getNewLineCharacter(),
+ lines: removed
+ };
+ this._dispatchEvent("change", { data: delta });
+ return removed;
+ };
+
+ this.removeNewLine = function(row) {
+ var firstLine = this.getLine(row);
+ var secondLine = this.getLine(row+1);
+
+ var range = new Range(row, firstLine.length, row+1, 0);
+ var line = firstLine + secondLine;
+
+ this.$lines.splice(row, 2, line);
+
+ var delta = {
+ action: "removeText",
+ range: range,
+ text: this.getNewLineCharacter()
+ };
+ this._dispatchEvent("change", { data: delta });
+ };
+
+ this.replace = function(range, text) {
+ if (text.length == 0 && range.isEmpty())
+ return range.start;
+
+ // Shortcut: If the text we want to insert is the same as it is already
+ // in the document, we don't have to replace anything.
+ if (text == this.getTextRange(range))
+ return range.end;
+
+ this.remove(range);
+ if (text) {
+ var end = this.insert(range.start, text);
+ }
+ else {
+ end = range.start;
+ }
+
+ return end;
+ };
+
+ this.applyDeltas = function(deltas) {
+ for (var i=0; i=0; i--) {
+ var delta = deltas[i];
+ var range = Range.fromPoints(delta.range.start, delta.range.end);
+
+ if (delta.action == "insertLines")
+ this.removeLines(range.start.row, range.end.row - 1)
+ else if (delta.action == "insertText")
+ this.remove(range)
+ else if (delta.action == "removeLines")
+ this.insertLines(range.start.row, delta.lines)
+ else if (delta.action == "removeText")
+ this.insert(range.start, delta.text)
+ }
+ };
+
+}).call(Document.prototype);
+
+exports.Document = Document;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/search', function(require, exports, module) {
+
+var lang = require("pilot/lang");
+var oop = require("pilot/oop");
+var Range = require("ace/range").Range;
+
+var Search = function() {
+ this.$options = {
+ needle: "",
+ backwards: false,
+ wrap: false,
+ caseSensitive: false,
+ wholeWord: false,
+ scope: Search.ALL,
+ regExp: false
+ };
+};
+
+Search.ALL = 1;
+Search.SELECTION = 2;
+
+(function() {
+
+ this.set = function(options) {
+ oop.mixin(this.$options, options);
+ return this;
+ };
+
+ this.getOptions = function() {
+ return lang.copyObject(this.$options);
+ };
+
+ this.find = function(session) {
+ if (!this.$options.needle)
+ return null;
+
+ if (this.$options.backwards) {
+ var iterator = this.$backwardMatchIterator(session);
+ } else {
+ iterator = this.$forwardMatchIterator(session);
+ }
+
+ var firstRange = null;
+ iterator.forEach(function(range) {
+ firstRange = range;
+ return true;
+ });
+
+ return firstRange;
+ };
+
+ this.findAll = function(session) {
+ if (!this.$options.needle)
+ return [];
+
+ if (this.$options.backwards) {
+ var iterator = this.$backwardMatchIterator(session);
+ } else {
+ iterator = this.$forwardMatchIterator(session);
+ }
+
+ var ranges = [];
+ iterator.forEach(function(range) {
+ ranges.push(range);
+ });
+
+ return ranges;
+ };
+
+ this.replace = function(input, replacement) {
+ var re = this.$assembleRegExp();
+ var match = re.exec(input);
+ if (match && match[0].length == input.length) {
+ if (this.$options.regExp) {
+ return input.replace(re, replacement);
+ } else {
+ return replacement;
+ }
+ } else {
+ return null;
+ }
+ };
+
+ this.$forwardMatchIterator = function(session) {
+ var re = this.$assembleRegExp();
+ var self = this;
+
+ return {
+ forEach: function(callback) {
+ self.$forwardLineIterator(session).forEach(function(line, startIndex, row) {
+ if (startIndex) {
+ line = line.substring(startIndex);
+ }
+
+ var matches = [];
+
+ line.replace(re, function(str) {
+ var offset = arguments[arguments.length-2];
+ matches.push({
+ str: str,
+ offset: startIndex + offset
+ });
+ return str;
+ });
+
+ for (var i=0; i= 0; i--) {
+ var match = matches[i];
+ var range = self.$rangeFromMatch(row, match.offset, match.str.length);
+ if (callback(range))
+ return true;
+ }
+ });
+ }
+ };
+ };
+
+ this.$rangeFromMatch = function(row, column, length) {
+ return new Range(row, column, row, column+length);
+ };
+
+ this.$assembleRegExp = function() {
+ if (this.$options.regExp) {
+ var needle = this.$options.needle;
+ } else {
+ needle = lang.escapeRegExp(this.$options.needle);
+ }
+
+ if (this.$options.wholeWord) {
+ needle = "\\b" + needle + "\\b";
+ }
+
+ var modifier = "g";
+ if (!this.$options.caseSensitive) {
+ modifier += "i";
+ }
+
+ var re = new RegExp(needle, modifier);
+ return re;
+ };
+
+ this.$forwardLineIterator = function(session) {
+ var searchSelection = this.$options.scope == Search.SELECTION;
+
+ var range = session.getSelection().getRange();
+ var start = session.getSelection().getCursor();
+
+ var firstRow = searchSelection ? range.start.row : 0;
+ var firstColumn = searchSelection ? range.start.column : 0;
+ var lastRow = searchSelection ? range.end.row : session.getLength() - 1;
+
+ var wrap = this.$options.wrap;
+
+ function getLine(row) {
+ var line = session.getLine(row);
+ if (searchSelection && row == range.end.row) {
+ line = line.substring(0, range.end.column);
+ }
+ return line;
+ }
+
+ return {
+ forEach: function(callback) {
+ var row = start.row;
+
+ var line = getLine(row);
+ var startIndex = start.column;
+
+ var stop = false;
+
+ while (!callback(line, startIndex, row)) {
+
+ if (stop) {
+ return;
+ }
+
+ row++;
+ startIndex = 0;
+
+ if (row > lastRow) {
+ if (wrap) {
+ row = firstRow;
+ startIndex = firstColumn;
+ } else {
+ return;
+ }
+ }
+
+ if (row == start.row)
+ stop = true;
+
+ line = getLine(row);
+ }
+ }
+ };
+ };
+
+ this.$backwardLineIterator = function(session) {
+ var searchSelection = this.$options.scope == Search.SELECTION;
+
+ var range = session.getSelection().getRange();
+ var start = searchSelection ? range.end : range.start;
+
+ var firstRow = searchSelection ? range.start.row : 0;
+ var firstColumn = searchSelection ? range.start.column : 0;
+ var lastRow = searchSelection ? range.end.row : session.getLength() - 1;
+
+ var wrap = this.$options.wrap;
+
+ return {
+ forEach : function(callback) {
+ var row = start.row;
+
+ var line = session.getLine(row).substring(0, start.column);
+ var startIndex = 0;
+ var stop = false;
+
+ while (!callback(line, startIndex, row)) {
+
+ if (stop)
+ return;
+
+ row--;
+ startIndex = 0;
+
+ if (row < firstRow) {
+ if (wrap) {
+ row = lastRow;
+ } else {
+ return;
+ }
+ }
+
+ if (row == start.row)
+ stop = true;
+
+ line = session.getLine(row);
+ if (searchSelection) {
+ if (row == firstRow)
+ startIndex = firstColumn;
+ else if (row == lastRow)
+ line = line.substring(0, range.end.column);
+ }
+ }
+ }
+ };
+ };
+
+}).call(Search.prototype);
+
+exports.Search = Search;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/background_tokenizer', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+
+var BackgroundTokenizer = function(tokenizer, editor) {
+ this.running = false;
+ this.lines = [];
+ this.currentLine = 0;
+ this.tokenizer = tokenizer;
+
+ var self = this;
+
+ this.$worker = function() {
+ if (!self.running) { return; }
+
+ var workerStart = new Date();
+ var startLine = self.currentLine;
+ var doc = self.doc;
+
+ var processedLines = 0;
+ var lastVisibleRow = editor.getLastVisibleRow();
+
+ var len = doc.getLength();
+ while (self.currentLine < len) {
+ self.lines[self.currentLine] = self.$tokenizeRows(self.currentLine, self.currentLine)[0];
+ self.currentLine++;
+
+ // only check every 5 lines
+ processedLines += 1;
+ if ((processedLines % 5 == 0) && (new Date() - workerStart) > 20) {
+ self.fireUpdateEvent(startLine, self.currentLine-1);
+
+ var timeout = self.currentLine < lastVisibleRow ? 20 : 100;
+ self.running = setTimeout(self.$worker, timeout);
+ return;
+ }
+ }
+
+ self.running = false;
+
+ self.fireUpdateEvent(startLine, len - 1);
+ };
+};
+
+(function(){
+
+ oop.implement(this, EventEmitter);
+
+ this.setTokenizer = function(tokenizer) {
+ this.tokenizer = tokenizer;
+ this.lines = [];
+
+ this.start(0);
+ };
+
+ this.setDocument = function(doc) {
+ this.doc = doc;
+ this.lines = [];
+
+ this.stop();
+ };
+
+ this.fireUpdateEvent = function(firstRow, lastRow) {
+ var data = {
+ first: firstRow,
+ last: lastRow
+ };
+ this._dispatchEvent("update", {data: data});
+ };
+
+ this.start = function(startRow) {
+ this.currentLine = Math.min(startRow || 0, this.currentLine,
+ this.doc.getLength());
+
+ // remove all cached items below this line
+ this.lines.splice(this.currentLine, this.lines.length);
+
+ this.stop();
+ // pretty long delay to prevent the tokenizer from interfering with the user
+ this.running = setTimeout(this.$worker, 700);
+ };
+
+ this.stop = function() {
+ if (this.running)
+ clearTimeout(this.running);
+ this.running = false;
+ };
+
+ this.getTokens = function(firstRow, lastRow) {
+ return this.$tokenizeRows(firstRow, lastRow);
+ };
+
+ this.getState = function(row) {
+ return this.$tokenizeRows(row, row)[0].state;
+ };
+
+ this.$tokenizeRows = function(firstRow, lastRow) {
+ if (!this.doc)
+ return [];
+
+ var rows = [];
+
+ // determine start state
+ var state = "start";
+ var doCache = false;
+ if (firstRow > 0 && this.lines[firstRow - 1]) {
+ state = this.lines[firstRow - 1].state;
+ doCache = true;
+ }
+
+ var lines = this.doc.getLines(firstRow, lastRow);
+ for (var row=firstRow; row<=lastRow; row++) {
+ if (!this.lines[row]) {
+ var tokens = this.tokenizer.getLineTokens(lines[row-firstRow] || "", state);
+ var state = tokens.state;
+ rows.push(tokens);
+
+ if (doCache) {
+ this.lines[row] = tokens;
+ }
+ }
+ else {
+ var tokens = this.lines[row];
+ state = tokens.state;
+ rows.push(tokens);
+ }
+ }
+ return rows;
+ };
+
+}).call(BackgroundTokenizer.prototype);
+
+exports.BackgroundTokenizer = BackgroundTokenizer;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/undomanager', function(require, exports, module) {
+
+var UndoManager = function() {
+ this.$undoStack = [];
+ this.$redoStack = [];
+};
+
+(function() {
+
+ this.execute = function(options) {
+ var deltas = options.args[0];
+ this.$doc = options.args[1];
+ this.$undoStack.push(deltas);
+ };
+
+ this.undo = function() {
+ var deltas = this.$undoStack.pop();
+ if (deltas) {
+ this.$doc.undoChanges(deltas);
+ this.$redoStack.push(deltas);
+ }
+ };
+
+ this.redo = function() {
+ var deltas = this.$redoStack.pop();
+ if (deltas) {
+ this.$doc.redoChanges(deltas);
+ this.$undoStack.push(deltas);
+ }
+ };
+
+}).call(UndoManager.prototype);
+
+exports.UndoManager = UndoManager;
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/theme/textmate', function(require, exports, module) {
+
+ var dom = require("pilot/dom");
+
+ var cssText = ".ace-tm .ace_editor {\
+ border: 2px solid rgb(159, 159, 159);\
+}\
+\
+.ace-tm .ace_editor.ace_focus {\
+ border: 2px solid #327fbd;\
+}\
+\
+.ace-tm .ace_gutter {\
+ width: 50px;\
+ background: #e8e8e8;\
+ color: #333;\
+ overflow : hidden;\
+}\
+\
+.ace-tm .ace_gutter-layer {\
+ width: 100%;\
+ text-align: right;\
+}\
+\
+.ace-tm .ace_gutter-layer .ace_gutter-cell {\
+ padding-right: 6px;\
+}\
+\
+.ace-tm .ace_print_margin {\
+ width: 1px;\
+ background: #e8e8e8;\
+}\
+\
+.ace-tm .ace_text-layer {\
+ cursor: text;\
+}\
+\
+.ace-tm .ace_cursor {\
+ border-left: 2px solid black;\
+}\
+\
+.ace-tm .ace_cursor.ace_overwrite {\
+ border-left: 0px;\
+ border-bottom: 1px solid black;\
+}\
+ \
+.ace-tm .ace_line .ace_invisible {\
+ color: rgb(191, 191, 191);\
+}\
+\
+.ace-tm .ace_line .ace_keyword {\
+ color: blue;\
+}\
+\
+.ace-tm .ace_line .ace_constant.ace_buildin {\
+ color: rgb(88, 72, 246);\
+}\
+\
+.ace-tm .ace_line .ace_constant.ace_language {\
+ color: rgb(88, 92, 246);\
+}\
+\
+.ace-tm .ace_line .ace_constant.ace_library {\
+ color: rgb(6, 150, 14);\
+}\
+\
+.ace-tm .ace_line .ace_invalid {\
+ background-color: rgb(153, 0, 0);\
+ color: white;\
+}\
+\
+.ace-tm .ace_line .ace_support.ace_function {\
+ color: rgb(60, 76, 114);\
+}\
+\
+.ace-tm .ace_line .ace_support.ace_constant {\
+ color: rgb(6, 150, 14);\
+}\
+\
+.ace-tm .ace_line .ace_support.ace_type,\
+.ace-tm .ace_line .ace_support.ace_class {\
+ color: rgb(109, 121, 222);\
+}\
+\
+.ace-tm .ace_line .ace_keyword.ace_operator {\
+ color: rgb(104, 118, 135);\
+}\
+\
+.ace-tm .ace_line .ace_string {\
+ color: rgb(3, 106, 7);\
+}\
+\
+.ace-tm .ace_line .ace_comment {\
+ color: rgb(76, 136, 107);\
+}\
+\
+.ace-tm .ace_line .ace_comment.ace_doc {\
+ color: rgb(0, 102, 255);\
+}\
+\
+.ace-tm .ace_line .ace_comment.ace_doc.ace_tag {\
+ color: rgb(128, 159, 191);\
+}\
+\
+.ace-tm .ace_line .ace_constant.ace_numeric {\
+ color: rgb(0, 0, 205);\
+}\
+\
+.ace-tm .ace_line .ace_variable {\
+ color: rgb(49, 132, 149);\
+}\
+\
+.ace-tm .ace_line .ace_xml_pe {\
+ color: rgb(104, 104, 91);\
+}\
+\
+.ace-tm .ace_marker-layer .ace_selection {\
+ background: rgb(181, 213, 255);\
+}\
+\
+.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: rgb(232, 242, 254);\
+}\
+\
+.ace-tm .ace_marker-layer .ace_selected_word {\
+ background: rgb(250, 250, 255);\
+ border: 1px solid rgb(200, 200, 250);\
+}\
+\
+.ace-tm .ace_string.ace_regex {\
+ color: rgb(255, 0, 0)\
+}";
+
+ // import CSS once
+ dom.importCssString(cssText);
+
+ exports.cssClass = "ace-tm";
+});
+/* ***** 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
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/mode/matching_brace_outdent', function(require, exports, module) {
+
+var Range = require("ace/range").Range;
+
+var MatchingBraceOutdent = function() {};
+
+(function() {
+
+ this.checkOutdent = function(line, input) {
+ if (! /^\s+$/.test(line))
+ return false;
+
+ return /^\s*\}/.test(input);
+ };
+
+ this.autoOutdent = function(doc, row) {
+ var line = doc.getLine(row);
+ var match = line.match(/^(\s*\})/);
+
+ if (!match) return 0;
+
+ var column = match[1].length;
+ var openBracePos = doc.findMatchingBracket({row: row, column: column});
+
+ if (!openBracePos || openBracePos.row == row) return 0;
+
+ var indent = this.$getIndent(doc.getLine(openBracePos.row));
+ doc.replace(new Range(row, 0, row, column-1), indent);
+ };
+
+ this.$getIndent = function(line) {
+ var match = line.match(/^(\s+)/);
+ if (match) {
+ return match[1];
+ }
+
+ return "";
+ };
+
+}).call(MatchingBraceOutdent.prototype);
+
+exports.MatchingBraceOutdent = MatchingBraceOutdent;
+});
+/* 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
+ * Irakli Gozalishvili (http://jeditoolkit.com)
+ * Julian Viereck
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/virtual_renderer', function(require, exports, module) {
+
+var oop = require("pilot/oop");
+var dom = require("pilot/dom");
+var event = require("pilot/event");
+var useragent = require("pilot/useragent");
+var GutterLayer = require("ace/layer/gutter").Gutter;
+var MarkerLayer = require("ace/layer/marker").Marker;
+var TextLayer = require("ace/layer/text").Text;
+var CursorLayer = require("ace/layer/cursor").Cursor;
+var ScrollBar = require("ace/scrollbar").ScrollBar;
+var RenderLoop = require("ace/renderloop").RenderLoop;
+var EventEmitter = require("pilot/event_emitter").EventEmitter;
+var editorCss = require("text!ace/css/editor.css");
+
+// import CSS once
+dom.importCssString(editorCss);
+
+var VirtualRenderer = function(container, theme) {
+ this.container = container;
+ dom.addCssClass(this.container, "ace_editor");
+
+ this.setTheme(theme);
+
+ this.$gutter = document.createElement("div");
+ this.$gutter.className = "ace_gutter";
+ this.container.appendChild(this.$gutter);
+
+ this.scroller = document.createElement("div");
+ this.scroller.className = "ace_scroller";
+ this.container.appendChild(this.scroller);
+
+ this.content = document.createElement("div");
+ this.content.className = "ace_content";
+ this.scroller.appendChild(this.content);
+
+ this.$gutterLayer = new GutterLayer(this.$gutter);
+ this.$markerBack = new MarkerLayer(this.content);
+
+ var textLayer = this.$textLayer = new TextLayer(this.content);
+ this.canvas = textLayer.element;
+
+ this.$markerFront = new MarkerLayer(this.content);
+
+ this.characterWidth = textLayer.getCharacterWidth();
+ this.lineHeight = textLayer.getLineHeight();
+
+ this.$cursorLayer = new CursorLayer(this.content);
+ this.$cursorPadding = 8;
+
+ this.scrollBar = new ScrollBar(container);
+ this.scrollBar.addEventListener("scroll", this.onScroll.bind(this));
+
+ this.scrollTop = 0;
+
+ this.cursorPos = {
+ row : 0,
+ column : 0
+ };
+
+ var _self = this;
+ this.$textLayer.addEventListener("changeCharaterSize", function() {
+ _self.characterWidth = textLayer.getCharacterWidth();
+ _self.lineHeight = textLayer.getLineHeight();
+ _self.$updatePrintMargin();
+ _self.onResize(true);
+
+ _self.$loop.schedule(_self.CHANGE_FULL);
+ });
+ event.addListener(this.$gutter, "click", this.$onGutterClick.bind(this));
+ event.addListener(this.$gutter, "dblclick", this.$onGutterClick.bind(this));
+
+ this.$size = {
+ width: 0,
+ height: 0,
+ scrollerHeight: 0,
+ scrollerWidth: 0
+ };
+
+ this.$loop = new RenderLoop(this.$renderChanges.bind(this));
+ this.$loop.schedule(this.CHANGE_FULL);
+
+ this.setPadding(4);
+ this.$updatePrintMargin();
+};
+
+(function() {
+ this.showGutter = true;
+
+ this.CHANGE_CURSOR = 1;
+ this.CHANGE_MARKER = 2;
+ this.CHANGE_GUTTER = 4;
+ this.CHANGE_SCROLL = 8;
+ this.CHANGE_LINES = 16;
+ this.CHANGE_TEXT = 32;
+ this.CHANGE_SIZE = 64;
+ this.CHANGE_MARKER_BACK = 128;
+ this.CHANGE_MARKER_FRONT = 256;
+ this.CHANGE_FULL = 512;
+
+ oop.implement(this, EventEmitter);
+
+ this.setSession = function(session) {
+ this.session = session;
+ this.$cursorLayer.setSession(session);
+ this.$markerBack.setSession(session);
+ this.$markerFront.setSession(session);
+ this.$gutterLayer.setSession(session);
+ this.$textLayer.setSession(session);
+ this.$loop.schedule(this.CHANGE_FULL);
+ };
+
+ /**
+ * Triggers partial update of the text layer
+ */
+ this.updateLines = function(firstRow, lastRow) {
+ if (lastRow === undefined)
+ lastRow = Infinity;
+
+ if (!this.$changedLines) {
+ this.$changedLines = {
+ firstRow: firstRow,
+ lastRow: lastRow
+ };
+ }
+ else {
+ if (this.$changedLines.firstRow > firstRow)
+ this.$changedLines.firstRow = firstRow;
+
+ if (this.$changedLines.lastRow < lastRow)
+ this.$changedLines.lastRow = lastRow;
+ }
+
+ this.$loop.schedule(this.CHANGE_LINES);
+ };
+
+ /**
+ * Triggers full update of the text layer
+ */
+ this.updateText = function() {
+ this.$loop.schedule(this.CHANGE_TEXT);
+ };
+
+ /**
+ * Triggers a full update of all layers
+ */
+ this.updateFull = function() {
+ this.$loop.schedule(this.CHANGE_FULL);
+ };
+
+ /**
+ * Triggers resize of the editor
+ */
+ this.onResize = function(force) {
+ var changes = this.CHANGE_SIZE;
+
+ var height = dom.getInnerHeight(this.container);
+ if (force || this.$size.height != height) {
+ this.$size.height = height;
+
+ this.scroller.style.height = height + "px";
+ this.scrollBar.setHeight(height);
+
+ if (this.session) {
+ this.scrollToY(this.getScrollTop());
+ changes = changes | this.CHANGE_FULL;
+ }
+ }
+
+ var width = dom.getInnerWidth(this.container);
+ if (force || this.$size.width != width) {
+ this.$size.width = width;
+
+ var gutterWidth = this.showGutter ? this.$gutter.offsetWidth : 0;
+ this.scroller.style.left = gutterWidth + "px";
+ this.scroller.style.width = Math.max(0, width - gutterWidth - this.scrollBar.getWidth()) + "px";
+
+ if (this.session.getUseWrapMode()) {
+ var availableWidth = this.scroller.clientWidth - this.$padding * 2;
+ var limit = Math.floor(availableWidth / this.characterWidth) - 1;
+ if (this.session.adjustWrapLimit(limit) || force) {
+ changes = changes | this.CHANGE_FULL;
+ }
+ }
+ }
+
+ this.$size.scrollerWidth = this.scroller.clientWidth;
+ this.$size.scrollerHeight = this.scroller.clientHeight;
+ this.$loop.schedule(changes);
+ };
+
+ this.setTokenizer = function(tokenizer) {
+ this.$tokenizer = tokenizer;
+ this.$textLayer.setTokenizer(tokenizer);
+ this.$loop.schedule(this.CHANGE_TEXT);
+ };
+
+ this.$onGutterClick = function(e) {
+ var pageX = event.getDocumentX(e);
+ var pageY = event.getDocumentY(e);
+
+ this._dispatchEvent("gutter" + e.type, {
+ row: this.screenToTextCoordinates(pageX, pageY).row,
+ htmlEvent: e
+ });
+ };
+
+ this.setShowInvisibles = function(showInvisibles) {
+ if (this.$textLayer.setShowInvisibles(showInvisibles))
+ this.$loop.schedule(this.CHANGE_TEXT);
+ };
+
+ this.getShowInvisibles = function() {
+ return this.$textLayer.showInvisibles;
+ };
+
+ this.$showPrintMargin = true;
+ this.setShowPrintMargin = function(showPrintMargin) {
+ this.$showPrintMargin = showPrintMargin;
+ this.$updatePrintMargin();
+ };
+
+ this.getShowPrintMargin = function() {
+ return this.$showPrintMargin;
+ };
+
+ this.$printMarginColumn = 80;
+ this.setPrintMarginColumn = function(showPrintMargin) {
+ this.$printMarginColumn = showPrintMargin;
+ this.$updatePrintMargin();
+ };
+
+ this.getPrintMarginColumn = function() {
+ return this.$printMarginColumn;
+ };
+
+ this.setShowGutter = function(show){
+ if(this.showGutter === show)
+ return;
+ this.$gutter.style.display = show ? "block" : "none";
+ this.showGutter = show;
+ this.onResize(true);
+ }
+
+ this.$updatePrintMargin = function() {
+ var containerEl
+
+ if (!this.$showPrintMargin && !this.$printMarginEl)
+ return;
+
+ if (!this.$printMarginEl) {
+ containerEl = document.createElement("div");
+ containerEl.className = "ace_print_margin_layer";
+ this.$printMarginEl = document.createElement("div")
+ this.$printMarginEl.className = "ace_print_margin";
+ containerEl.appendChild(this.$printMarginEl);
+ this.content.insertBefore(containerEl, this.$textLayer.element);
+ }
+
+ var style = this.$printMarginEl.style;
+ style.left = ((this.characterWidth * this.$printMarginColumn) + this.$padding * 2) + "px";
+ style.visibility = this.$showPrintMargin ? "visible" : "hidden";
+ };
+
+ this.getContainerElement = function() {
+ return this.container;
+ };
+
+ this.getMouseEventTarget = function() {
+ return this.content;
+ };
+
+ this.getTextAreaContainer = function() {
+ return this.container;
+ };
+
+ this.moveTextAreaToCursor = function(textarea) {
+ // in IE the native cursor always shines through
+ if (useragent.isIE)
+ return;
+
+ var pos = this.$cursorLayer.getPixelPosition();
+ if (!pos)
+ return;
+
+ var bounds = this.content.getBoundingClientRect();
+ var offset = (this.layerConfig && this.layerConfig.offset) || 0;
+
+ textarea.style.left = (bounds.left + pos.left + this.$padding) + "px";
+ textarea.style.top = (bounds.top + pos.top - this.scrollTop + offset) + "px";
+ };
+
+ this.getFirstVisibleRow = function() {
+ return (this.layerConfig || {}).firstRow || 0;
+ };
+
+ this.getFirstFullyVisibleRow = function(){
+ if (!this.layerConfig)
+ return 0;
+
+ return this.layerConfig.firstRow + (this.layerConfig.offset == 0 ? 0 : 1);
+ }
+
+ this.getLastFullyVisibleRow = function() {
+ if (!this.layerConfig)
+ return 0;
+
+ var flint = Math.floor((this.layerConfig.height + this.layerConfig.offset) / this.layerConfig.lineHeight);
+ return this.layerConfig.firstRow - 1 + flint;
+ }
+
+ this.getLastVisibleRow = function() {
+ return (this.layerConfig || {}).lastRow || 0;
+ };
+
+ this.$padding = null;
+ this.setPadding = function(padding) {
+ this.$padding = padding;
+ this.content.style.padding = "0 " + padding + "px";
+ this.$loop.schedule(this.CHANGE_FULL);
+ this.$updatePrintMargin();
+ };
+
+ this.onScroll = function(e) {
+ this.scrollToY(e.data);
+ };
+
+ this.$updateScrollBar = function() {
+ this.scrollBar.setInnerHeight(this.session.getScreenLength() * this.lineHeight);
+ this.scrollBar.setScrollTop(this.scrollTop);
+ };
+
+ this.$renderChanges = function(changes) {
+ if (!changes || !this.session || !this.$tokenizer)
+ return;
+
+ // text, scrolling and resize changes can cause the view port size to change
+ if (!this.layerConfig ||
+ changes & this.CHANGE_FULL ||
+ changes & this.CHANGE_SIZE ||
+ changes & this.CHANGE_TEXT ||
+ changes & this.CHANGE_LINES ||
+ changes & this.CHANGE_SCROLL
+ )
+ this.$computeLayerConfig();
+
+ // full
+ if (changes & this.CHANGE_FULL) {
+ this.$textLayer.update(this.layerConfig);
+ this.showGutter && this.$gutterLayer.update(this.layerConfig);
+ this.$markerBack.update(this.layerConfig);
+ this.$markerFront.update(this.layerConfig);
+ this.$cursorLayer.update(this.layerConfig);
+ this.$updateScrollBar();
+ this.scrollCursorIntoView();
+ return;
+ }
+
+ // scrolling
+ if (changes & this.CHANGE_SCROLL) {
+ if (changes & this.CHANGE_TEXT || changes & this.CHANGE_LINES)
+ this.$textLayer.update(this.layerConfig);
+ else
+ this.$textLayer.scrollLines(this.layerConfig);
+ this.showGutter && this.$gutterLayer.update(this.layerConfig);
+ this.$markerBack.update(this.layerConfig);
+ this.$markerFront.update(this.layerConfig);
+ this.$cursorLayer.update(this.layerConfig);
+ this.$updateScrollBar();
+ return;
+ }
+
+ if (changes & this.CHANGE_TEXT) {
+ this.$textLayer.update(this.layerConfig);
+ this.showGutter && this.$gutterLayer.update(this.layerConfig);
+ }
+ else if (changes & this.CHANGE_LINES) {
+ this.$updateLines();
+ this.$updateScrollBar();
+ this.showGutter && this.$gutterLayer.update(this.layerConfig);
+ } else if (changes & this.CHANGE_GUTTER) {
+ this.showGutter && this.$gutterLayer.update(this.layerConfig);
+ }
+
+ if (changes & this.CHANGE_CURSOR)
+ this.$cursorLayer.update(this.layerConfig);
+
+ if (changes & (this.CHANGE_MARKER | this.CHANGE_MARKER_FRONT)) {
+ this.$markerFront.update(this.layerConfig);
+ }
+
+ if (changes & (this.CHANGE_MARKER | this.CHANGE_MARKER_BACK)) {
+ this.$markerBack.update(this.layerConfig);
+ }
+
+ if (changes & this.CHANGE_SIZE)
+ this.$updateScrollBar();
+ };
+
+ this.$computeLayerConfig = function() {
+ var session = this.session;
+
+ var offset = this.scrollTop % this.lineHeight;
+ var minHeight = this.$size.scrollerHeight + this.lineHeight;
+
+ var longestLine = this.$getLongestLine();
+ var widthChanged = !this.layerConfig ? true : (this.layerConfig.width != longestLine);
+
+ var lineCount = Math.ceil(minHeight / this.lineHeight) - 1;
+ var firstRow = Math.max(0, Math.round((this.scrollTop - offset) / this.lineHeight));
+ var lastRow = firstRow + lineCount;
+
+ // Map lines on the screen to lines in the document.
+ var firstRowScreen, firstRowHeight;
+ var lineHeight = { lineHeight: this.lineHeight };
+ firstRow = session.screenToDocumentRow(firstRow);
+ firstRowScreen = session.documentToScreenRow(firstRow);
+ firstRowHeight = session.getRowHeight(lineHeight, firstRow);
+
+ lastRow = Math.min(session.screenToDocumentRow(lastRow), session.getLength() - 1);
+ minHeight = this.$size.scrollerHeight + session.getRowHeight(lineHeight, lastRow)+
+ firstRowHeight;
+
+ offset = this.scrollTop - firstRowScreen * this.lineHeight;
+
+ var layerConfig = this.layerConfig = {
+ width : longestLine,
+ padding : this.$padding,
+ firstRow : firstRow,
+ firstRowScreen: firstRowScreen,
+ lastRow : lastRow,
+ lineHeight : this.lineHeight,
+ characterWidth : this.characterWidth,
+ minHeight : minHeight,
+ offset : offset,
+ height : this.$size.scrollerHeight
+ };
+
+ this.$gutterLayer.element.style.marginTop = (-offset) + "px";
+ this.content.style.marginTop = (-offset) + "px";
+ this.content.style.width = longestLine + "px";
+ this.content.style.height = minHeight + "px";
+ };
+
+ this.$updateLines = function() {
+ var firstRow = this.$changedLines.firstRow;
+ var lastRow = this.$changedLines.lastRow;
+ this.$changedLines = null;
+
+ var layerConfig = this.layerConfig;
+
+ // if the update changes the width of the document do a full redraw
+ if (layerConfig.width != this.$getLongestLine())
+ return this.$textLayer.update(layerConfig);
+
+ if (firstRow > layerConfig.lastRow + 1) { return; }
+ if (lastRow < layerConfig.firstRow) { return; }
+
+ // if the last row is unknown -> redraw everything
+ if (lastRow === Infinity) {
+ this.showGutter && this.$gutterLayer.update(layerConfig);
+ this.$textLayer.update(layerConfig);
+ return;
+ }
+
+ // else update only the changed rows
+ this.$textLayer.updateLines(layerConfig, firstRow, lastRow);
+ };
+
+ this.$getLongestLine = function() {
+ var charCount = this.session.getScreenWidth() + 1;
+ if (this.$textLayer.showInvisibles)
+ charCount += 1;
+
+ return Math.max(this.$size.scrollerWidth - this.$padding * 2, Math.round(charCount * this.characterWidth));
+ };
+
+ this.updateFrontMarkers = function() {
+ this.$markerFront.setMarkers(this.session.getMarkers(true));
+ this.$loop.schedule(this.CHANGE_MARKER_FRONT);
+ };
+
+ this.updateBackMarkers = function() {
+ this.$markerBack.setMarkers(this.session.getMarkers());
+ this.$loop.schedule(this.CHANGE_MARKER_BACK);
+ };
+
+ this.addGutterDecoration = function(row, className){
+ this.$gutterLayer.addGutterDecoration(row, className);
+ this.$loop.schedule(this.CHANGE_GUTTER);
+ }
+
+ this.removeGutterDecoration = function(row, className){
+ this.$gutterLayer.removeGutterDecoration(row, className);
+ this.$loop.schedule(this.CHANGE_GUTTER);
+ }
+
+ this.setBreakpoints = function(rows) {
+ this.$gutterLayer.setBreakpoints(rows);
+ this.$loop.schedule(this.CHANGE_GUTTER);
+ };
+
+ this.setAnnotations = function(annotations) {
+ this.$gutterLayer.setAnnotations(annotations);
+ this.$loop.schedule(this.CHANGE_GUTTER);
+ };
+
+ this.updateCursor = function(position, overwrite) {
+ this.$cursorLayer.setCursor(position, overwrite);
+ this.$loop.schedule(this.CHANGE_CURSOR);
+ };
+
+ this.hideCursor = function() {
+ this.$cursorLayer.hideCursor();
+ };
+
+ this.showCursor = function() {
+ this.$cursorLayer.showCursor();
+ };
+
+ this.scrollCursorIntoView = function() {
+ var pos = this.$cursorLayer.getPixelPosition();
+
+ var left = pos.left + this.$padding;
+ var top = pos.top;
+
+ if (this.getScrollTop() > top) {
+ this.scrollToY(top);
+ }
+
+ if (this.getScrollTop() + this.$size.scrollerHeight < top
+ + this.lineHeight) {
+ this.scrollToY(top + this.lineHeight - this.$size.scrollerHeight);
+ }
+
+ if (this.scroller.scrollLeft > left) {
+ this.scrollToX(left);
+ }
+
+ if (this.scroller.scrollLeft + this.$size.scrollerWidth < left + this.characterWidth) {
+
+ if (left + this.characterWidth > this.scroller.scrollWidth)
+ this.$renderChanges(this.CHANGE_SIZE);
+
+ this.scrollToX(Math.round(left + this.characterWidth - this.$size.scrollerWidth));
+ }
+ },
+
+ this.getScrollTop = function() {
+ return this.scrollTop;
+ };
+
+ this.getScrollLeft = function() {
+ return this.scroller.scrollLeft;
+ };
+
+ this.getScrollTopRow = function() {
+ return this.scrollTop / this.lineHeight;
+ };
+
+ this.getScrollBottomRow = function() {
+ return Math.max(0, Math.floor((this.scrollTop + this.$size.scrollerHeight) / this.lineHeight) - 1);
+ }
+
+ this.scrollToRow = function(row) {
+ this.scrollToY(row * this.lineHeight);
+ };
+
+ this.scrollToLine = function(line, center) {
+ var lineHeight = { lineHeight: this.lineHeight };
+ var offset = 0;
+ for (var l = 1; l < line; l++) {
+ offset += this.session.getRowHeight(lineHeight, l-1);
+ }
+
+ if (center) {
+ offset -= this.$size.scrollerHeight / 2;
+ }
+ this.scrollToY(offset);
+ };
+
+ this.scrollToY = function(scrollTop) {
+ var maxHeight = this.session.getScreenLength() * this.lineHeight - this.$size.scrollerHeight;
+ var scrollTop = Math.max(0, Math.min(maxHeight, scrollTop));
+
+ if (this.scrollTop !== scrollTop) {
+ this.scrollTop = scrollTop;
+ this.$loop.schedule(this.CHANGE_SCROLL);
+ }
+ };
+
+ this.scrollToX = function(scrollLeft) {
+ if (scrollLeft <= this.$padding)
+ scrollLeft = 0;
+
+ this.scroller.scrollLeft = scrollLeft;
+ };
+
+ this.scrollBy = function(deltaX, deltaY) {
+ deltaY && this.scrollToY(this.scrollTop + deltaY);
+ deltaX && this.scrollToX(this.scroller.scrollLeft + deltaX);
+ };
+
+ this.screenToTextCoordinates = function(pageX, pageY) {
+ var canvasPos = this.scroller.getBoundingClientRect();
+
+ var col = Math.round((pageX + this.scroller.scrollLeft - canvasPos.left - this.$padding - dom.getPageScrollLeft())
+ / this.characterWidth);
+ var row = Math.floor((pageY + this.scrollTop - canvasPos.top - dom.getPageScrollTop())
+ / this.lineHeight);
+
+ return this.session.screenToDocumentPosition(row, Math.max(col, 0));
+ };
+
+ this.textToScreenCoordinates = function(row, column) {
+ var canvasPos = this.scroller.getBoundingClientRect();
+ var pos = this.session.documentToScreenPosition(row, column);
+
+ var x = this.$padding + Math.round(pos.column * this.characterWidth);
+ var y = pos.row * this.lineHeight;
+
+ return {
+ pageX: canvasPos.left + x - this.getScrollLeft(),
+ pageY: canvasPos.top + y - this.getScrollTop()
+ }
+ };
+
+ this.visualizeFocus = function() {
+ dom.addCssClass(this.container, "ace_focus");
+ };
+
+ this.visualizeBlur = function() {
+ dom.removeCssClass(this.container, "ace_focus");
+ };
+
+ this.showComposition = function(position) {
+ if (!this.$composition) {
+ this.$composition = document.createElement("div");
+ this.$composition.className = "ace_composition";
+ this.content.appendChild(this.$composition);
+ }
+
+ this.$composition.innerHTML = " ";
+
+ var pos = this.$cursorLayer.getPixelPosition();
+ var style = this.$composition.style;
+ style.top = pos.top + "px";
+ style.left = (pos.left + this.$padding) + "px";
+ style.height = this.lineHeight + "px";
+
+ this.hideCursor();
+ };
+
+ this.setCompositionText = function(text) {
+ dom.setInnerText(this.$composition, text);
+ };
+
+ this.hideComposition = function() {
+ this.showCursor();
+
+ if (!this.$composition)
+ return;
+
+ var style = this.$composition.style;
+ style.top = "-10000px";
+ style.left = "-10000px";
+ };
+
+ this.setTheme = function(theme) {
+ var _self = this;
+ if (!theme || typeof theme == "string") {
+ theme = theme || "ace/theme/textmate";
+ require([theme], function(theme) {
+ afterLoad(theme);
+ });
+ } else {
+ afterLoad(theme);
+ }
+
+ var _self = this;
+ function afterLoad(theme) {
+ if (_self.$theme)
+ dom.removeCssClass(_self.container, _self.$theme);
+
+ _self.$theme = theme ? theme.cssClass : null;
+
+ if (_self.$theme)
+ dom.addCssClass(_self.container, _self.$theme);
+
+ // force re-measure of the gutter width
+ if (_self.$size) {
+ _self.$size.width = 0;
+ _self.onResize();
+ }
+ }
+ };
+
+ // Methods allows to add / remove CSS classnames to the editor element.
+ // This feature can be used by plug-ins to provide a visual indication of
+ // a certain mode that editor is in.
+
+ this.setStyle = function setStyle(style) {
+ dom.addCssClass(this.container, style)
+ };
+
+ this.unsetStyle = function unsetStyle(style) {
+ dom.removeCssClass(this.container, style)
+ };
+
+}).call(VirtualRenderer.prototype);
+
+exports.VirtualRenderer = VirtualRenderer;
+});
+/* ***** 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
+ * Julian Viereck
+ *
+ * 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 ***** */
+
+__ace_shadowed__.define('ace/layer/gutter', function(require, exports, module) {
+
+var dom = require("pilot/dom");
+
+var Gutter = function(parentEl) {
+ this.element = document.createElement("div");
+ this.element.className = "ace_layer ace_gutter-layer";
+ parentEl.appendChild(this.element);
+
+ this.$breakpoints = [];
+ this.$annotations = [];
+ this.$decorations = [];
+};
+
+(function() {
+
+ this.setSession = function(session) {
+ this.session = session;
+ };
+
+ this.addGutterDecoration = function(row, className){
+ if (!this.$decorations[row])
+ this.$decorations[row] = "";
+ this.$decorations[row] += " ace_" + className;
+ }
+
+ this.removeGutterDecoration = function(row, className){
+ this.$decorations[row] = this.$decorations[row].replace(" ace_" + className, "");
+ };
+
+ this.setBreakpoints = function(rows) {
+ this.$breakpoints = rows.concat();
+ };
+
+ this.setAnnotations = function(annotations) {
+ // iterate over sparse array
+ this.$annotations = [];
+ for (var row in annotations) if (annotations.hasOwnProperty(row)) {
+ var rowAnnotations = annotations[row];
+ if (!rowAnnotations)
+ continue;
+
+ var rowInfo = this.$annotations[row] = {
+ text: []
+ };
+ for (var i=0; i", (i+1), "