502 lines
11 KiB
JavaScript
Executable File
502 lines
11 KiB
JavaScript
Executable File
/**
|
|
* Tools.js
|
|
*
|
|
* Copyright, Moxiecode Systems AB
|
|
* Released under LGPL License.
|
|
*
|
|
* License: http://www.tinymce.com/license
|
|
* Contributing: http://www.tinymce.com/contributing
|
|
*/
|
|
|
|
/**
|
|
* This class contains various utlity functions. These are also exposed
|
|
* directly on the tinymce namespace.
|
|
*
|
|
* @class tinymce.util.Tools
|
|
*/
|
|
define("tinymce/util/Tools", [], function() {
|
|
/**
|
|
* Removes whitespace from the beginning and end of a string.
|
|
*
|
|
* @method trim
|
|
* @param {String} s String to remove whitespace from.
|
|
* @return {String} New string with removed whitespace.
|
|
*/
|
|
var whiteSpaceRegExp = /^\s*|\s*$/g;
|
|
var trim = function(str) {
|
|
return (str === null || str === undefined) ? '' : ("" + str).replace(whiteSpaceRegExp, '');
|
|
};
|
|
|
|
/**
|
|
* Returns true/false if the object is an array or not.
|
|
*
|
|
* @method isArray
|
|
* @param {Object} obj Object to check.
|
|
* @return {boolean} true/false state if the object is an array or not.
|
|
*/
|
|
var isArray = Array.isArray || function(obj) {
|
|
return Object.prototype.toString.call(obj) === "[object Array]";
|
|
};
|
|
|
|
/**
|
|
* Checks if a object is of a specific type for example an array.
|
|
*
|
|
* @method is
|
|
* @param {Object} o Object to check type of.
|
|
* @param {string} t Optional type to check for.
|
|
* @return {Boolean} true/false if the object is of the specified type.
|
|
*/
|
|
function is(o, t) {
|
|
if (!t) {
|
|
return o !== undefined;
|
|
}
|
|
|
|
if (t == 'array' && isArray(o)) {
|
|
return true;
|
|
}
|
|
|
|
return typeof(o) == t;
|
|
}
|
|
|
|
/**
|
|
* Converts the specified object into a real JavaScript array.
|
|
*
|
|
* @method toArray
|
|
* @param {Object} obj Object to convert into array.
|
|
* @return {Array} Array object based in input.
|
|
*/
|
|
function toArray(obj) {
|
|
var array = [], i, l;
|
|
|
|
for (i = 0, l = obj.length; i < l; i++) {
|
|
array[i] = obj[i];
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
/**
|
|
* Makes a name/object map out of an array with names.
|
|
*
|
|
* @method makeMap
|
|
* @param {Array/String} items Items to make map out of.
|
|
* @param {String} delim Optional delimiter to split string by.
|
|
* @param {Object} map Optional map to add items to.
|
|
* @return {Object} Name/value map of items.
|
|
*/
|
|
function makeMap(items, delim, map) {
|
|
var i;
|
|
|
|
items = items || [];
|
|
delim = delim || ',';
|
|
|
|
if (typeof(items) == "string") {
|
|
items = items.split(delim);
|
|
}
|
|
|
|
map = map || {};
|
|
|
|
i = items.length;
|
|
while (i--) {
|
|
map[items[i]] = {};
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
/**
|
|
* Performs an iteration of all items in a collection such as an object or array. This method will execure the
|
|
* callback function for each item in the collection, if the callback returns false the iteration will terminate.
|
|
* The callback has the following format: cb(value, key_or_index).
|
|
*
|
|
* @method each
|
|
* @param {Object} o Collection to iterate.
|
|
* @param {function} cb Callback function to execute for each item.
|
|
* @param {Object} s Optional scope to execute the callback in.
|
|
* @example
|
|
* // Iterate an array
|
|
* tinymce.each([1,2,3], function(v, i) {
|
|
* console.debug("Value: " + v + ", Index: " + i);
|
|
* });
|
|
*
|
|
* // Iterate an object
|
|
* tinymce.each({a: 1, b: 2, c: 3], function(v, k) {
|
|
* console.debug("Value: " + v + ", Key: " + k);
|
|
* });
|
|
*/
|
|
function each(o, cb, s) {
|
|
var n, l;
|
|
|
|
if (!o) {
|
|
return 0;
|
|
}
|
|
|
|
s = s || o;
|
|
|
|
if (o.length !== undefined) {
|
|
// Indexed arrays, needed for Safari
|
|
for (n=0, l = o.length; n < l; n++) {
|
|
if (cb.call(s, o[n], n, o) === false) {
|
|
return 0;
|
|
}
|
|
}
|
|
} else {
|
|
// Hashtables
|
|
for (n in o) {
|
|
if (o.hasOwnProperty(n)) {
|
|
if (cb.call(s, o[n], n, o) === false) {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Creates a new array by the return value of each iteration function call. This enables you to convert
|
|
* one array list into another.
|
|
*
|
|
* @method map
|
|
* @param {Array} a Array of items to iterate.
|
|
* @param {function} f Function to call for each item. It's return value will be the new value.
|
|
* @return {Array} Array with new values based on function return values.
|
|
*/
|
|
function map(a, f) {
|
|
var o = [];
|
|
|
|
each(a, function(v) {
|
|
o.push(f(v));
|
|
});
|
|
|
|
return o;
|
|
}
|
|
|
|
/**
|
|
* Filters out items from the input array by calling the specified function for each item.
|
|
* If the function returns false the item will be excluded if it returns true it will be included.
|
|
*
|
|
* @method grep
|
|
* @param {Array} a Array of items to loop though.
|
|
* @param {function} f Function to call for each item. Include/exclude depends on it's return value.
|
|
* @return {Array} New array with values imported and filtered based in input.
|
|
* @example
|
|
* // Filter out some items, this will return an array with 4 and 5
|
|
* var items = tinymce.grep([1,2,3,4,5], function(v) {return v > 3;});
|
|
*/
|
|
function grep(a, f) {
|
|
var o = [];
|
|
|
|
each(a, function(v) {
|
|
if (!f || f(v)) {
|
|
o.push(v);
|
|
}
|
|
});
|
|
|
|
return o;
|
|
}
|
|
|
|
/**
|
|
* Creates a class, subclass or static singleton.
|
|
* More details on this method can be found in the Wiki.
|
|
*
|
|
* @method create
|
|
* @param {String} s Class name, inheritage and prefix.
|
|
* @param {Object} p Collection of methods to add to the class.
|
|
* @param {Object} root Optional root object defaults to the global window object.
|
|
* @example
|
|
* // Creates a basic class
|
|
* tinymce.create('tinymce.somepackage.SomeClass', {
|
|
* SomeClass: function() {
|
|
* // Class constructor
|
|
* },
|
|
*
|
|
* method: function() {
|
|
* // Some method
|
|
* }
|
|
* });
|
|
*
|
|
* // Creates a basic subclass class
|
|
* tinymce.create('tinymce.somepackage.SomeSubClass:tinymce.somepackage.SomeClass', {
|
|
* SomeSubClass: function() {
|
|
* // Class constructor
|
|
* this.parent(); // Call parent constructor
|
|
* },
|
|
*
|
|
* method: function() {
|
|
* // Some method
|
|
* this.parent(); // Call parent method
|
|
* },
|
|
*
|
|
* 'static': {
|
|
* staticMethod: function() {
|
|
* // Static method
|
|
* }
|
|
* }
|
|
* });
|
|
*
|
|
* // Creates a singleton/static class
|
|
* tinymce.create('static tinymce.somepackage.SomeSingletonClass', {
|
|
* method: function() {
|
|
* // Some method
|
|
* }
|
|
* });
|
|
*/
|
|
function create(s, p, root) {
|
|
var t = this, sp, ns, cn, scn, c, de = 0;
|
|
|
|
// Parse : <prefix> <class>:<super class>
|
|
s = /^((static) )?([\w.]+)(:([\w.]+))?/.exec(s);
|
|
cn = s[3].match(/(^|\.)(\w+)$/i)[2]; // Class name
|
|
|
|
// Create namespace for new class
|
|
ns = t.createNS(s[3].replace(/\.\w+$/, ''), root);
|
|
|
|
// Class already exists
|
|
if (ns[cn]) {
|
|
return;
|
|
}
|
|
|
|
// Make pure static class
|
|
if (s[2] == 'static') {
|
|
ns[cn] = p;
|
|
|
|
if (this.onCreate) {
|
|
this.onCreate(s[2], s[3], ns[cn]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Create default constructor
|
|
if (!p[cn]) {
|
|
p[cn] = function() {};
|
|
de = 1;
|
|
}
|
|
|
|
// Add constructor and methods
|
|
ns[cn] = p[cn];
|
|
t.extend(ns[cn].prototype, p);
|
|
|
|
// Extend
|
|
if (s[5]) {
|
|
sp = t.resolve(s[5]).prototype;
|
|
scn = s[5].match(/\.(\w+)$/i)[1]; // Class name
|
|
|
|
// Extend constructor
|
|
c = ns[cn];
|
|
if (de) {
|
|
// Add passthrough constructor
|
|
ns[cn] = function() {
|
|
return sp[scn].apply(this, arguments);
|
|
};
|
|
} else {
|
|
// Add inherit constructor
|
|
ns[cn] = function() {
|
|
this.parent = sp[scn];
|
|
return c.apply(this, arguments);
|
|
};
|
|
}
|
|
ns[cn].prototype[cn] = ns[cn];
|
|
|
|
// Add super methods
|
|
t.each(sp, function(f, n) {
|
|
ns[cn].prototype[n] = sp[n];
|
|
});
|
|
|
|
// Add overridden methods
|
|
t.each(p, function(f, n) {
|
|
// Extend methods if needed
|
|
if (sp[n]) {
|
|
ns[cn].prototype[n] = function() {
|
|
this.parent = sp[n];
|
|
return f.apply(this, arguments);
|
|
};
|
|
} else {
|
|
if (n != cn) {
|
|
ns[cn].prototype[n] = f;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Add static methods
|
|
/*jshint sub:true*/
|
|
t.each(p['static'], function(f, n) {
|
|
ns[cn][n] = f;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Returns the index of a value in an array, this method will return -1 if the item wasn't found.
|
|
*
|
|
* @method inArray
|
|
* @param {Array} a Array/Object to search for value in.
|
|
* @param {Object} v Value to check for inside the array.
|
|
* @return {Number/String} Index of item inside the array inside an object. Or -1 if it wasn't found.
|
|
* @example
|
|
* // Get index of value in array this will alert 1 since 2 is at that index
|
|
* alert(tinymce.inArray([1,2,3], 2));
|
|
*/
|
|
function inArray(a, v) {
|
|
var i, l;
|
|
|
|
if (a) {
|
|
for (i = 0, l = a.length; i < l; i++) {
|
|
if (a[i] === v) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
function extend(obj, ext) {
|
|
var i, l, name, args = arguments, value;
|
|
|
|
for (i = 1, l = args.length; i < l; i++) {
|
|
ext = args[i];
|
|
for (name in ext) {
|
|
if (ext.hasOwnProperty(name)) {
|
|
value = ext[name];
|
|
|
|
if (value !== undefined) {
|
|
obj[name] = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Executed the specified function for each item in a object tree.
|
|
*
|
|
* @method walk
|
|
* @param {Object} o Object tree to walk though.
|
|
* @param {function} f Function to call for each item.
|
|
* @param {String} n Optional name of collection inside the objects to walk for example childNodes.
|
|
* @param {String} s Optional scope to execute the function in.
|
|
*/
|
|
function walk(o, f, n, s) {
|
|
s = s || this;
|
|
|
|
if (o) {
|
|
if (n) {
|
|
o = o[n];
|
|
}
|
|
|
|
each(o, function(o, i) {
|
|
if (f.call(s, o, i, n) === false) {
|
|
return false;
|
|
}
|
|
|
|
walk(o, f, n, s);
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a namespace on a specific object.
|
|
*
|
|
* @method createNS
|
|
* @param {String} n Namespace to create for example a.b.c.d.
|
|
* @param {Object} o Optional object to add namespace to, defaults to window.
|
|
* @return {Object} New namespace object the last item in path.
|
|
* @example
|
|
* // Create some namespace
|
|
* tinymce.createNS('tinymce.somepackage.subpackage');
|
|
*
|
|
* // Add a singleton
|
|
* var tinymce.somepackage.subpackage.SomeSingleton = {
|
|
* method: function() {
|
|
* // Some method
|
|
* }
|
|
* };
|
|
*/
|
|
function createNS(n, o) {
|
|
var i, v;
|
|
|
|
o = o || window;
|
|
|
|
n = n.split('.');
|
|
for (i=0; i<n.length; i++) {
|
|
v = n[i];
|
|
|
|
if (!o[v]) {
|
|
o[v] = {};
|
|
}
|
|
|
|
o = o[v];
|
|
}
|
|
|
|
return o;
|
|
}
|
|
|
|
/**
|
|
* Resolves a string and returns the object from a specific structure.
|
|
*
|
|
* @method resolve
|
|
* @param {String} n Path to resolve for example a.b.c.d.
|
|
* @param {Object} o Optional object to search though, defaults to window.
|
|
* @return {Object} Last object in path or null if it couldn't be resolved.
|
|
* @example
|
|
* // Resolve a path into an object reference
|
|
* var obj = tinymce.resolve('a.b.c.d');
|
|
*/
|
|
function resolve(n, o) {
|
|
var i, l;
|
|
|
|
o = o || window;
|
|
|
|
n = n.split('.');
|
|
for (i = 0, l = n.length; i < l; i++) {
|
|
o = o[n[i]];
|
|
|
|
if (!o) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return o;
|
|
}
|
|
|
|
/**
|
|
* Splits a string but removes the whitespace before and after each value.
|
|
*
|
|
* @method explode
|
|
* @param {string} s String to split.
|
|
* @param {string} d Delimiter to split by.
|
|
* @example
|
|
* // Split a string into an array with a,b,c
|
|
* var arr = tinymce.explode('a, b, c');
|
|
*/
|
|
function explode(s, d) {
|
|
if (!s || is(s, 'array')) {
|
|
return s;
|
|
}
|
|
|
|
return map(s.split(d || ','), trim);
|
|
}
|
|
|
|
return {
|
|
trim: trim,
|
|
isArray: isArray,
|
|
is: is,
|
|
toArray: toArray,
|
|
makeMap: makeMap,
|
|
each: each,
|
|
map: map,
|
|
grep: grep,
|
|
inArray: inArray,
|
|
extend: extend,
|
|
create: create,
|
|
walk: walk,
|
|
createNS: createNS,
|
|
resolve: resolve,
|
|
explode: explode
|
|
};
|
|
}); |