)((\n|\r|.)*?)(?:<\/script>)',
/** @id MochiKit.Base.stripScripts */
stripScripts: function (str) {
return str.replace(new RegExp(MochiKit.Base.ScriptFragment, 'img'), '');
},
/** @id MochiKit.Base.stripTags */
stripTags: function(str) {
return str.replace(/<\/?[^>]+>/gi, '');
},
/** @id MochiKit.Base.extractScripts */
extractScripts: function (str) {
var matchAll = new RegExp(MochiKit.Base.ScriptFragment, 'img');
var matchOne = new RegExp(MochiKit.Base.ScriptFragment, 'im');
return MochiKit.Base.map(function (scriptTag) {
return (scriptTag.match(matchOne) || ['', ''])[1];
}, str.match(matchAll) || []);
},
/** @id MochiKit.Base.evalScripts */
evalScripts: function (str) {
return MochiKit.Base.map(function (scr) {
eval(scr);
}, MochiKit.Base.extractScripts(str));
}
});
MochiKit.Form = {
/** @id MochiKit.Form.serialize */
serialize: function (form) {
var elements = MochiKit.Form.getElements(form);
var queryComponents = [];
for (var i = 0; i < elements.length; i++) {
var queryComponent = MochiKit.Form.serializeElement(elements[i]);
if (queryComponent) {
queryComponents.push(queryComponent);
}
}
return queryComponents.join('&');
},
/** @id MochiKit.Form.getElements */
getElements: function (form) {
form = MochiKit.DOM.getElement(form);
var elements = [];
for (var tagName in MochiKit.Form.Serializers) {
var tagElements = form.getElementsByTagName(tagName);
for (var j = 0; j < tagElements.length; j++) {
elements.push(tagElements[j]);
}
}
return elements;
},
/** @id MochiKit.Form.serializeElement */
serializeElement: function (element) {
element = MochiKit.DOM.getElement(element);
var method = element.tagName.toLowerCase();
var parameter = MochiKit.Form.Serializers[method](element);
if (parameter) {
var key = encodeURIComponent(parameter[0]);
if (key.length === 0) {
return;
}
if (!(parameter[1] instanceof Array)) {
parameter[1] = [parameter[1]];
}
return parameter[1].map(function (value) {
return key + '=' + encodeURIComponent(value);
}).join('&');
}
}
};
MochiKit.Form.Serializers = {
/** @id MochiKit.Form.Serializers.input */
input: function (element) {
switch (element.type.toLowerCase()) {
case 'submit':
case 'hidden':
case 'password':
case 'text':
return MochiKit.Form.Serializers.textarea(element);
case 'checkbox':
case 'radio':
return MochiKit.Form.Serializers.inputSelector(element);
}
return false;
},
/** @id MochiKit.Form.Serializers.inputSelector */
inputSelector: function (element) {
if (element.checked) {
return [element.name, element.value];
}
},
/** @id MochiKit.Form.Serializers.textarea */
textarea: function (element) {
return [element.name, element.value];
},
/** @id MochiKit.Form.Serializers.select */
select: function (element) {
return MochiKit.Form.Serializers[element.type == 'select-one' ?
'selectOne' : 'selectMany'](element);
},
/** @id MochiKit.Form.Serializers.selectOne */
selectOne: function (element) {
var value = '', opt, index = element.selectedIndex;
if (index >= 0) {
opt = element.options[index];
value = opt.value;
if (!value && !('value' in opt)) {
value = opt.text;
}
}
return [element.name, value];
},
/** @id MochiKit.Form.Serializers.selectMany */
selectMany: function (element) {
var value = [];
for (var i = 0; i < element.length; i++) {
var opt = element.options[i];
if (opt.selected) {
var optValue = opt.value;
if (!optValue && !('value' in opt)) {
optValue = opt.text;
}
value.push(optValue);
}
}
return [element.name, value];
}
};
/** @id Ajax */
var Ajax = {
activeRequestCount: 0
};
Ajax.Responders = {
responders: [],
/** @id Ajax.Responders.register */
register: function (responderToAdd) {
if (MochiKit.Base.find(this.responders, responderToAdd) == -1) {
this.responders.push(responderToAdd);
}
},
/** @id Ajax.Responders.unregister */
unregister: function (responderToRemove) {
this.responders = this.responders.without(responderToRemove);
},
/** @id Ajax.Responders.dispatch */
dispatch: function (callback, request, transport, json) {
MochiKit.Iter.forEach(this.responders, function (responder) {
if (responder[callback] &&
typeof(responder[callback]) == 'function') {
try {
responder[callback].apply(responder, [request, transport, json]);
} catch (e) {}
}
});
}
};
Ajax.Responders.register({
/** @id Ajax.Responders.onCreate */
onCreate: function () {
Ajax.activeRequestCount++;
},
/** @id Ajax.Responders.onComplete */
onComplete: function () {
Ajax.activeRequestCount--;
}
});
/** @id Ajax.Base */
Ajax.Base = function () {};
Ajax.Base.prototype = {
/** @id Ajax.Base.prototype.setOptions */
setOptions: function (options) {
this.options = {
method: 'post',
asynchronous: true,
parameters: ''
}
MochiKit.Base.update(this.options, options || {});
},
/** @id Ajax.Base.prototype.responseIsSuccess */
responseIsSuccess: function () {
return this.transport.status == undefined
|| this.transport.status === 0
|| (this.transport.status >= 200 && this.transport.status < 300);
},
/** @id Ajax.Base.prototype.responseIsFailure */
responseIsFailure: function () {
return !this.responseIsSuccess();
}
};
/** @id Ajax.Request */
Ajax.Request = function (url, options) {
this.__init__(url, options);
};
/** @id Ajax.Events */
Ajax.Request.Events = ['Uninitialized', 'Loading', 'Loaded',
'Interactive', 'Complete'];
MochiKit.Base.update(Ajax.Request.prototype, Ajax.Base.prototype);
MochiKit.Base.update(Ajax.Request.prototype, {
__init__: function (url, options) {
this.transport = MochiKit.Async.getXMLHttpRequest();
this.setOptions(options);
this.request(url);
},
/** @id Ajax.Request.prototype.request */
request: function (url) {
var parameters = this.options.parameters || '';
if (parameters.length > 0){
parameters += '&_=';
}
try {
this.url = url;
if (this.options.method == 'get' && parameters.length > 0) {
this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;
}
Ajax.Responders.dispatch('onCreate', this, this.transport);
this.transport.open(this.options.method, this.url,
this.options.asynchronous);
if (this.options.asynchronous) {
this.transport.onreadystatechange = MochiKit.Base.bind(this.onStateChange, this);
setTimeout(MochiKit.Base.bind(function () {
this.respondToReadyState(1);
}, this), 10);
}
this.setRequestHeaders();
var body = this.options.postBody ? this.options.postBody : parameters;
this.transport.send(this.options.method == 'post' ? body : null);
} catch (e) {
this.dispatchException(e);
}
},
/** @id Ajax.Request.prototype.setRequestHeaders */
setRequestHeaders: function () {
var requestHeaders = ['X-Requested-With', 'XMLHttpRequest'];
if (this.options.method == 'post') {
requestHeaders.push('Content-type',
'application/x-www-form-urlencoded');
/* Force 'Connection: close' for Mozilla browsers to work around
* a bug where XMLHttpRequest sends an incorrect Content-length
* header. See Mozilla Bugzilla #246651.
*/
if (this.transport.overrideMimeType) {
requestHeaders.push('Connection', 'close');
}
}
if (this.options.requestHeaders) {
requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);
}
for (var i = 0; i < requestHeaders.length; i += 2) {
this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
}
},
/** @id Ajax.Request.prototype.onStateChange */
onStateChange: function () {
var readyState = this.transport.readyState;
if (readyState != 1) {
this.respondToReadyState(this.transport.readyState);
}
},
/** @id Ajax.Request.prototype.header */
header: function (name) {
try {
return this.transport.getResponseHeader(name);
} catch (e) {}
},
/** @id Ajax.Request.prototype.evalJSON */
evalJSON: function () {
try {
return eval(this.header('X-JSON'));
} catch (e) {}
},
/** @id Ajax.Request.prototype.evalResponse */
evalResponse: function () {
try {
return eval(this.transport.responseText);
} catch (e) {
this.dispatchException(e);
}
},
/** @id Ajax.Request.prototype.respondToReadyState */
respondToReadyState: function (readyState) {
var event = Ajax.Request.Events[readyState];
var transport = this.transport, json = this.evalJSON();
if (event == 'Complete') {
try {
(this.options['on' + this.transport.status]
|| this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
|| MochiKit.Base.noop)(transport, json);
} catch (e) {
this.dispatchException(e);
}
if ((this.header('Content-type') || '').match(/^text\/javascript/i)) {
this.evalResponse();
}
}
try {
(this.options['on' + event] || MochiKit.Base.noop)(transport, json);
Ajax.Responders.dispatch('on' + event, this, transport, json);
} catch (e) {
this.dispatchException(e);
}
/* Avoid memory leak in MSIE: clean up the oncomplete event handler */
if (event == 'Complete') {
this.transport.onreadystatechange = MochiKit.Base.noop;
}
},
/** @id Ajax.Request.prototype.dispatchException */
dispatchException: function (exception) {
(this.options.onException || MochiKit.Base.noop)(this, exception);
Ajax.Responders.dispatch('onException', this, exception);
}
});
/** @id Ajax.Updater */
Ajax.Updater = function (container, url, options) {
this.__init__(container, url, options);
};
MochiKit.Base.update(Ajax.Updater.prototype, Ajax.Request.prototype);
MochiKit.Base.update(Ajax.Updater.prototype, {
__init__: function (container, url, options) {
this.containers = {
success: container.success ? MochiKit.DOM.getElement(container.success) : MochiKit.DOM.getElement(container),
failure: container.failure ? MochiKit.DOM.getElement(container.failure) :
(container.success ? null : MochiKit.DOM.getElement(container))
}
this.transport = MochiKit.Async.getXMLHttpRequest();
this.setOptions(options);
var onComplete = this.options.onComplete || MochiKit.Base.noop;
this.options.onComplete = MochiKit.Base.bind(function (transport, object) {
this.updateContent();
onComplete(transport, object);
}, this);
this.request(url);
},
/** @id Ajax.Updater.prototype.updateContent */
updateContent: function () {
var receiver = this.responseIsSuccess() ?
this.containers.success : this.containers.failure;
var response = this.transport.responseText;
if (!this.options.evalScripts) {
response = MochiKit.Base.stripScripts(response);
}
if (receiver) {
if (this.options.insertion) {
new this.options.insertion(receiver, response);
} else {
MochiKit.DOM.getElement(receiver).innerHTML =
MochiKit.Base.stripScripts(response);
setTimeout(function () {
MochiKit.Base.evalScripts(response);
}, 10);
}
}
if (this.responseIsSuccess()) {
if (this.onComplete) {
setTimeout(MochiKit.Base.bind(this.onComplete, this), 10);
}
}
}
});
/** @id Field */
var Field = {
/** @id clear */
clear: function () {
for (var i = 0; i < arguments.length; i++) {
MochiKit.DOM.getElement(arguments[i]).value = '';
}
},
/** @id focus */
focus: function (element) {
MochiKit.DOM.getElement(element).focus();
},
/** @id present */
present: function () {
for (var i = 0; i < arguments.length; i++) {
if (MochiKit.DOM.getElement(arguments[i]).value == '') {
return false;
}
}
return true;
},
/** @id select */
select: function (element) {
MochiKit.DOM.getElement(element).select();
},
/** @id activate */
activate: function (element) {
element = MochiKit.DOM.getElement(element);
element.focus();
if (element.select) {
element.select();
}
},
/** @id scrollFreeActivate */
scrollFreeActivate: function (field) {
setTimeout(function () {
Field.activate(field);
}, 1);
}
};
/** @id Autocompleter */
var Autocompleter = {};
/** @id Autocompleter.Base */
Autocompleter.Base = function () {};
Autocompleter.Base.prototype = {
/** @id Autocompleter.Base.prototype.baseInitialize */
baseInitialize: function (element, update, options) {
this.element = MochiKit.DOM.getElement(element);
this.update = MochiKit.DOM.getElement(update);
this.hasFocus = false;
this.changed = false;
this.active = false;
this.index = 0;
this.entryCount = 0;
if (this.setOptions) {
this.setOptions(options);
}
else {
this.options = options || {};
}
this.options.paramName = this.options.paramName || this.element.name;
this.options.tokens = this.options.tokens || [];
this.options.frequency = this.options.frequency || 0.4;
this.options.minChars = this.options.minChars || 1;
this.options.onShow = this.options.onShow || function (element, update) {
if (!update.style.position || update.style.position == 'absolute') {
update.style.position = 'absolute';
MochiKit.Position.clone(element, update, {
setHeight: false,
offsetTop: element.offsetHeight
});
}
MochiKit.Visual.appear(update, {duration:0.15});
};
this.options.onHide = this.options.onHide || function (element, update) {
MochiKit.Visual.fade(update, {duration: 0.15});
};
if (typeof(this.options.tokens) == 'string') {
this.options.tokens = new Array(this.options.tokens);
}
this.observer = null;
this.element.setAttribute('autocomplete', 'off');
MochiKit.Style.hideElement(this.update);
MochiKit.Signal.connect(this.element, 'onblur', this, this.onBlur);
MochiKit.Signal.connect(this.element, 'onkeypress', this, this.onKeyPress, this);
},
/** @id Autocompleter.Base.prototype.show */
show: function () {
if (MochiKit.Style.getStyle(this.update, 'display') == 'none') {
this.options.onShow(this.element, this.update);
}
if (!this.iefix && /MSIE/.test(navigator.userAgent &&
(MochiKit.Style.getStyle(this.update, 'position') == 'absolute'))) {
new Insertion.After(this.update,
'');
this.iefix = MochiKit.DOM.getElement(this.update.id + '_iefix');
}
if (this.iefix) {
setTimeout(MochiKit.Base.bind(this.fixIEOverlapping, this), 50);
}
},
/** @id Autocompleter.Base.prototype.fixIEOverlapping */
fixIEOverlapping: function () {
MochiKit.Position.clone(this.update, this.iefix);
this.iefix.style.zIndex = 1;
this.update.style.zIndex = 2;
MochiKit.Style.showElement(this.iefix);
},
/** @id Autocompleter.Base.prototype.hide */
hide: function () {
this.stopIndicator();
if (MochiKit.Style.getStyle(this.update, 'display') != 'none') {
this.options.onHide(this.element, this.update);
}
if (this.iefix) {
MochiKit.Style.hideElement(this.iefix);
}
},
/** @id Autocompleter.Base.prototype.startIndicator */
startIndicator: function () {
if (this.options.indicator) {
MochiKit.Style.showElement(this.options.indicator);
}
},
/** @id Autocompleter.Base.prototype.stopIndicator */
stopIndicator: function () {
if (this.options.indicator) {
MochiKit.Style.hideElement(this.options.indicator);
}
},
/** @id Autocompleter.Base.prototype.onKeyPress */
onKeyPress: function (event) {
if (this.active) {
if (event.key().string == "KEY_TAB" || event.key().string == "KEY_RETURN") {
this.selectEntry();
MochiKit.Event.stop(event);
} else if (event.key().string == "KEY_ESCAPE") {
this.hide();
this.active = false;
MochiKit.Event.stop(event);
return;
} else if (event.key().string == "KEY_LEFT" || event.key().string == "KEY_RIGHT") {
return;
} else if (event.key().string == "KEY_UP") {
this.markPrevious();
this.render();
if (/AppleWebKit'/.test(navigator.appVersion)) {
event.stop();
}
return;
} else if (event.key().string == "KEY_DOWN") {
this.markNext();
this.render();
if (/AppleWebKit'/.test(navigator.appVersion)) {
event.stop();
}
return;
}
} else {
if (event.key().string == "KEY_TAB" || event.key().string == "KEY_RETURN") {
return;
}
}
this.changed = true;
this.hasFocus = true;
if (this.observer) {
clearTimeout(this.observer);
}
this.observer = setTimeout(MochiKit.Base.bind(this.onObserverEvent, this),
this.options.frequency*1000);
},
/** @id Autocompleter.Base.prototype.findElement */
findElement: function (event, tagName) {
var element = event.target;
while (element.parentNode && (!element.tagName ||
(element.tagName.toUpperCase() != tagName.toUpperCase()))) {
element = element.parentNode;
}
return element;
},
/** @id Autocompleter.Base.prototype.hover */
onHover: function (event) {
var element = this.findElement(event, 'LI');
if (this.index != element.autocompleteIndex) {
this.index = element.autocompleteIndex;
this.render();
}
event.stop();
},
/** @id Autocompleter.Base.prototype.onClick */
onClick: function (event) {
var element = this.findElement(event, 'LI');
this.index = element.autocompleteIndex;
this.selectEntry();
this.hide();
},
/** @id Autocompleter.Base.prototype.onBlur */
onBlur: function (event) {
// needed to make click events working
setTimeout(MochiKit.Base.bind(this.hide, this), 250);
this.hasFocus = false;
this.active = false;
},
/** @id Autocompleter.Base.prototype.render */
render: function () {
if (this.entryCount > 0) {
for (var i = 0; i < this.entryCount; i++) {
this.index == i ?
MochiKit.DOM.addElementClass(this.getEntry(i), 'selected') :
MochiKit.DOM.removeElementClass(this.getEntry(i), 'selected');
}
if (this.hasFocus) {
this.show();
this.active = true;
}
} else {
this.active = false;
this.hide();
}
},
/** @id Autocompleter.Base.prototype.markPrevious */
markPrevious: function () {
if (this.index > 0) {
this.index--
} else {
this.index = this.entryCount-1;
}
},
/** @id Autocompleter.Base.prototype.markNext */
markNext: function () {
if (this.index < this.entryCount-1) {
this.index++
} else {
this.index = 0;
}
},
/** @id Autocompleter.Base.prototype.getEntry */
getEntry: function (index) {
return this.update.firstChild.childNodes[index];
},
/** @id Autocompleter.Base.prototype.getCurrentEntry */
getCurrentEntry: function () {
return this.getEntry(this.index);
},
/** @id Autocompleter.Base.prototype.selectEntry */
selectEntry: function () {
this.active = false;
this.updateElement(this.getCurrentEntry());
},
/** @id Autocompleter.Base.prototype.collectTextNodesIgnoreClass */
collectTextNodesIgnoreClass: function (element, className) {
return MochiKit.Base.flattenArray(MochiKit.Base.map(function (node) {
if (node.nodeType == 3) {
return node.nodeValue;
} else if (node.hasChildNodes() && !MochiKit.DOM.hasElementClass(node, className)) {
return this.collectTextNodesIgnoreClass(node, className);
}
return '';
}, MochiKit.DOM.getElement(element).childNodes)).join('');
},
/** @id Autocompleter.Base.prototype.updateElement */
updateElement: function (selectedElement) {
if (this.options.updateElement) {
this.options.updateElement(selectedElement);
return;
}
var value = '';
if (this.options.select) {
var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
if (nodes.length > 0) {
value = MochiKit.DOM.scrapeText(nodes[0]);
}
} else {
value = this.collectTextNodesIgnoreClass(selectedElement, 'informal');
}
var lastTokenPos = this.findLastToken();
if (lastTokenPos != -1) {
var newValue = this.element.value.substr(0, lastTokenPos + 1);
var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
if (whitespace) {
newValue += whitespace[0];
}
this.element.value = newValue + value;
} else {
this.element.value = value;
}
this.element.focus();
if (this.options.afterUpdateElement) {
this.options.afterUpdateElement(this.element, selectedElement);
}
},
/** @id Autocompleter.Base.prototype.updateChoices */
updateChoices: function (choices) {
if (!this.changed && this.hasFocus) {
this.update.innerHTML = choices;
var d = MochiKit.DOM;
d.removeEmptyTextNodes(this.update);
d.removeEmptyTextNodes(this.update.firstChild);
if (this.update.firstChild && this.update.firstChild.childNodes) {
this.entryCount = this.update.firstChild.childNodes.length;
for (var i = 0; i < this.entryCount; i++) {
var entry = this.getEntry(i);
entry.autocompleteIndex = i;
this.addObservers(entry);
}
} else {
this.entryCount = 0;
}
this.stopIndicator();
this.index = 0;
this.render();
}
},
/** @id Autocompleter.Base.prototype.addObservers */
addObservers: function (element) {
MochiKit.Signal.connect(element, 'onmouseover', this, this.onHover);
MochiKit.Signal.connect(element, 'onclick', this, this.onClick);
},
/** @id Autocompleter.Base.prototype.onObserverEvent */
onObserverEvent: function () {
this.changed = false;
if (this.getToken().length >= this.options.minChars) {
this.startIndicator();
this.getUpdatedChoices();
} else {
this.active = false;
this.hide();
}
},
/** @id Autocompleter.Base.prototype.getToken */
getToken: function () {
var tokenPos = this.findLastToken();
if (tokenPos != -1) {
var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
} else {
var ret = this.element.value;
}
return /\n/.test(ret) ? '' : ret;
},
/** @id Autocompleter.Base.prototype.findLastToken */
findLastToken: function () {
var lastTokenPos = -1;
for (var i = 0; i < this.options.tokens.length; i++) {
var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
if (thisTokenPos > lastTokenPos) {
lastTokenPos = thisTokenPos;
}
}
return lastTokenPos;
}
}
/** @id Ajax.Autocompleter */
Ajax.Autocompleter = function (element, update, url, options) {
this.__init__(element, update, url, options);
};
MochiKit.Base.update(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype);
MochiKit.Base.update(Ajax.Autocompleter.prototype, {
__init__: function (element, update, url, options) {
this.baseInitialize(element, update, options);
this.options.asynchronous = true;
this.options.onComplete = MochiKit.Base.bind(this.onComplete, this);
this.options.defaultParams = this.options.parameters || null;
this.url = url;
},
/** @id Ajax.Autocompleter.prototype.getUpdatedChoices */
getUpdatedChoices: function () {
var entry = encodeURIComponent(this.options.paramName) + '=' +
encodeURIComponent(this.getToken());
this.options.parameters = this.options.callback ?
this.options.callback(this.element, entry) : entry;
if (this.options.defaultParams) {
this.options.parameters += '&' + this.options.defaultParams;
}
new Ajax.Request(this.url, this.options);
},
/** @id Ajax.Autocompleter.prototype.onComplete */
onComplete: function (request) {
this.updateChoices(request.responseText);
}
});
/***
The local array autocompleter. Used when you'd prefer to
inject an array of autocompletion options into the page, rather
than sending out Ajax queries, which can be quite slow sometimes.
The constructor takes four parameters. The first two are, as usual,
the id of the monitored textbox, and id of the autocompletion menu.
The third is the array you want to autocomplete from, and the fourth
is the options block.
Extra local autocompletion options:
- choices - How many autocompletion choices to offer
- partialSearch - If false, the autocompleter will match entered
text only at the beginning of strings in the
autocomplete array. Defaults to true, which will
match text at the beginning of any *word* in the
strings in the autocomplete array. If you want to
search anywhere in the string, additionally set
the option fullSearch to true (default: off).
- fullSsearch - Search anywhere in autocomplete array strings.
- partialChars - How many characters to enter before triggering
a partial match (unlike minChars, which defines
how many characters are required to do any match
at all). Defaults to 2.
- ignoreCase - Whether to ignore case when autocompleting.
Defaults to true.
It's possible to pass in a custom function as the 'selector'
option, if you prefer to write your own autocompletion logic.
In that case, the other options above will not apply unless
you support them.
***/
/** @id Autocompleter.Local */
Autocompleter.Local = function (element, update, array, options) {
this.__init__(element, update, array, options);
};
MochiKit.Base.update(Autocompleter.Local.prototype, Autocompleter.Base.prototype);
MochiKit.Base.update(Autocompleter.Local.prototype, {
__init__: function (element, update, array, options) {
this.baseInitialize(element, update, options);
this.options.array = array;
},
/** @id Autocompleter.Local.prototype.getUpdatedChoices */
getUpdatedChoices: function () {
this.updateChoices(this.options.selector(this));
},
/** @id Autocompleter.Local.prototype.setOptions */
setOptions: function (options) {
this.options = MochiKit.Base.update({
choices: 10,
partialSearch: true,
partialChars: 2,
ignoreCase: true,
fullSearch: false,
selector: function (instance) {
var ret = []; // Beginning matches
var partial = []; // Inside matches
var entry = instance.getToken();
var count = 0;
for (var i = 0; i < instance.options.array.length &&
ret.length < instance.options.choices ; i++) {
var elem = instance.options.array[i];
var foundPos = instance.options.ignoreCase ?
elem.toLowerCase().indexOf(entry.toLowerCase()) :
elem.indexOf(entry);
while (foundPos != -1) {
if (foundPos === 0 && elem.length != entry.length) {
ret.push('' + elem.substr(0, entry.length) + '' +
elem.substr(entry.length) + '');
break;
} else if (entry.length >= instance.options.partialChars &&
instance.options.partialSearch && foundPos != -1) {
if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos - 1, 1))) {
partial.push('' + elem.substr(0, foundPos) + '' +
elem.substr(foundPos, entry.length) + '' + elem.substr(
foundPos + entry.length) + '');
break;
}
}
foundPos = instance.options.ignoreCase ?
elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) :
elem.indexOf(entry, foundPos + 1);
}
}
if (partial.length) {
ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
}
return '';
}
}, options || {});
}
});
/***
AJAX in-place editor
see documentation on http://wiki.script.aculo.us/scriptaculous/show/Ajax.InPlaceEditor
Use this if you notice weird scrolling problems on some browsers,
the DOM might be a bit confused when this gets called so do this
waits 1 ms (with setTimeout) until it does the activation
***/
/** @id Ajax.InPlaceEditor */
Ajax.InPlaceEditor = function (element, url, options) {
this.__init__(element, url, options);
};
/** @id Ajax.InPlaceEditor.defaultHighlightColor */
Ajax.InPlaceEditor.defaultHighlightColor = '#FFFF99';
Ajax.InPlaceEditor.prototype = {
__init__: function (element, url, options) {
this.url = url;
this.element = MochiKit.DOM.getElement(element);
this.options = MochiKit.Base.update({
okButton: true,
okText: 'ok',
cancelLink: true,
cancelText: 'cancel',
savingText: 'Saving...',
clickToEditText: 'Click to edit',
okText: 'ok',
rows: 1,
onComplete: function (transport, element) {
new MochiKit.Visual.Highlight(element, {startcolor: this.options.highlightcolor});
},
onFailure: function (transport) {
alert('Error communicating with the server: ' + MochiKit.Base.stripTags(transport.responseText));
},
callback: function (form) {
return MochiKit.DOM.formContents(form);
},
handleLineBreaks: true,
loadingText: 'Loading...',
savingClassName: 'inplaceeditor-saving',
loadingClassName: 'inplaceeditor-loading',
formClassName: 'inplaceeditor-form',
highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
highlightendcolor: '#FFFFFF',
externalControl: null,
submitOnBlur: false,
ajaxOptions: {}
}, options || {});
if (!this.options.formId && this.element.id) {
this.options.formId = this.element.id + '-inplaceeditor';
if (MochiKit.DOM.getElement(this.options.formId)) {
// there's already a form with that name, don't specify an id
this.options.formId = null;
}
}
if (this.options.externalControl) {
this.options.externalControl = MochiKit.DOM.getElement(this.options.externalControl);
}
this.originalBackground = MochiKit.Style.getStyle(this.element, 'background-color');
if (!this.originalBackground) {
this.originalBackground = 'transparent';
}
this.element.title = this.options.clickToEditText;
this.onclickListener = MochiKit.Signal.connect(this.element, 'onclick', this, this.enterEditMode);
this.mouseoverListener = MochiKit.Signal.connect(this.element, 'onmouseover', this, this.enterHover);
this.mouseoutListener = MochiKit.Signal.connect(this.element, 'onmouseout', this, this.leaveHover);
if (this.options.externalControl) {
this.onclickListenerExternal = MochiKit.Signal.connect(this.options.externalControl,
'onclick', this, this.enterEditMode);
this.mouseoverListenerExternal = MochiKit.Signal.connect(this.options.externalControl,
'onmouseover', this, this.enterHover);
this.mouseoutListenerExternal = MochiKit.Signal.connect(this.options.externalControl,
'onmouseout', this, this.leaveHover);
}
},
/** @id Ajax.InPlaceEditor.prototype.enterEditMode */
enterEditMode: function (evt) {
if (this.saving) {
return;
}
if (this.editing) {
return;
}
this.editing = true;
this.onEnterEditMode();
if (this.options.externalControl) {
MochiKit.Style.hideElement(this.options.externalControl);
}
MochiKit.Style.hideElement(this.element);
this.createForm();
this.element.parentNode.insertBefore(this.form, this.element);
Field.scrollFreeActivate(this.editField);
// stop the event to avoid a page refresh in Safari
if (evt) {
evt.stop();
}
return false;
},
/** @id Ajax.InPlaceEditor.prototype.createForm */
createForm: function () {
this.form = document.createElement('form');
this.form.id = this.options.formId;
MochiKit.DOM.addElementClass(this.form, this.options.formClassName)
this.form.onsubmit = MochiKit.Base.bind(this.onSubmit, this);
this.createEditField();
if (this.options.textarea) {
var br = document.createElement('br');
this.form.appendChild(br);
}
if (this.options.okButton) {
okButton = document.createElement('input');
okButton.type = 'submit';
okButton.value = this.options.okText;
this.form.appendChild(okButton);
}
if (this.options.cancelLink) {
cancelLink = document.createElement('a');
cancelLink.href = '#';
cancelLink.appendChild(document.createTextNode(this.options.cancelText));
cancelLink.onclick = MochiKit.Base.bind(this.onclickCancel, this);
this.form.appendChild(cancelLink);
}
},
/** @id Ajax.InPlaceEditor.prototype.hasHTMLLineBreaks */
hasHTMLLineBreaks: function (string) {
if (!this.options.handleLineBreaks) {
return false;
}
return string.match(/
/i);
},
/** @id Ajax.InPlaceEditor.prototype.convertHTMLLineBreaks */
convertHTMLLineBreaks: function (string) {
return string.replace(/
/gi, '\n').replace(//gi, '\n').replace(/<\/p>/gi, '\n').replace(//gi, '');
},
/** @id Ajax.InPlaceEditor.prototype.createEditField */
createEditField: function () {
var text;
if (this.options.loadTextURL) {
text = this.options.loadingText;
} else {
text = this.getText();
}
var obj = this;
if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)) {
this.options.textarea = false;
var textField = document.createElement('input');
textField.obj = this;
textField.type = 'text';
textField.name = 'value';
textField.value = text;
textField.style.backgroundColor = this.options.highlightcolor;
var size = this.options.size || this.options.cols || 0;
if (size !== 0) {
textField.size = size;
}
if (this.options.submitOnBlur) {
textField.onblur = MochiKit.Base.bind(this.onSubmit, this);
}
this.editField = textField;
} else {
this.options.textarea = true;
var textArea = document.createElement('textarea');
textArea.obj = this;
textArea.name = 'value';
textArea.value = this.convertHTMLLineBreaks(text);
textArea.rows = this.options.rows;
textArea.cols = this.options.cols || 40;
if (this.options.submitOnBlur) {
textArea.onblur = MochiKit.Base.bind(this.onSubmit, this);
}
this.editField = textArea;
}
if (this.options.loadTextURL) {
this.loadExternalText();
}
this.form.appendChild(this.editField);
},
/** @id Ajax.InPlaceEditor.prototype.getText */
getText: function () {
return this.element.innerHTML;
},
/** @id Ajax.InPlaceEditor.prototype.loadExternalText */
loadExternalText: function () {
MochiKit.DOM.addElementClass(this.form, this.options.loadingClassName);
this.editField.disabled = true;
new Ajax.Request(
this.options.loadTextURL,
MochiKit.Base.update({
asynchronous: true,
onComplete: MochiKit.Base.bind(this.onLoadedExternalText, this)
}, this.options.ajaxOptions)
);
},
/** @id Ajax.InPlaceEditor.prototype.onLoadedExternalText */
onLoadedExternalText: function (transport) {
MochiKit.DOM.removeElementClass(this.form, this.options.loadingClassName);
this.editField.disabled = false;
this.editField.value = MochiKit.Base.stripTags(transport);
},
/** @id Ajax.InPlaceEditor.prototype.onclickCancel */
onclickCancel: function () {
this.onComplete();
this.leaveEditMode();
return false;
},
/** @id Ajax.InPlaceEditor.prototype.onFailure */
onFailure: function (transport) {
this.options.onFailure(transport);
if (this.oldInnerHTML) {
this.element.innerHTML = this.oldInnerHTML;
this.oldInnerHTML = null;
}
return false;
},
/** @id Ajax.InPlaceEditor.prototype.onSubmit */
onSubmit: function () {
// onLoading resets these so we need to save them away for the Ajax call
var form = this.form;
var value = this.editField.value;
// do this first, sometimes the ajax call returns before we get a
// chance to switch on Saving which means this will actually switch on
// Saving *after* we have left edit mode causing Saving to be
// displayed indefinitely
this.onLoading();
new Ajax.Updater(
{
success: this.element,
// dont update on failure (this could be an option)
failure: null
},
this.url,
MochiKit.Base.update({
parameters: this.options.callback(form, value),
onComplete: MochiKit.Base.bind(this.onComplete, this),
onFailure: MochiKit.Base.bind(this.onFailure, this)
}, this.options.ajaxOptions)
);
// stop the event to avoid a page refresh in Safari
if (arguments.length > 1) {
arguments[0].stop();
}
return false;
},
/** @id Ajax.InPlaceEditor.prototype.onLoading */
onLoading: function () {
this.saving = true;
this.removeForm();
this.leaveHover();
this.showSaving();
},
/** @id Ajax.InPlaceEditor.prototype.onSaving */
showSaving: function () {
this.oldInnerHTML = this.element.innerHTML;
this.element.innerHTML = this.options.savingText;
MochiKit.DOM.addElementClass(this.element, this.options.savingClassName);
this.element.style.backgroundColor = this.originalBackground;
MochiKit.Style.showElement(this.element);
},
/** @id Ajax.InPlaceEditor.prototype.removeForm */
removeForm: function () {
if (this.form) {
if (this.form.parentNode) {
MochiKit.DOM.removeElement(this.form);
}
this.form = null;
}
},
/** @id Ajax.InPlaceEditor.prototype.enterHover */
enterHover: function () {
if (this.saving) {
return;
}
this.element.style.backgroundColor = this.options.highlightcolor;
if (this.effect) {
this.effect.cancel();
}
MochiKit.DOM.addElementClass(this.element, this.options.hoverClassName)
},
/** @id Ajax.InPlaceEditor.prototype.leaveHover */
leaveHover: function () {
if (this.options.backgroundColor) {
this.element.style.backgroundColor = this.oldBackground;
}
MochiKit.DOM.removeElementClass(this.element, this.options.hoverClassName)
if (this.saving) {
return;
}
this.effect = new MochiKit.Visual.Highlight(this.element, {
startcolor: this.options.highlightcolor,
endcolor: this.options.highlightendcolor,
restorecolor: this.originalBackground
});
},
/** @id Ajax.InPlaceEditor.prototype.leaveEditMode */
leaveEditMode: function () {
MochiKit.DOM.removeElementClass(this.element, this.options.savingClassName);
this.removeForm();
this.leaveHover();
this.element.style.backgroundColor = this.originalBackground;
MochiKit.Style.showElement(this.element);
if (this.options.externalControl) {
MochiKit.Style.showElement(this.options.externalControl);
}
this.editing = false;
this.saving = false;
this.oldInnerHTML = null;
this.onLeaveEditMode();
},
/** @id Ajax.InPlaceEditor.prototype.onComplete */
onComplete: function (transport) {
this.leaveEditMode();
MochiKit.Base.bind(this.options.onComplete, this)(transport, this.element);
},
/** @id Ajax.InPlaceEditor.prototype.onEnterEditMode */
onEnterEditMode: function () {},
/** @id Ajax.InPlaceEditor.prototype.onLeaveEditMode */
onLeaveEditMode: function () {},
/** @id Ajax.InPlaceEditor.prototype.dispose */
dispose: function () {
if (this.oldInnerHTML) {
this.element.innerHTML = this.oldInnerHTML;
}
this.leaveEditMode();
MochiKit.Signal.disconnect(this.onclickListener);
MochiKit.Signal.disconnect(this.mouseoverListener);
MochiKit.Signal.disconnect(this.mouseoutListener);
if (this.options.externalControl) {
MochiKit.Signal.disconnect(this.onclickListenerExternal);
MochiKit.Signal.disconnect(this.mouseoverListenerExternal);
MochiKit.Signal.disconnect(this.mouseoutListenerExternal);
}
}
};
/***
MochiKit.DateTime 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.DateTime');
}
if (typeof(MochiKit) == 'undefined') {
MochiKit = {};
}
if (typeof(MochiKit.DateTime) == 'undefined') {
MochiKit.DateTime = {};
}
MochiKit.DateTime.NAME = "MochiKit.DateTime";
MochiKit.DateTime.VERSION = "1.4";
MochiKit.DateTime.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
MochiKit.DateTime.toString = function () {
return this.__repr__();
};
/** @id MochiKit.DateTime.isoDate */
MochiKit.DateTime.isoDate = function (str) {
str = str + "";
if (typeof(str) != "string" || str.length === 0) {
return null;
}
var iso = str.split('-');
if (iso.length === 0) {
return null;
}
return new Date(iso[0], iso[1] - 1, iso[2]);
};
MochiKit.DateTime._isoRegexp = /(\d{4,})(?:-(\d{1,2})(?:-(\d{1,2})(?:[T ](\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.(\d+))?)?(?:(Z)|([+-])(\d{1,2})(?::(\d{1,2}))?)?)?)?)?/;
/** @id MochiKit.DateTime.isoTimestamp */
MochiKit.DateTime.isoTimestamp = function (str) {
str = str + "";
if (typeof(str) != "string" || str.length === 0) {
return null;
}
var res = str.match(MochiKit.DateTime._isoRegexp);
if (typeof(res) == "undefined" || res === null) {
return null;
}
var year, month, day, hour, min, sec, msec;
year = parseInt(res[1], 10);
if (typeof(res[2]) == "undefined" || res[2] === '') {
return new Date(year);
}
month = parseInt(res[2], 10) - 1;
day = parseInt(res[3], 10);
if (typeof(res[4]) == "undefined" || res[4] === '') {
return new Date(year, month, day);
}
hour = parseInt(res[4], 10);
min = parseInt(res[5], 10);
sec = (typeof(res[6]) != "undefined" && res[6] !== '') ? parseInt(res[6], 10) : 0;
if (typeof(res[7]) != "undefined" && res[7] !== '') {
msec = Math.round(1000.0 * parseFloat("0." + res[7]));
} else {
msec = 0;
}
if ((typeof(res[8]) == "undefined" || res[8] === '') && (typeof(res[9]) == "undefined" || res[9] === '')) {
return new Date(year, month, day, hour, min, sec, msec);
}
var ofs;
if (typeof(res[9]) != "undefined" && res[9] !== '') {
ofs = parseInt(res[10], 10) * 3600000;
if (typeof(res[11]) != "undefined" && res[11] !== '') {
ofs += parseInt(res[11], 10) * 60000;
}
if (res[9] == "-") {
ofs = -ofs;
}
} else {
ofs = 0;
}
return new Date(Date.UTC(year, month, day, hour, min, sec, msec) - ofs);
};
/** @id MochiKit.DateTime.toISOTime */
MochiKit.DateTime.toISOTime = function (date, realISO/* = false */) {
if (typeof(date) == "undefined" || date === null) {
return null;
}
var hh = date.getHours();
var mm = date.getMinutes();
var ss = date.getSeconds();
var lst = [
((realISO && (hh < 10)) ? "0" + hh : hh),
((mm < 10) ? "0" + mm : mm),
((ss < 10) ? "0" + ss : ss)
];
return lst.join(":");
};
/** @id MochiKit.DateTime.toISOTimeStamp */
MochiKit.DateTime.toISOTimestamp = function (date, realISO/* = false*/) {
if (typeof(date) == "undefined" || date === null) {
return null;
}
var sep = realISO ? "T" : " ";
var foot = realISO ? "Z" : "";
if (realISO) {
date = new Date(date.getTime() + (date.getTimezoneOffset() * 60000));
}
return MochiKit.DateTime.toISODate(date) + sep + MochiKit.DateTime.toISOTime(date, realISO) + foot;
};
/** @id MochiKit.DateTime.toISODate */
MochiKit.DateTime.toISODate = function (date) {
if (typeof(date) == "undefined" || date === null) {
return null;
}
var _padTwo = MochiKit.DateTime._padTwo;
return [
date.getFullYear(),
_padTwo(date.getMonth() + 1),
_padTwo(date.getDate())
].join("-");
};
/** @id MochiKit.DateTime.americanDate */
MochiKit.DateTime.americanDate = function (d) {
d = d + "";
if (typeof(d) != "string" || d.length === 0) {
return null;
}
var a = d.split('/');
return new Date(a[2], a[0] - 1, a[1]);
};
MochiKit.DateTime._padTwo = function (n) {
return (n > 9) ? n : "0" + n;
};
/** @id MochiKit.DateTime.toPaddedAmericanDate */
MochiKit.DateTime.toPaddedAmericanDate = function (d) {
if (typeof(d) == "undefined" || d === null) {
return null;
}
var _padTwo = MochiKit.DateTime._padTwo;
return [
_padTwo(d.getMonth() + 1),
_padTwo(d.getDate()),
d.getFullYear()
].join('/');
};
/** @id MochiKit.DateTime.toAmericanDate */
MochiKit.DateTime.toAmericanDate = function (d) {
if (typeof(d) == "undefined" || d === null) {
return null;
}
return [d.getMonth() + 1, d.getDate(), d.getFullYear()].join('/');
};
MochiKit.DateTime.EXPORT = [
"isoDate",
"isoTimestamp",
"toISOTime",
"toISOTimestamp",
"toISODate",
"americanDate",
"toPaddedAmericanDate",
"toAmericanDate"
];
MochiKit.DateTime.EXPORT_OK = [];
MochiKit.DateTime.EXPORT_TAGS = {
":common": MochiKit.DateTime.EXPORT,
":all": MochiKit.DateTime.EXPORT
};
MochiKit.DateTime.__new__ = function () {
// MochiKit.Base.nameFunctions(this);
var base = this.NAME + ".";
for (var k in this) {
var o = this[k];
if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
try {
o.NAME = base + k;
} catch (e) {
// pass
}
}
}
};
MochiKit.DateTime.__new__();
if (typeof(MochiKit.Base) != "undefined") {
MochiKit.Base._exportSymbols(this, MochiKit.DateTime);
} else {
(function (globals, module) {
if ((typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
|| (MochiKit.__export__ === false)) {
var all = module.EXPORT_TAGS[":all"];
for (var i = 0; i < all.length; i++) {
globals[all[i]] = module[all[i]];
}
}
})(this, MochiKit.DateTime);
}
/***
MochiKit.Format 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Format');
}
if (typeof(MochiKit) == 'undefined') {
MochiKit = {};
}
if (typeof(MochiKit.Format) == 'undefined') {
MochiKit.Format = {};
}
MochiKit.Format.NAME = "MochiKit.Format";
MochiKit.Format.VERSION = "1.4";
MochiKit.Format.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
MochiKit.Format.toString = function () {
return this.__repr__();
};
MochiKit.Format._numberFormatter = function (placeholder, header, footer, locale, isPercent, precision, leadingZeros, separatorAt, trailingZeros) {
return function (num) {
num = parseFloat(num);
if (typeof(num) == "undefined" || num === null || isNaN(num)) {
return placeholder;
}
var curheader = header;
var curfooter = footer;
if (num < 0) {
num = -num;
} else {
curheader = curheader.replace(/-/, "");
}
var me = arguments.callee;
var fmt = MochiKit.Format.formatLocale(locale);
if (isPercent) {
num = num * 100.0;
curfooter = fmt.percent + curfooter;
}
num = MochiKit.Format.roundToFixed(num, precision);
var parts = num.split(/\./);
var whole = parts[0];
var frac = (parts.length == 1) ? "" : parts[1];
var res = "";
while (whole.length < leadingZeros) {
whole = "0" + whole;
}
if (separatorAt) {
while (whole.length > separatorAt) {
var i = whole.length - separatorAt;
//res = res + fmt.separator + whole.substring(i, whole.length);
res = fmt.separator + whole.substring(i, whole.length) + res;
whole = whole.substring(0, i);
}
}
res = whole + res;
if (precision > 0) {
while (frac.length < trailingZeros) {
frac = frac + "0";
}
res = res + fmt.decimal + frac;
}
return curheader + res + curfooter;
};
};
/** @id MochiKit.Format.numberFormatter */
MochiKit.Format.numberFormatter = function (pattern, placeholder/* = "" */, locale/* = "default" */) {
// http://java.sun.com/docs/books/tutorial/i18n/format/numberpattern.html
// | 0 | leading or trailing zeros
// | # | just the number
// | , | separator
// | . | decimal separator
// | % | Multiply by 100 and format as percent
if (typeof(placeholder) == "undefined") {
placeholder = "";
}
var match = pattern.match(/((?:[0#]+,)?[0#]+)(?:\.([0#]+))?(%)?/);
if (!match) {
throw TypeError("Invalid pattern");
}
var header = pattern.substr(0, match.index);
var footer = pattern.substr(match.index + match[0].length);
if (header.search(/-/) == -1) {
header = header + "-";
}
var whole = match[1];
var frac = (typeof(match[2]) == "string" && match[2] != "") ? match[2] : "";
var isPercent = (typeof(match[3]) == "string" && match[3] != "");
var tmp = whole.split(/,/);
var separatorAt;
if (typeof(locale) == "undefined") {
locale = "default";
}
if (tmp.length == 1) {
separatorAt = null;
} else {
separatorAt = tmp[1].length;
}
var leadingZeros = whole.length - whole.replace(/0/g, "").length;
var trailingZeros = frac.length - frac.replace(/0/g, "").length;
var precision = frac.length;
var rval = MochiKit.Format._numberFormatter(
placeholder, header, footer, locale, isPercent, precision,
leadingZeros, separatorAt, trailingZeros
);
var m = MochiKit.Base;
if (m) {
var fn = arguments.callee;
var args = m.concat(arguments);
rval.repr = function () {
return [
self.NAME,
"(",
map(m.repr, args).join(", "),
")"
].join("");
};
}
return rval;
};
/** @id MochiKit.Format.formatLocale */
MochiKit.Format.formatLocale = function (locale) {
if (typeof(locale) == "undefined" || locale === null) {
locale = "default";
}
if (typeof(locale) == "string") {
var rval = MochiKit.Format.LOCALE[locale];
if (typeof(rval) == "string") {
rval = arguments.callee(rval);
MochiKit.Format.LOCALE[locale] = rval;
}
return rval;
} else {
return locale;
}
};
/** @id MochiKit.Format.twoDigitAverage */
MochiKit.Format.twoDigitAverage = function (numerator, denominator) {
if (denominator) {
var res = numerator / denominator;
if (!isNaN(res)) {
return MochiKit.Format.twoDigitFloat(numerator / denominator);
}
}
return "0";
};
/** @id MochiKit.Format.twoDigitFloat */
MochiKit.Format.twoDigitFloat = function (someFloat) {
var sign = (someFloat < 0 ? '-' : '');
var s = Math.floor(Math.abs(someFloat) * 100).toString();
if (s == '0') {
return s;
}
if (s.length < 3) {
while (s.charAt(s.length - 1) == '0') {
s = s.substring(0, s.length - 1);
}
return sign + '0.' + s;
}
var head = sign + s.substring(0, s.length - 2);
var tail = s.substring(s.length - 2, s.length);
if (tail == '00') {
return head;
} else if (tail.charAt(1) == '0') {
return head + '.' + tail.charAt(0);
} else {
return head + '.' + tail;
}
};
/** @id MochiKit.Format.lstrip */
MochiKit.Format.lstrip = function (str, /* optional */chars) {
str = str + "";
if (typeof(str) != "string") {
return null;
}
if (!chars) {
return str.replace(/^\s+/, "");
} else {
return str.replace(new RegExp("^[" + chars + "]+"), "");
}
};
/** @id MochiKit.Format.rstrip */
MochiKit.Format.rstrip = function (str, /* optional */chars) {
str = str + "";
if (typeof(str) != "string") {
return null;
}
if (!chars) {
return str.replace(/\s+$/, "");
} else {
return str.replace(new RegExp("[" + chars + "]+$"), "");
}
};
/** @id MochiKit.Format.strip */
MochiKit.Format.strip = function (str, /* optional */chars) {
var self = MochiKit.Format;
return self.rstrip(self.lstrip(str, chars), chars);
};
/** @id MochiKit.Format.truncToFixed */
MochiKit.Format.truncToFixed = function (aNumber, precision) {
aNumber = Math.floor(aNumber * Math.pow(10, precision));
var res = (aNumber * Math.pow(10, -precision)).toFixed(precision);
if (res.charAt(0) == ".") {
res = "0" + res;
}
return res;
};
/** @id MochiKit.Format.roundToFixed */
MochiKit.Format.roundToFixed = function (aNumber, precision) {
return MochiKit.Format.truncToFixed(
aNumber + 0.5 * Math.pow(10, -precision),
precision
);
};
/** @id MochiKit.Format.percentFormat */
MochiKit.Format.percentFormat = function (someFloat) {
return MochiKit.Format.twoDigitFloat(100 * someFloat) + '%';
};
MochiKit.Format.EXPORT = [
"truncToFixed",
"roundToFixed",
"numberFormatter",
"formatLocale",
"twoDigitAverage",
"twoDigitFloat",
"percentFormat",
"lstrip",
"rstrip",
"strip"
];
MochiKit.Format.LOCALE = {
en_US: {separator: ",", decimal: ".", percent: "%"},
de_DE: {separator: ".", decimal: ",", percent: "%"},
pt_BR: {separator: ".", decimal: ",", percent: "%"},
fr_FR: {separator: " ", decimal: ",", percent: "%"},
"default": "en_US"
};
MochiKit.Format.EXPORT_OK = [];
MochiKit.Format.EXPORT_TAGS = {
':all': MochiKit.Format.EXPORT,
':common': MochiKit.Format.EXPORT
};
MochiKit.Format.__new__ = function () {
// MochiKit.Base.nameFunctions(this);
var base = this.NAME + ".";
var k, v, o;
for (k in this.LOCALE) {
o = this.LOCALE[k];
if (typeof(o) == "object") {
o.repr = function () { return this.NAME; };
o.NAME = base + "LOCALE." + k;
}
}
for (k in this) {
o = this[k];
if (typeof(o) == 'function' && typeof(o.NAME) == 'undefined') {
try {
o.NAME = base + k;
} catch (e) {
// pass
}
}
}
};
MochiKit.Format.__new__();
if (typeof(MochiKit.Base) != "undefined") {
MochiKit.Base._exportSymbols(this, MochiKit.Format);
} else {
(function (globals, module) {
if ((typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
|| (MochiKit.__export__ === false)) {
var all = module.EXPORT_TAGS[":all"];
for (var i = 0; i < all.length; i++) {
globals[all[i]] = module[all[i]];
}
}
})(this, MochiKit.Format);
}
/***
MochiKit.MockDOM 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
if (typeof(MochiKit) == "undefined") {
MochiKit = {};
}
if (typeof(MochiKit.MockDOM) == "undefined") {
MochiKit.MockDOM = {};
}
MochiKit.MockDOM.NAME = "MochiKit.MockDOM";
MochiKit.MockDOM.VERSION = "1.4";
MochiKit.MockDOM.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
/** @id MochiKit.MockDOM.toString */
MochiKit.MockDOM.toString = function () {
return this.__repr__();
};
/** @id MochiKit.MockDOM.createDocument */
MochiKit.MockDOM.createDocument = function () {
var doc = new MochiKit.MockDOM.MockElement("DOCUMENT");
doc.body = doc.createElement("BODY");
doc.appendChild(doc.body);
return doc;
};
/** @id MochiKit.MockDOM.MockElement */
MochiKit.MockDOM.MockElement = function (name, data, ownerDocument) {
this.tagName = this.nodeName = name.toUpperCase();
this.ownerDocument = ownerDocument || null;
if (name == "DOCUMENT") {
this.nodeType = 9;
this.childNodes = [];
} else if (typeof(data) == "string") {
this.nodeValue = data;
this.nodeType = 3;
} else {
this.nodeType = 1;
this.childNodes = [];
}
if (name.substring(0, 1) == "<") {
var nameattr = name.substring(
name.indexOf('"') + 1, name.lastIndexOf('"'));
name = name.substring(1, name.indexOf(" "));
this.tagName = this.nodeName = name.toUpperCase();
this.setAttribute("name", nameattr);
}
};
MochiKit.MockDOM.MockElement.prototype = {
/** @id MochiKit.MockDOM.MockElement.prototype.createElement */
createElement: function (tagName) {
return new MochiKit.MockDOM.MockElement(tagName, null, this.nodeType == 9 ? this : this.ownerDocument);
},
/** @id MochiKit.MockDOM.MockElement.prototype.createTextNode */
createTextNode: function (text) {
return new MochiKit.MockDOM.MockElement("text", text, this.nodeType == 9 ? this : this.ownerDocument);
},
/** @id MochiKit.MockDOM.MockElement.prototype.setAttribute */
setAttribute: function (name, value) {
this[name] = value;
},
/** @id MochiKit.MockDOM.MockElement.prototype.getAttribute */
getAttribute: function (name) {
return this[name];
},
/** @id MochiKit.MockDOM.MockElement.prototype.appendChild */
appendChild: function (child) {
this.childNodes.push(child);
},
/** @id MochiKit.MockDOM.MockElement.prototype.toString */
toString: function () {
return "MockElement(" + this.tagName + ")";
},
/** @id MochiKit.MockDOM.MockElement.prototype.getElementsByTagName */
getElementsByTagName: function (tagName) {
var foundElements = [];
MochiKit.Base.nodeWalk(this, function(node){
if (tagName == '*' || tagName == node.tagName) {
foundElements.push(node);
return node.childNodes;
}
});
return foundElements;
}
};
/** @id MochiKit.MockDOM.EXPORT_OK */
MochiKit.MockDOM.EXPORT_OK = [
"mockElement",
"createDocument"
];
/** @id MochiKit.MockDOM.EXPORT */
MochiKit.MockDOM.EXPORT = [
"document"
];
MochiKit.MockDOM.__new__ = function () {
this.document = this.createDocument();
};
MochiKit.MockDOM.__new__();
/***
MochiKit.Selector 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito and others. All rights Reserved.
***/
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Selector');
dojo.require('MochiKit.Base');
dojo.require('MochiKit.DOM');
dojo.require('MochiKit.Iter');
}
if (typeof(JSAN) != 'undefined') {
JSAN.use("MochiKit.Base", []);
JSAN.use("MochiKit.DOM", []);
JSAN.use("MochiKit.Iter", []);
}
try {
if (typeof(MochiKit.Base) === 'undefined' ||
typeof(MochiKit.DOM) === 'undefined' ||
typeof(MochiKit.Iter) === 'undefined') {
throw "";
}
} catch (e) {
throw "MochiKit.Selector depends on MochiKit.Base, MochiKit.DOM and MochiKit.Iter!";
}
if (typeof(MochiKit.Selector) == 'undefined') {
MochiKit.Selector = {};
}
MochiKit.Selector.NAME = "MochiKit.Selector";
MochiKit.Selector.VERSION = "1.4";
MochiKit.Selector.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
MochiKit.Selector.toString = function () {
return this.__repr__();
};
MochiKit.Selector.EXPORT = [
"Selector",
"findChildElements",
"findDocElements",
"$$"
];
MochiKit.Selector.EXPORT_OK = [
];
MochiKit.Selector.Selector = function (expression) {
this.params = {classNames: [], pseudoClassNames: []};
this.expression = expression.toString().replace(/(^\s+|\s+$)/g, '');
this.parseExpression();
this.compileMatcher();
};
MochiKit.Selector.Selector.prototype = {
/***
Selector class: convenient object to make CSS selections.
***/
__class__: MochiKit.Selector.Selector,
/** @id MochiKit.Selector.Selector.prototype.parseExpression */
parseExpression: function () {
function abort(message) {
throw 'Parse error in selector: ' + message;
}
if (this.expression == '') {
abort('empty expression');
}
var repr = MochiKit.Base.repr;
var params = this.params;
var expr = this.expression;
var match, modifier, clause, rest;
while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!^$*]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)) {
params.attributes = params.attributes || [];
params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
expr = match[1];
}
if (expr == '*') {
return this.params.wildcard = true;
}
while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+(?:\([^)]*\))?)(.*)/i)) {
modifier = match[1];
clause = match[2];
rest = match[3];
switch (modifier) {
case '#':
params.id = clause;
break;
case '.':
params.classNames.push(clause);
break;
case ':':
params.pseudoClassNames.push(clause);
break;
case '':
case undefined:
params.tagName = clause.toUpperCase();
break;
default:
abort(repr(expr));
}
expr = rest;
}
if (expr.length > 0) {
abort(repr(expr));
}
},
/** @id MochiKit.Selector.Selector.prototype.buildMatchExpression */
buildMatchExpression: function () {
var repr = MochiKit.Base.repr;
var params = this.params;
var conditions = [];
var clause, i;
function childElements(element) {
return "MochiKit.Base.filter(function (node) { return node.nodeType == 1; }, " + element + ".childNodes)";
}
if (params.wildcard) {
conditions.push('true');
}
if (clause = params.id) {
conditions.push('element.id == ' + repr(clause));
}
if (clause = params.tagName) {
conditions.push('element.tagName.toUpperCase() == ' + repr(clause));
}
if ((clause = params.classNames).length > 0) {
for (i = 0; i < clause.length; i++) {
conditions.push('MochiKit.DOM.hasElementClass(element, ' + repr(clause[i]) + ')');
}
}
if ((clause = params.pseudoClassNames).length > 0) {
for (i = 0; i < clause.length; i++) {
var match = clause[i].match(/^([^(]+)(?:\((.*)\))?$/);
var pseudoClass = match[1];
var pseudoClassArgument = match[2];
switch (pseudoClass) {
case 'root':
conditions.push('element.nodeType == 9 || element === element.ownerDocument.documentElement'); break;
case 'nth-child':
case 'nth-last-child':
case 'nth-of-type':
case 'nth-last-of-type':
match = pseudoClassArgument.match(/^((?:(\d+)n\+)?(\d+)|odd|even)$/);
if (!match) {
throw "Invalid argument to pseudo element nth-child: " + pseudoClassArgument;
}
var a, b;
if (match[0] == 'odd') {
a = 2;
b = 1;
} else if (match[0] == 'even') {
a = 2;
b = 0;
} else {
a = match[2] && parseInt(match) || null;
b = parseInt(match[3]);
}
conditions.push('this.nthChild(element,' + a + ',' + b
+ ',' + !!pseudoClass.match('^nth-last') // Reverse
+ ',' + !!pseudoClass.match('of-type$') // Restrict to same tagName
+ ')');
break;
case 'first-child':
conditions.push('this.nthChild(element, null, 1)');
break;
case 'last-child':
conditions.push('this.nthChild(element, null, 1, true)');
break;
case 'first-of-type':
conditions.push('this.nthChild(element, null, 1, false, true)');
break;
case 'last-of-type':
conditions.push('this.nthChild(element, null, 1, true, true)');
break;
case 'only-child':
conditions.push(childElements('element.parentNode') + '.length == 1');
break;
case 'only-of-type':
conditions.push('MochiKit.Base.filter(function (node) { return node.tagName == element.tagName; }, ' + childElements('element.parentNode') + ').length == 1');
break;
case 'empty':
conditions.push('element.childNodes.length == 0');
break;
case 'enabled':
conditions.push('(this.isUIElement(element) && element.disabled === false)');
break;
case 'disabled':
conditions.push('(this.isUIElement(element) && element.disabled === true)');
break;
case 'checked':
conditions.push('(this.isUIElement(element) && element.checked === true)');
break;
case 'not':
var subselector = new MochiKit.Selector.Selector(pseudoClassArgument);
conditions.push('!( ' + subselector.buildMatchExpression() + ')')
break;
}
}
}
if (clause = params.attributes) {
MochiKit.Base.map(function (attribute) {
var value = 'MochiKit.DOM.getNodeAttribute(element, ' + repr(attribute.name) + ')';
var splitValueBy = function (delimiter) {
return value + '.split(' + repr(delimiter) + ')';
}
switch (attribute.operator) {
case '=':
conditions.push(value + ' == ' + repr(attribute.value));
break;
case '~=':
conditions.push(value + ' && MochiKit.Base.findValue(' + splitValueBy(' ') + ', ' + repr(attribute.value) + ') > -1');
break;
case '^=':
conditions.push(value + '.substring(0, ' + attribute.value.length + ') == ' + repr(attribute.value));
break;
case '$=':
conditions.push(value + '.substring(' + value + '.length - ' + attribute.value.length + ') == ' + repr(attribute.value));
break;
case '*=':
conditions.push(value + '.match(' + repr(attribute.value) + ')');
break;
case '|=':
conditions.push(
value + ' && ' + splitValueBy('-') + '[0].toUpperCase() == ' + repr(attribute.value.toUpperCase())
);
break;
case '!=':
conditions.push(value + ' != ' + repr(attribute.value));
break;
case '':
case undefined:
conditions.push(value + ' != null');
break;
default:
throw 'Unknown operator ' + attribute.operator + ' in selector';
}
}, clause);
}
return conditions.join(' && ');
},
/** @id MochiKit.Selector.Selector.prototype.compileMatcher */
compileMatcher: function () {
this.match = new Function('element', 'if (!element.tagName) return false; \
return ' + this.buildMatchExpression());
},
/** @id MochiKit.Selector.Selector.prototype.nthChild */
nthChild: function (element, a, b, reverse, sametag){
var siblings = MochiKit.Base.filter(function (node) {
return node.nodeType == 1;
}, element.parentNode.childNodes);
if (sametag) {
siblings = MochiKit.Base.filter(function (node) {
return node.tagName == element.tagName;
}, siblings);
}
if (reverse) {
siblings = MochiKit.Iter.reversed(siblings);
}
if (a) {
var actualIndex = MochiKit.Base.findIdentical(siblings, element);
return ((actualIndex + 1 - b) / a) % 1 == 0;
} else {
return b == MochiKit.Base.findIdentical(siblings, element) + 1;
}
},
/** @id MochiKit.Selector.Selector.prototype.isUIElement */
isUIElement: function (element) {
return MochiKit.Base.findValue(['input', 'button', 'select', 'option', 'textarea', 'object'],
element.tagName.toLowerCase()) > -1;
},
/** @id MochiKit.Selector.Selector.prototype.findElements */
findElements: function (scope, axis) {
var element;
if (axis == undefined) {
axis = "";
}
function inScope(element, scope) {
if (axis == "") {
return MochiKit.DOM.isChildNode(element, scope);
} else if (axis == ">") {
return element.parentNode == scope;
} else if (axis == "+") {
return element == nextSiblingElement(scope);
} else if (axis == "~") {
var sibling = scope;
while (sibling = nextSiblingElement(sibling)) {
if (element == sibling) {
return true;
}
}
return false;
} else {
throw "Invalid axis: " + axis;
}
}
if (element = MochiKit.DOM.getElement(this.params.id)) {
if (this.match(element)) {
if (!scope || inScope(element, scope)) {
return [element];
}
}
}
function nextSiblingElement(node) {
node = node.nextSibling;
while (node && node.nodeType != 1) {
node = node.nextSibling;
}
return node;
}
if (axis == "") {
scope = (scope || MochiKit.DOM.currentDocument()).getElementsByTagName(this.params.tagName || '*');
} else if (axis == ">") {
if (!scope) {
throw "> combinator not allowed without preceeding expression";
}
scope = MochiKit.Base.filter(function (node) {
return node.nodeType == 1;
}, scope.childNodes);
} else if (axis == "+") {
if (!scope) {
throw "+ combinator not allowed without preceeding expression";
}
scope = nextSiblingElement(scope) && [nextSiblingElement(scope)];
} else if (axis == "~") {
if (!scope) {
throw "~ combinator not allowed without preceeding expression";
}
var newscope = [];
while (nextSiblingElement(scope)) {
scope = nextSiblingElement(scope);
newscope.push(scope);
}
scope = newscope;
}
if (!scope) {
return [];
}
var results = MochiKit.Base.filter(MochiKit.Base.bind(function (scopeElt) {
return this.match(scopeElt);
}, this), scope);
return results;
},
/** @id MochiKit.Selector.Selector.prototype.repr */
repr: function () {
return 'Selector(' + this.expression + ')';
},
toString: MochiKit.Base.forwardCall("repr")
};
MochiKit.Base.update(MochiKit.Selector, {
/** @id MochiKit.Selector.findChildElements */
findChildElements: function (element, expressions) {
return MochiKit.Base.flattenArray(MochiKit.Base.map(function (expression) {
var nextScope = "";
return MochiKit.Iter.reduce(function (results, expr) {
if (match = expr.match(/^[>+~]$/)) {
nextScope = match[0];
return results;
} else {
var selector = new MochiKit.Selector.Selector(expr);
var elements = MochiKit.Iter.reduce(function (elements, result) {
return MochiKit.Base.extend(elements, selector.findElements(result || element, nextScope));
}, results, []);
nextScope = "";
return elements;
}
}, expression.replace(/(^\s+|\s+$)/g, '').split(/\s+/), [null]);
}, expressions));
},
findDocElements: function () {
return MochiKit.Selector.findChildElements(MochiKit.DOM.currentDocument(), arguments);
},
__new__: function () {
var m = MochiKit.Base;
this.$$ = this.findDocElements;
this.EXPORT_TAGS = {
":common": this.EXPORT,
":all": m.concat(this.EXPORT, this.EXPORT_OK)
};
m.nameFunctions(this);
}
});
MochiKit.Selector.__new__();
MochiKit.Base._exportSymbols(this, MochiKit.Selector);
/***
Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
Mochi-ized By Thomas Herve (_firstname_@nimail.org)
See scriptaculous.js for full license.
***/
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Sortable');
dojo.require('MochiKit.Base');
dojo.require('MochiKit.DOM');
dojo.require('MochiKit.Iter');
}
if (typeof(JSAN) != 'undefined') {
JSAN.use("MochiKit.Base", []);
JSAN.use("MochiKit.DOM", []);
JSAN.use("MochiKit.Iter", []);
}
try {
if (typeof(MochiKit.Base) == 'undefined' ||
typeof(MochiKit.DOM) == 'undefined' ||
typeof(MochiKit.Iter) == 'undefined') {
throw "";
}
} catch (e) {
throw "MochiKit.DragAndDrop depends on MochiKit.Base, MochiKit.DOM and MochiKit.Iter!";
}
if (typeof(MochiKit.Sortable) == 'undefined') {
MochiKit.Sortable = {};
}
MochiKit.Sortable.NAME = 'MochiKit.Sortable';
MochiKit.Sortable.VERSION = '1.4';
MochiKit.Sortable.__repr__ = function () {
return '[' + this.NAME + ' ' + this.VERSION + ']';
};
MochiKit.Sortable.toString = function () {
return this.__repr__();
};
MochiKit.Sortable.EXPORT = [
];
MochiKit.Sortable.EXPORT_OK = [
];
MochiKit.Base.update(MochiKit.Sortable, {
/***
Manage sortables. Mainly use the create function to add a sortable.
***/
sortables: {},
_findRootElement: function (element) {
while (element.tagName.toUpperCase() != "BODY") {
if (element.id && MochiKit.Sortable.sortables[element.id]) {
return element;
}
element = element.parentNode;
}
},
/** @id MochiKit.Sortable.options */
options: function (element) {
element = MochiKit.Sortable._findRootElement(MochiKit.DOM.getElement(element));
if (!element) {
return;
}
return MochiKit.Sortable.sortables[element.id];
},
/** @id MochiKit.Sortable.destroy */
destroy: function (element){
var s = MochiKit.Sortable.options(element);
var b = MochiKit.Base;
var d = MochiKit.DragAndDrop;
if (s) {
MochiKit.Signal.disconnect(s.startHandle);
MochiKit.Signal.disconnect(s.endHandle);
b.map(function (dr) {
d.Droppables.remove(dr);
}, s.droppables);
b.map(function (dr) {
dr.destroy();
}, s.draggables);
delete MochiKit.Sortable.sortables[s.element.id];
}
},
/** @id MochiKit.Sortable.create */
create: function (element, options) {
element = MochiKit.DOM.getElement(element);
var self = MochiKit.Sortable;
/** @id MochiKit.Sortable.options */
options = MochiKit.Base.update({
/** @id MochiKit.Sortable.element */
element: element,
/** @id MochiKit.Sortable.tag */
tag: 'li', // assumes li children, override with tag: 'tagname'
/** @id MochiKit.Sortable.dropOnEmpty */
dropOnEmpty: false,
/** @id MochiKit.Sortable.tree */
tree: false,
/** @id MochiKit.Sortable.treeTag */
treeTag: 'ul',
/** @id MochiKit.Sortable.overlap */
overlap: 'vertical', // one of 'vertical', 'horizontal'
/** @id MochiKit.Sortable.constraint */
constraint: 'vertical', // one of 'vertical', 'horizontal', false
// also takes array of elements (or ids); or false
/** @id MochiKit.Sortable.containment */
containment: [element],
/** @id MochiKit.Sortable.handle */
handle: false, // or a CSS class
/** @id MochiKit.Sortable.only */
only: false,
/** @id MochiKit.Sortable.hoverclass */
hoverclass: null,
/** @id MochiKit.Sortable.ghosting */
ghosting: false,
/** @id MochiKit.Sortable.scroll */
scroll: false,
/** @id MochiKit.Sortable.scrollSensitivity */
scrollSensitivity: 20,
/** @id MochiKit.Sortable.scrollSpeed */
scrollSpeed: 15,
/** @id MochiKit.Sortable.format */
format: /^[^_]*_(.*)$/,
/** @id MochiKit.Sortable.onChange */
onChange: MochiKit.Base.noop,
/** @id MochiKit.Sortable.onUpdate */
onUpdate: MochiKit.Base.noop,
/** @id MochiKit.Sortable.accept */
accept: null
}, options);
// clear any old sortable with same element
self.destroy(element);
// build options for the draggables
var options_for_draggable = {
revert: true,
ghosting: options.ghosting,
scroll: options.scroll,
scrollSensitivity: options.scrollSensitivity,
scrollSpeed: options.scrollSpeed,
constraint: options.constraint,
handle: options.handle
};
if (options.starteffect) {
options_for_draggable.starteffect = options.starteffect;
}
if (options.reverteffect) {
options_for_draggable.reverteffect = options.reverteffect;
} else if (options.ghosting) {
options_for_draggable.reverteffect = function (innerelement) {
innerelement.style.top = 0;
innerelement.style.left = 0;
};
}
if (options.endeffect) {
options_for_draggable.endeffect = options.endeffect;
}
if (options.zindex) {
options_for_draggable.zindex = options.zindex;
}
// build options for the droppables
var options_for_droppable = {
overlap: options.overlap,
containment: options.containment,
hoverclass: options.hoverclass,
onhover: self.onHover,
tree: options.tree,
accept: options.accept
}
var options_for_tree = {
onhover: self.onEmptyHover,
overlap: options.overlap,
containment: options.containment,
hoverclass: options.hoverclass,
accept: options.accept
}
// fix for gecko engine
MochiKit.DOM.removeEmptyTextNodes(element);
options.draggables = [];
options.droppables = [];
// drop on empty handling
if (options.dropOnEmpty || options.tree) {
new MochiKit.DragAndDrop.Droppable(element, options_for_tree);
options.droppables.push(element);
}
MochiKit.Base.map(function (e) {
// handles are per-draggable
var handle = options.handle ?
MochiKit.DOM.getFirstElementByTagAndClassName(null,
options.handle, e) : e;
options.draggables.push(
new MochiKit.DragAndDrop.Draggable(e,
MochiKit.Base.update(options_for_draggable,
{handle: handle})));
new MochiKit.DragAndDrop.Droppable(e, options_for_droppable);
if (options.tree) {
e.treeNode = element;
}
options.droppables.push(e);
}, (self.findElements(element, options) || []));
if (options.tree) {
MochiKit.Base.map(function (e) {
new MochiKit.DragAndDrop.Droppable(e, options_for_tree);
e.treeNode = element;
options.droppables.push(e);
}, (self.findTreeElements(element, options) || []));
}
// keep reference
self.sortables[element.id] = options;
options.lastValue = self.serialize(element);
options.startHandle = MochiKit.Signal.connect(MochiKit.DragAndDrop.Draggables, 'start',
MochiKit.Base.partial(self.onStart, element));
options.endHandle = MochiKit.Signal.connect(MochiKit.DragAndDrop.Draggables, 'end',
MochiKit.Base.partial(self.onEnd, element));
},
/** @id MochiKit.Sortable.onStart */
onStart: function (element, draggable) {
var self = MochiKit.Sortable;
var options = self.options(element);
options.lastValue = self.serialize(options.element);
},
/** @id MochiKit.Sortable.onEnd */
onEnd: function (element, draggable) {
var self = MochiKit.Sortable;
self.unmark();
var options = self.options(element);
if (options.lastValue != self.serialize(options.element)) {
options.onUpdate(options.element);
}
},
// return all suitable-for-sortable elements in a guaranteed order
/** @id MochiKit.Sortable.findElements */
findElements: function (element, options) {
return MochiKit.Sortable.findChildren(
element, options.only, options.tree ? true : false, options.tag);
},
/** @id MochiKit.Sortable.findTreeElements */
findTreeElements: function (element, options) {
return MochiKit.Sortable.findChildren(
element, options.only, options.tree ? true : false, options.treeTag);
},
/** @id MochiKit.Sortable.findChildren */
findChildren: function (element, only, recursive, tagName) {
if (!element.hasChildNodes()) {
return null;
}
tagName = tagName.toUpperCase();
if (only) {
only = MochiKit.Base.flattenArray([only]);
}
var elements = [];
MochiKit.Base.map(function (e) {
if (e.tagName &&
e.tagName.toUpperCase() == tagName &&
(!only ||
MochiKit.Iter.some(only, function (c) {
return MochiKit.DOM.hasElementClass(e, c);
}))) {
elements.push(e);
}
if (recursive) {
var grandchildren = MochiKit.Sortable.findChildren(e, only, recursive, tagName);
if (grandchildren && grandchildren.length > 0) {
elements = elements.concat(grandchildren);
}
}
}, element.childNodes);
return elements;
},
/** @id MochiKit.Sortable.onHover */
onHover: function (element, dropon, overlap) {
if (MochiKit.DOM.isParent(dropon, element)) {
return;
}
var self = MochiKit.Sortable;
if (overlap > .33 && overlap < .66 && self.options(dropon).tree) {
return;
} else if (overlap > 0.5) {
self.mark(dropon, 'before');
if (dropon.previousSibling != element) {
var oldParentNode = element.parentNode;
element.style.visibility = 'hidden'; // fix gecko rendering
dropon.parentNode.insertBefore(element, dropon);
if (dropon.parentNode != oldParentNode) {
self.options(oldParentNode).onChange(element);
}
self.options(dropon.parentNode).onChange(element);
}
} else {
self.mark(dropon, 'after');
var nextElement = dropon.nextSibling || null;
if (nextElement != element) {
var oldParentNode = element.parentNode;
element.style.visibility = 'hidden'; // fix gecko rendering
dropon.parentNode.insertBefore(element, nextElement);
if (dropon.parentNode != oldParentNode) {
self.options(oldParentNode).onChange(element);
}
self.options(dropon.parentNode).onChange(element);
}
}
},
_offsetSize: function (element, type) {
if (type == 'vertical' || type == 'height') {
return element.offsetHeight;
} else {
return element.offsetWidth;
}
},
/** @id MochiKit.Sortable.onEmptyHover */
onEmptyHover: function (element, dropon, overlap) {
var oldParentNode = element.parentNode;
var self = MochiKit.Sortable;
var droponOptions = self.options(dropon);
if (!MochiKit.DOM.isParent(dropon, element)) {
var index;
var children = self.findElements(dropon, {tag: droponOptions.tag,
only: droponOptions.only});
var child = null;
if (children) {
var offset = self._offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
for (index = 0; index < children.length; index += 1) {
if (offset - self._offsetSize(children[index], droponOptions.overlap) >= 0) {
offset -= self._offsetSize(children[index], droponOptions.overlap);
} else if (offset - (self._offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
child = index + 1 < children.length ? children[index + 1] : null;
break;
} else {
child = children[index];
break;
}
}
}
dropon.insertBefore(element, child);
self.options(oldParentNode).onChange(element);
droponOptions.onChange(element);
}
},
/** @id MochiKit.Sortable.unmark */
unmark: function () {
var m = MochiKit.Sortable._marker;
if (m) {
MochiKit.Style.hideElement(m);
}
},
/** @id MochiKit.Sortable.mark */
mark: function (dropon, position) {
// mark on ghosting only
var d = MochiKit.DOM;
var self = MochiKit.Sortable;
var sortable = self.options(dropon.parentNode);
if (sortable && !sortable.ghosting) {
return;
}
if (!self._marker) {
self._marker = d.getElement('dropmarker') ||
document.createElement('DIV');
MochiKit.Style.hideElement(self._marker);
d.addElementClass(self._marker, 'dropmarker');
self._marker.style.position = 'absolute';
document.getElementsByTagName('body').item(0).appendChild(self._marker);
}
var offsets = MochiKit.Position.cumulativeOffset(dropon);
self._marker.style.left = offsets.x + 'px';
self._marker.style.top = offsets.y + 'px';
if (position == 'after') {
if (sortable.overlap == 'horizontal') {
self._marker.style.left = (offsets.x + dropon.clientWidth) + 'px';
} else {
self._marker.style.top = (offsets.y + dropon.clientHeight) + 'px';
}
}
MochiKit.Style.showElement(self._marker);
},
_tree: function (element, options, parent) {
var self = MochiKit.Sortable;
var children = self.findElements(element, options) || [];
for (var i = 0; i < children.length; ++i) {
var match = children[i].id.match(options.format);
if (!match) {
continue;
}
var child = {
id: encodeURIComponent(match ? match[1] : null),
element: element,
parent: parent,
children: [],
position: parent.children.length,
container: self._findChildrenElement(children[i], options.treeTag.toUpperCase())
}
/* Get the element containing the children and recurse over it */
if (child.container) {
self._tree(child.container, options, child)
}
parent.children.push (child);
}
return parent;
},
/* Finds the first element of the given tag type within a parent element.
Used for finding the first LI[ST] within a L[IST]I[TEM].*/
_findChildrenElement: function (element, containerTag) {
if (element && element.hasChildNodes) {
containerTag = containerTag.toUpperCase();
for (var i = 0; i < element.childNodes.length; ++i) {
if (element.childNodes[i].tagName.toUpperCase() == containerTag) {
return element.childNodes[i];
}
}
}
return null;
},
/** @id MochiKit.Sortable.tree */
tree: function (element, options) {
element = MochiKit.DOM.getElement(element);
var sortableOptions = MochiKit.Sortable.options(element);
options = MochiKit.Base.update({
tag: sortableOptions.tag,
treeTag: sortableOptions.treeTag,
only: sortableOptions.only,
name: element.id,
format: sortableOptions.format
}, options || {});
var root = {
id: null,
parent: null,
children: new Array,
container: element,
position: 0
}
return MochiKit.Sortable._tree(element, options, root);
},
/**
* Specifies the sequence for the Sortable.
* @param {Node} element Element to use as the Sortable.
* @param {Object} newSequence New sequence to use.
* @param {Object} options Options to use fro the Sortable.
*/
setSequence: function (element, newSequence, options) {
var self = MochiKit.Sortable;
var b = MochiKit.Base;
element = MochiKit.DOM.getElement(element);
options = b.update(self.options(element), options || {});
var nodeMap = {};
b.map(function (n) {
var m = n.id.match(options.format);
if (m) {
nodeMap[m[1]] = [n, n.parentNode];
}
n.parentNode.removeChild(n);
}, self.findElements(element, options));
b.map(function (ident) {
var n = nodeMap[ident];
if (n) {
n[1].appendChild(n[0]);
delete nodeMap[ident];
}
}, newSequence);
},
/* Construct a [i] index for a particular node */
_constructIndex: function (node) {
var index = '';
do {
if (node.id) {
index = '[' + node.position + ']' + index;
}
} while ((node = node.parent) != null);
return index;
},
/** @id MochiKit.Sortable.sequence */
sequence: function (element, options) {
element = MochiKit.DOM.getElement(element);
var self = MochiKit.Sortable;
var options = MochiKit.Base.update(self.options(element), options || {});
return MochiKit.Base.map(function (item) {
return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
}, MochiKit.DOM.getElement(self.findElements(element, options) || []));
},
/**
* Serializes the content of a Sortable. Useful to send this content through a XMLHTTPRequest.
* These options override the Sortable options for the serialization only.
* @param {Node} element Element to serialize.
* @param {Object} options Serialization options.
*/
serialize: function (element, options) {
element = MochiKit.DOM.getElement(element);
var self = MochiKit.Sortable;
options = MochiKit.Base.update(self.options(element), options || {});
var name = encodeURIComponent(options.name || element.id);
if (options.tree) {
return MochiKit.Base.flattenArray(MochiKit.Base.map(function (item) {
return [name + self._constructIndex(item) + "[id]=" +
encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
}, self.tree(element, options).children)).join('&');
} else {
return MochiKit.Base.map(function (item) {
return name + "[]=" + encodeURIComponent(item);
}, self.sequence(element, options)).join('&');
}
}
});
// trunk compatibility
MochiKit.Sortable.Sortable = MochiKit.Sortable;
/***
MochiKit.Test 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Test');
dojo.require('MochiKit.Base');
}
if (typeof(JSAN) != 'undefined') {
JSAN.use("MochiKit.Base", []);
}
try {
if (typeof(MochiKit.Base) == 'undefined') {
throw "";
}
} catch (e) {
throw "MochiKit.Test depends on MochiKit.Base!";
}
if (typeof(MochiKit.Test) == 'undefined') {
MochiKit.Test = {};
}
MochiKit.Test.NAME = "MochiKit.Test";
MochiKit.Test.VERSION = "1.4";
MochiKit.Test.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
MochiKit.Test.toString = function () {
return this.__repr__();
};
MochiKit.Test.EXPORT = ["runTests"];
MochiKit.Test.EXPORT_OK = [];
MochiKit.Test.runTests = function (obj) {
if (typeof(obj) == "string") {
obj = JSAN.use(obj);
}
var suite = new MochiKit.Test.Suite();
suite.run(obj);
};
MochiKit.Test.Suite = function () {
this.testIndex = 0;
MochiKit.Base.bindMethods(this);
};
MochiKit.Test.Suite.prototype = {
run: function (obj) {
try {
obj(this);
} catch (e) {
this.traceback(e);
}
},
traceback: function (e) {
var items = MochiKit.Iter.sorted(MochiKit.Base.items(e));
print("not ok " + this.testIndex + " - Error thrown");
for (var i = 0; i < items.length; i++) {
var kv = items[i];
if (kv[0] == "stack") {
kv[1] = kv[1].split(/\n/)[0];
}
this.print("# " + kv.join(": "));
}
},
print: function (s) {
print(s);
},
is: function (got, expected, /* optional */message) {
var res = 1;
var msg = null;
try {
res = MochiKit.Base.compare(got, expected);
} catch (e) {
msg = "Can not compare " + typeof(got) + ":" + typeof(expected);
}
if (res) {
msg = "Expected value did not compare equal";
}
if (!res) {
return this.testResult(true, message);
}
return this.testResult(false, message,
[[msg], ["got:", got], ["expected:", expected]]);
},
testResult: function (pass, msg, failures) {
this.testIndex += 1;
if (pass) {
this.print("ok " + this.testIndex + " - " + msg);
return;
}
this.print("not ok " + this.testIndex + " - " + msg);
if (failures) {
for (var i = 0; i < failures.length; i++) {
this.print("# " + failures[i].join(" "));
}
}
},
isDeeply: function (got, expected, /* optional */message) {
var m = MochiKit.Base;
var res = 1;
try {
res = m.compare(got, expected);
} catch (e) {
// pass
}
if (res === 0) {
return this.ok(true, message);
}
var gk = m.keys(got);
var ek = m.keys(expected);
gk.sort();
ek.sort();
if (m.compare(gk, ek)) {
// differing keys
var cmp = {};
var i;
for (i = 0; i < gk.length; i++) {
cmp[gk[i]] = "got";
}
for (i = 0; i < ek.length; i++) {
if (ek[i] in cmp) {
delete cmp[ek[i]];
} else {
cmp[ek[i]] = "expected";
}
}
var diffkeys = m.keys(cmp);
diffkeys.sort();
var gotkeys = [];
var expkeys = [];
while (diffkeys.length) {
var k = diffkeys.shift();
if (k in Object.prototype) {
continue;
}
(cmp[k] == "got" ? gotkeys : expkeys).push(k);
}
}
return this.testResult((!res), msg,
(msg ? [["got:", got], ["expected:", expected]] : undefined)
);
},
ok: function (res, message) {
return this.testResult(res, message);
}
};
MochiKit.Test.__new__ = function () {
var m = MochiKit.Base;
this.EXPORT_TAGS = {
":common": this.EXPORT,
":all": m.concat(this.EXPORT, this.EXPORT_OK)
};
m.nameFunctions(this);
};
MochiKit.Test.__new__();
MochiKit.Base._exportSymbols(this, MochiKit.Test);