)((\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 (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);
+ }
+ }
+};
+
diff --git a/thirdpartyjs/MochiKit/DOM.js b/thirdpartyjs/MochiKit/DOM.js
index 0449ccd..a2cdf47 100644
--- a/thirdpartyjs/MochiKit/DOM.js
+++ b/thirdpartyjs/MochiKit/DOM.js
@@ -1,6 +1,6 @@
/***
-MochiKit.DOM 1.3.1
+MochiKit.DOM 1.4
See for documentation, downloads, license, etc.
@@ -10,18 +10,18 @@ See for documentation, downloads, license, etc.
if (typeof(dojo) != 'undefined') {
dojo.provide("MochiKit.DOM");
- dojo.require("MochiKit.Iter");
+ dojo.require("MochiKit.Base");
}
if (typeof(JSAN) != 'undefined') {
- JSAN.use("MochiKit.Iter", []);
+ JSAN.use("MochiKit.Base", []);
}
try {
- if (typeof(MochiKit.Iter) == 'undefined') {
+ if (typeof(MochiKit.Base) == 'undefined') {
throw "";
}
} catch (e) {
- throw "MochiKit.DOM depends on MochiKit.Iter!";
+ throw "MochiKit.DOM depends on MochiKit.Base!";
}
if (typeof(MochiKit.DOM) == 'undefined') {
@@ -29,7 +29,7 @@ if (typeof(MochiKit.DOM) == 'undefined') {
}
MochiKit.DOM.NAME = "MochiKit.DOM";
-MochiKit.DOM.VERSION = "1.3.1";
+MochiKit.DOM.VERSION = "1.4";
MochiKit.DOM.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
@@ -38,6 +38,7 @@ MochiKit.DOM.toString = function () {
};
MochiKit.DOM.EXPORT = [
+ "removeEmptyTextNodes",
"formContents",
"currentWindow",
"currentDocument",
@@ -47,6 +48,7 @@ MochiKit.DOM.EXPORT = [
"coerceToDOM",
"createDOM",
"createDOMFunc",
+ "isChildNode",
"getNodeAttribute",
"setNodeAttribute",
"updateNodeAttributes",
@@ -90,7 +92,6 @@ MochiKit.DOM.EXPORT = [
"IMG",
"getElement",
"$",
- "computedStyle",
"getElementsByTagAndClassName",
"addToCallStack",
"addLoadEvent",
@@ -104,248 +105,60 @@ MochiKit.DOM.EXPORT = [
"escapeHTML",
"toHTML",
"emitHTML",
- "setDisplayForElement",
- "hideElement",
- "showElement",
"scrapeText",
- "elementDimensions",
- "elementPosition",
- "setElementDimensions",
- "setElementPosition",
- "getViewportDimensions",
- "setOpacity"
+ "isParent",
+ "makeClipping",
+ "undoClipping",
+ "makePositioned",
+ "undoPositioned",
+ "getFirstElementByTagAndClassName"
];
MochiKit.DOM.EXPORT_OK = [
"domConverters"
];
-MochiKit.DOM.Dimensions = function (w, h) {
- this.w = w;
- this.h = h;
-};
-
-MochiKit.DOM.Dimensions.prototype.repr = function () {
- var repr = MochiKit.Base.repr;
- return "{w: " + repr(this.w) + ", h: " + repr(this.h) + "}";
-};
-
-MochiKit.DOM.Coordinates = function (x, y) {
- this.x = x;
- this.y = y;
-};
-
-MochiKit.DOM.Coordinates.prototype.repr = function () {
- var repr = MochiKit.Base.repr;
- return "{x: " + repr(this.x) + ", y: " + repr(this.y) + "}";
-};
+MochiKit.DOM.DEPRECATED = [
+ ['computedStyle', 'MochiKit.Style.computedStyle', '1.4'],
+ /** @id MochiKit.DOM.elementDimensions */
+ ['elementDimensions', 'MochiKit.Style.getElementDimensions', '1.4'],
+ /** @id MochiKit.DOM.elementPosition */
+ ['elementPosition', 'MochiKit.Style.getElementPosition', '1.4'],
+ ['hideElement', 'MochiKit.Style.hideElement', '1.4'],
+ /** @id MochiKit.DOM.setElementDimensions */
+ ['setElementDimensions', 'MochiKit.Style.setElementDimensions', '1.4'],
+ /** @id MochiKit.DOM.setElementPosition */
+ ['setElementPosition', 'MochiKit.Style.setElementPosition', '1.4'],
+ ['setDisplayForElement', 'MochiKit.Style.setDisplayForElement', '1.4'],
+ /** @id MochiKit.DOM.setOpacity */
+ ['setOpacity', 'MochiKit.Style.setOpacity', '1.4'],
+ ['showElement', 'MochiKit.Style.showElement', '1.4'],
+ /** @id MochiKit.DOM.Coordinates */
+ ['Coordinates', 'MochiKit.Style.Coordinates', '1.4'], // FIXME: broken
+ /** @id MochiKit.DOM.Dimensions */
+ ['Dimensions', 'MochiKit.Style.Dimensions', '1.4'] // FIXME: broken
+];
-MochiKit.DOM.Coordinates.prototype.toString = function () {
- return this.repr();
-};
+/** @id MochiKit.DOM.getViewportDimensions */
+MochiKit.DOM.getViewportDimensions = new Function('' +
+ 'if (!MochiKit["Style"]) {' +
+ ' throw new Error("This function has been deprecated and depends on MochiKit.Style.");' +
+ '}' +
+ 'return MochiKit.Style.getViewportDimensions.apply(this, arguments);');
MochiKit.Base.update(MochiKit.DOM, {
- setOpacity: function(elem, o) {
- elem = MochiKit.DOM.getElement(elem);
- MochiKit.DOM.updateNodeAttributes(elem, {'style': {
- 'opacity': o,
- '-moz-opacity': o,
- '-khtml-opacity': o,
- 'filter':' alpha(opacity=' + (o * 100) + ')'
- }});
- },
-
- getViewportDimensions: function() {
- var d = new MochiKit.DOM.Dimensions();
-
- var w = MochiKit.DOM._window;
- var b = MochiKit.DOM._document.body;
-
- if (w.innerWidth) {
- d.w = w.innerWidth;
- d.h = w.innerHeight;
- } else if (b.parentElement.clientWidth) {
- d.w = b.parentElement.clientWidth;
- d.h = b.parentElement.clientHeight;
- } else if (b && b.clientWidth) {
- d.w = b.clientWidth;
- d.h = b.clientHeight;
- }
- return d;
- },
-
- elementDimensions: function (elem) {
- var self = MochiKit.DOM;
- if (typeof(elem.w) == 'number' || typeof(elem.h) == 'number') {
- return new self.Dimensions(elem.w || 0, elem.h || 0);
- }
- elem = self.getElement(elem);
- if (!elem) {
- return undefined;
- }
- if (self.computedStyle(elem, 'display') != 'none') {
- return new self.Dimensions(elem.offsetWidth || 0,
- elem.offsetHeight || 0);
- }
- var s = elem.style;
- var originalVisibility = s.visibility;
- var originalPosition = s.position;
- s.visibility = 'hidden';
- s.position = 'absolute';
- s.display = '';
- var originalWidth = elem.offsetWidth;
- var originalHeight = elem.offsetHeight;
- s.display = 'none';
- s.position = originalPosition;
- s.visibility = originalVisibility;
- return new self.Dimensions(originalWidth, originalHeight);
- },
-
- /*
-
- elementPosition is adapted from YAHOO.util.Dom.getXY, version 0.9.0.
- Copyright: Copyright (c) 2006, Yahoo! Inc. All rights reserved.
- License: BSD, http://developer.yahoo.net/yui/license.txt
-
- */
- elementPosition: function (elem, /* optional */relativeTo) {
- var self = MochiKit.DOM;
- elem = self.getElement(elem);
-
- if (!elem) {
- return undefined;
- }
-
- var c = new self.Coordinates(0, 0);
-
- if (elem.x && elem.y) {
- /* it's just a MochiKit.DOM.Coordinates object */
- c.x += elem.x || 0;
- c.y += elem.y || 0;
- return c;
- } else if (elem.parentNode === null || self.computedStyle(elem, 'display') == 'none') {
- return undefined;
- }
-
- var box = null;
- var parent = null;
-
- var d = MochiKit.DOM._document;
- var de = d.documentElement;
- var b = d.body;
-
- if (elem.getBoundingClientRect) { // IE shortcut
-
- /*
-
- The IE shortcut is off by two:
- http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
-
- */
- box = elem.getBoundingClientRect();
-
- c.x += box.left +
- (de.scrollLeft || b.scrollLeft) -
- (de.clientLeft || b.clientLeft);
-
- c.y += box.top +
- (de.scrollTop || b.scrollTop) -
- (de.clientTop || b.clientTop);
-
- } else if (d.getBoxObjectFor) { // Gecko shortcut
- box = d.getBoxObjectFor(elem);
- c.x += box.x;
- c.y += box.y;
- } else if (elem.offsetParent) {
- c.x += elem.offsetLeft;
- c.y += elem.offsetTop;
- parent = elem.offsetParent;
-
- if (parent != elem) {
- while (parent) {
- c.x += parent.offsetLeft;
- c.y += parent.offsetTop;
- parent = parent.offsetParent;
- }
- }
-
- /*
-
- Opera < 9 and old Safari (absolute) incorrectly account for
- body offsetTop and offsetLeft.
-
- */
- var ua = navigator.userAgent.toLowerCase();
- if ((typeof(opera) != "undefined" &&
- parseFloat(opera.version()) < 9) ||
- (ua.indexOf('safari') != -1 &&
- self.computedStyle(elem, 'position') == 'absolute')) {
-
- c.x -= b.offsetLeft;
- c.y -= b.offsetTop;
-
- }
- }
-
- if (typeof(relativeTo) != 'undefined') {
- relativeTo = arguments.callee(relativeTo);
- if (relativeTo) {
- c.x -= (relativeTo.x || 0);
- c.y -= (relativeTo.y || 0);
- }
- }
-
- if (elem.parentNode) {
- parent = elem.parentNode;
- } else {
- parent = null;
- }
-
- while (parent && parent.tagName != 'BODY' &&
- parent.tagName != 'HTML') {
- c.x -= parent.scrollLeft;
- c.y -= parent.scrollTop;
- if (parent.parentNode) {
- parent = parent.parentNode;
- } else {
- parent = null;
- }
- }
-
- return c;
- },
-
- setElementDimensions: function (elem, newSize/* optional */, units) {
- elem = MochiKit.DOM.getElement(elem);
- if (typeof(units) == 'undefined') {
- units = 'px';
- }
- MochiKit.DOM.updateNodeAttributes(elem, {'style': {
- 'width': newSize.w + units,
- 'height': newSize.h + units
- }});
- },
-
- setElementPosition: function (elem, newPos/* optional */, units) {
- elem = MochiKit.DOM.getElement(elem);
- if (typeof(units) == 'undefined') {
- units = 'px';
- }
- MochiKit.DOM.updateNodeAttributes(elem, {'style': {
- 'left': newPos.x + units,
- 'top': newPos.y + units
- }});
- },
-
+ /** @id MochiKit.DOM.currentWindow */
currentWindow: function () {
return MochiKit.DOM._window;
},
+ /** @id MochiKit.DOM.currentDocument */
currentDocument: function () {
return MochiKit.DOM._document;
},
+ /** @id MochiKit.DOM.withWindow */
withWindow: function (win, func) {
var self = MochiKit.DOM;
var oldDoc = self._document;
@@ -365,6 +178,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return rval;
},
+ /** @id MochiKit.DOM.formContents */
formContents: function (elem/* = document */) {
var names = [];
var values = [];
@@ -378,27 +192,45 @@ MochiKit.Base.update(MochiKit.DOM, {
m.nodeWalk(elem, function (elem) {
var name = elem.name;
if (m.isNotEmpty(name)) {
- var tagName = elem.nodeName;
- if (tagName == "INPUT"
+ var tagName = elem.tagName.toUpperCase();
+ if (tagName === "INPUT"
&& (elem.type == "radio" || elem.type == "checkbox")
&& !elem.checked
) {
return null;
}
- if (tagName == "SELECT") {
- if (elem.selectedIndex >= 0) {
- var opt = elem.options[elem.selectedIndex];
+ if (tagName === "SELECT") {
+ if (elem.type == "select-one") {
+ if (elem.selectedIndex >= 0) {
+ var opt = elem.options[elem.selectedIndex];
+ names.push(name);
+ values.push(opt.value);
+ return null;
+ }
+ // no form elements?
names.push(name);
- values.push((opt.value) ? opt.value : opt.text);
+ values.push("");
+ return null;
+ } else {
+ var opts = elem.options;
+ if (!opts.length) {
+ names.push(name);
+ values.push("");
+ return null;
+ }
+ for (var i = 0; i < opts.length; i++) {
+ var opt = opts[i];
+ if (!opt.selected) {
+ continue;
+ }
+ names.push(name);
+ values.push(opt.value);
+ }
return null;
}
- // no form elements?
- names.push(name);
- values.push("");
- return null;
}
- if (tagName == "FORM" || tagName == "P" || tagName == "SPAN"
- || tagName == "DIV"
+ if (tagName === "FORM" || tagName === "P" || tagName === "SPAN"
+ || tagName === "DIV"
) {
return elem.childNodes;
}
@@ -411,6 +243,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return [names, values];
},
+ /** @id MochiKit.DOM.withDocument */
withDocument: function (doc, func) {
var self = MochiKit.DOM;
var oldDoc = self._document;
@@ -426,19 +259,24 @@ MochiKit.Base.update(MochiKit.DOM, {
return rval;
},
+ /** @id MochiKit.DOM.registerDOMConverter */
registerDOMConverter: function (name, check, wrap, /* optional */override) {
MochiKit.DOM.domConverters.register(name, check, wrap, override);
},
+ /** @id MochiKit.DOM.coerceToDOM */
coerceToDOM: function (node, ctx) {
+ var m = MochiKit.Base;
var im = MochiKit.Iter;
var self = MochiKit.DOM;
- var iter = im.iter;
- var repeat = im.repeat;
- var imap = im.imap;
+ if (im) {
+ var iter = im.iter;
+ var repeat = im.repeat;
+ var map = m.map;
+ }
var domConverters = self.domConverters;
- var coerceToDOM = self.coerceToDOM;
- var NotFound = MochiKit.Base.NotFound;
+ var coerceToDOM = arguments.callee;
+ var NotFound = m.NotFound;
while (true) {
if (typeof(node) == 'undefined' || node === null) {
return null;
@@ -453,28 +291,30 @@ MochiKit.Base.update(MochiKit.DOM, {
if (typeof(node) == 'string') {
return self._document.createTextNode(node);
}
- if (typeof(node.toDOM) == 'function') {
- node = node.toDOM(ctx);
+ if (typeof(node.__dom__) == 'function') {
+ node = node.__dom__(ctx);
+ continue;
+ }
+ if (typeof(node.dom) == 'function') {
+ node = node.dom(ctx);
continue;
}
if (typeof(node) == 'function') {
- node = node(ctx);
+ node = node.apply(ctx, [ctx]);
continue;
}
- // iterable
- var iterNodes = null;
- try {
- iterNodes = iter(node);
- } catch (e) {
- // pass
- }
- if (iterNodes) {
- return imap(
- coerceToDOM,
- iterNodes,
- repeat(ctx)
- );
+ if (im) {
+ // iterable
+ var iterNodes = null;
+ try {
+ iterNodes = iter(node);
+ } catch (e) {
+ // pass
+ }
+ if (iterNodes) {
+ return map(coerceToDOM, iterNodes, repeat(ctx));
+ }
}
// adapter
@@ -494,6 +334,28 @@ MochiKit.Base.update(MochiKit.DOM, {
return undefined;
},
+ /** @id MochiKit.DOM.isChildNode */
+ isChildNode: function (node, maybeparent) {
+ var self = MochiKit.DOM;
+ if (typeof(node) == "string") {
+ node = self.getElement(node);
+ }
+ if (typeof(maybeparent) == "string") {
+ maybeparent = self.getElement(maybeparent);
+ }
+ if (node === maybeparent) {
+ return true;
+ }
+ while (node && node.tagName.toUpperCase() != "BODY") {
+ node = node.parentNode;
+ if (node === maybeparent) {
+ return true;
+ }
+ }
+ return false;
+ },
+
+ /** @id MochiKit.DOM.setNodeAttribute */
setNodeAttribute: function (node, attr, value) {
var o = {};
o[attr] = value;
@@ -505,6 +367,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return null;
},
+ /** @id MochiKit.DOM.getNodeAttribute */
getNodeAttribute: function (node, attr) {
var self = MochiKit.DOM;
var rename = self.attributeArray.renames[attr];
@@ -520,6 +383,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return null;
},
+ /** @id MochiKit.DOM.updateNodeAttributes */
updateNodeAttributes: function (node, attrs) {
var elem = node;
var self = MochiKit.DOM;
@@ -570,6 +434,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return elem;
},
+ /** @id MochiKit.DOM.appendChildNodes */
appendChildNodes: function (node/*, nodes...*/) {
var elem = node;
var self = MochiKit.DOM;
@@ -596,6 +461,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return elem;
},
+ /** @id MochiKit.DOM.replaceChildNodes */
replaceChildNodes: function (node/*, nodes...*/) {
var elem = node;
var self = MochiKit.DOM;
@@ -614,14 +480,8 @@ MochiKit.Base.update(MochiKit.DOM, {
}
},
+ /** @id MochiKit.DOM.createDOM */
createDOM: function (name, attrs/*, nodes... */) {
- /*
-
- Create a DOM fragment in a really convenient manner, much like
- Nevow's stan.
-
- */
-
var elem;
var self = MochiKit.DOM;
var m = MochiKit.Base;
@@ -631,12 +491,27 @@ MochiKit.Base.update(MochiKit.DOM, {
}
if (typeof(name) == 'string') {
// Internet Explorer is dumb
- if (attrs && "name" in attrs && !self.attributeArray.compliant) {
+ var xhtml = self._xhtml;
+ if (attrs && !self.attributeArray.compliant) {
// http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/name_2.asp
- name = ('<' + name + ' name="' + self.escapeHTML(attrs.name)
- + '">');
+ var contents = "";
+ if ('name' in attrs) {
+ contents += ' name="' + self.escapeHTML(attrs.name) + '"';
+ }
+ if (name == 'input' && 'type' in attrs) {
+ contents += ' type="' + self.escapeHTML(attrs.type) + '"';
+ }
+ if (contents) {
+ name = "<" + name + contents + ">";
+ xhtml = false;
+ }
+ }
+ var d = self._document;
+ if (xhtml && d === document) {
+ elem = d.createElementNS("http://www.w3.org/1999/xhtml", name);
+ } else {
+ elem = d.createElement(name);
}
- elem = self._document.createElement(name);
} else {
elem = name;
}
@@ -651,6 +526,7 @@ MochiKit.Base.update(MochiKit.DOM, {
}
},
+ /** @id MochiKit.DOM.createDOMFunc */
createDOMFunc: function (/* tag, attrs, *nodes */) {
var m = MochiKit.Base;
return m.partial.apply(
@@ -659,6 +535,14 @@ MochiKit.Base.update(MochiKit.DOM, {
);
},
+ /** @id MochiKit.DOM.removeElement */
+ removeElement: function (elem) {
+ var e = MochiKit.DOM.getElement(elem);
+ e.parentNode.removeChild(e);
+ return e;
+ },
+
+ /** @id MochiKit.DOM.swapDOM */
swapDOM: function (dest, src) {
var self = MochiKit.DOM;
dest = self.getElement(dest);
@@ -672,6 +556,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return src;
},
+ /** @id MochiKit.DOM.getElement */
getElement: function (id) {
var self = MochiKit.DOM;
if (arguments.length == 1) {
@@ -682,32 +567,7 @@ MochiKit.Base.update(MochiKit.DOM, {
}
},
- computedStyle: function (htmlElement, cssProperty, mozillaEquivalentCSS) {
- if (arguments.length == 2) {
- mozillaEquivalentCSS = cssProperty;
- }
- var self = MochiKit.DOM;
- var el = self.getElement(htmlElement);
- var document = self._document;
- if (!el || el == document) {
- return undefined;
- }
- if (el.currentStyle) {
- return el.currentStyle[cssProperty];
- }
- if (typeof(document.defaultView) == 'undefined') {
- return undefined;
- }
- if (document.defaultView === null) {
- return undefined;
- }
- var style = document.defaultView.getComputedStyle(el, null);
- if (typeof(style) == "undefined" || style === null) {
- return undefined;
- }
- return style.getPropertyValue(mozillaEquivalentCSS);
- },
-
+ /** @id MochiKit.DOM.getElementsByTagAndClassName */
getElementsByTagAndClassName: function (tagName, className,
/* optional */parent) {
var self = MochiKit.DOM;
@@ -727,7 +587,11 @@ MochiKit.Base.update(MochiKit.DOM, {
var elements = [];
for (var i = 0; i < children.length; i++) {
var child = children[i];
- var classNames = child.className.split(' ');
+ var cls = child.className;
+ if (!cls) {
+ continue;
+ }
+ var classNames = cls.split(' ');
for (var j = 0; j < classNames.length; j++) {
if (classNames[j] == className) {
elements.push(child);
@@ -759,6 +623,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return rval;
},
+ /** @id MochiKit.DOM.addToCallStack */
addToCallStack: function (target, path, func, once) {
var self = MochiKit.DOM;
var existing = target[path];
@@ -775,12 +640,14 @@ MochiKit.Base.update(MochiKit.DOM, {
regfunc.callStack.push(func);
},
+ /** @id MochiKit.DOM.addLoadEvent */
addLoadEvent: function (func) {
var self = MochiKit.DOM;
self.addToCallStack(self._window, "onload", func, true);
},
+ /** @id MochiKit.DOM.focusOnLoad */
focusOnLoad: function (element) {
var self = MochiKit.DOM;
self.addLoadEvent(function () {
@@ -791,6 +658,7 @@ MochiKit.Base.update(MochiKit.DOM, {
});
},
+ /** @id MochiKit.DOM.setElementClass */
setElementClass: function (element, className) {
var self = MochiKit.DOM;
var obj = self.getElement(element);
@@ -801,6 +669,7 @@ MochiKit.Base.update(MochiKit.DOM, {
}
},
+ /** @id MochiKit.DOM.toggleElementClass */
toggleElementClass: function (className/*, element... */) {
var self = MochiKit.DOM;
for (var i = 1; i < arguments.length; i++) {
@@ -811,12 +680,13 @@ MochiKit.Base.update(MochiKit.DOM, {
}
},
+ /** @id MochiKit.DOM.addElementClass */
addElementClass: function (element, className) {
var self = MochiKit.DOM;
var obj = self.getElement(element);
var cls = obj.className;
// trivial case, no className yet
- if (cls.length === 0) {
+ if (cls == undefined || cls.length === 0) {
self.setElementClass(obj, className);
return true;
}
@@ -824,7 +694,7 @@ MochiKit.Base.update(MochiKit.DOM, {
if (cls == className) {
return false;
}
- var classes = obj.className.split(" ");
+ var classes = cls.split(" ");
for (var i = 0; i < classes.length; i++) {
// already present
if (classes[i] == className) {
@@ -836,12 +706,13 @@ MochiKit.Base.update(MochiKit.DOM, {
return true;
},
+ /** @id MochiKit.DOM.removeElementClass */
removeElementClass: function (element, className) {
var self = MochiKit.DOM;
var obj = self.getElement(element);
var cls = obj.className;
// trivial case, no className yet
- if (cls.length === 0) {
+ if (cls == undefined || cls.length === 0) {
return false;
}
// other trivial case, set only to className
@@ -849,7 +720,7 @@ MochiKit.Base.update(MochiKit.DOM, {
self.setElementClass(obj, "");
return true;
}
- var classes = obj.className.split(" ");
+ var classes = cls.split(" ");
for (var i = 0; i < classes.length; i++) {
// already present
if (classes[i] == className) {
@@ -863,6 +734,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return false;
},
+ /** @id MochiKit.DOM.swapElementClass */
swapElementClass: function (element, fromClass, toClass) {
var obj = MochiKit.DOM.getElement(element);
var res = MochiKit.DOM.removeElementClass(obj, fromClass);
@@ -872,9 +744,14 @@ MochiKit.Base.update(MochiKit.DOM, {
return res;
},
+ /** @id MochiKit.DOM.hasElementClass */
hasElementClass: function (element, className/*...*/) {
var obj = MochiKit.DOM.getElement(element);
- var classes = obj.className.split(" ");
+ var cls = obj.className;
+ if (!cls) {
+ return false;
+ }
+ var classes = cls.split(" ");
for (var i = 1; i < arguments.length; i++) {
var good = false;
for (var j = 0; j < classes.length; j++) {
@@ -890,6 +767,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return true;
},
+ /** @id MochiKit.DOM.escapeHTML */
escapeHTML: function (s) {
return s.replace(/&/g, "&"
).replace(/"/g, """
@@ -897,10 +775,12 @@ MochiKit.Base.update(MochiKit.DOM, {
).replace(/>/g, ">");
},
+ /** @id MochiKit.DOM.toHTML */
toHTML: function (dom) {
return MochiKit.DOM.emitHTML(dom).join("");
},
+ /** @id MochiKit.DOM.emitHTML */
emitHTML: function (dom, /* optional */lst) {
if (typeof(lst) == 'undefined' || lst === null) {
lst = [];
@@ -920,7 +800,7 @@ MochiKit.Base.update(MochiKit.DOM, {
//
// I think it might have something to do with
// garbage collection and function calls.
- lst.push('<' + dom.nodeName.toLowerCase());
+ lst.push('<' + dom.tagName.toLowerCase());
var attributes = [];
var domAttr = attributeArray(dom);
for (var i = 0; i < domAttr.length; i++) {
@@ -944,7 +824,7 @@ MochiKit.Base.update(MochiKit.DOM, {
lst.push(">");
// queue is the FILO call stack, so we put the close tag
// on first
- queue.push("");
+ queue.push("");
var cnodes = dom.childNodes;
for (i = cnodes.length - 1; i >= 0; i--) {
queue.push(cnodes[i]);
@@ -959,17 +839,7 @@ MochiKit.Base.update(MochiKit.DOM, {
return lst;
},
- setDisplayForElement: function (display, element/*, ...*/) {
- var m = MochiKit.Base;
- var elements = m.extend(null, arguments, 1);
- MochiKit.Iter.forEach(
- m.filter(null, m.map(MochiKit.DOM.getElement, elements)),
- function (element) {
- element.style.display = display;
- }
- );
- },
-
+ /** @id MochiKit.DOM.scrapeText */
scrapeText: function (node, /* optional */asArray) {
var rval = [];
(function (node) {
@@ -989,13 +859,115 @@ MochiKit.Base.update(MochiKit.DOM, {
} else {
return rval.join("");
}
+ },
+
+ /** @id MochiKit.DOM.removeEmptyTextNodes */
+ removeEmptyTextNodes: function (element) {
+ element = MochiKit.DOM.getElement(element);
+ for (var i = 0; i < element.childNodes.length; i++) {
+ var node = element.childNodes[i];
+ if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) {
+ node.parentNode.removeChild(node);
+ }
+ }
+ },
+
+ /** @id MochiKit.DOM.makeClipping */
+ makeClipping: function (element) {
+ element = MochiKit.DOM.getElement(element);
+ var oldOverflow = element.style.overflow;
+ if ((MochiKit.Style.getStyle(element, 'overflow') || 'visible') != 'hidden') {
+ element.style.overflow = 'hidden';
+ }
+ return oldOverflow;
+ },
+
+ /** @id MochiKit.DOM.undoClipping */
+ undoClipping: function (element, overflow) {
+ element = MochiKit.DOM.getElement(element);
+ if (!overflow) {
+ return;
+ }
+ element.style.overflow = overflow;
+ },
+
+ /** @id MochiKit.DOM.makePositioned */
+ makePositioned: function (element) {
+ element = MochiKit.DOM.getElement(element);
+ var pos = MochiKit.Style.getStyle(element, 'position');
+ if (pos == 'static' || !pos) {
+ element.style.position = 'relative';
+ // Opera returns the offset relative to the positioning context,
+ // when an element is position relative but top and left have
+ // not been defined
+ if (/Opera/.test(navigator.userAgent)) {
+ element.style.top = 0;
+ element.style.left = 0;
+ }
+ }
},
+ /** @id MochiKit.DOM.undoPositioned */
+ undoPositioned: function (element) {
+ element = MochiKit.DOM.getElement(element);
+ if (element.style.position == 'relative') {
+ element.style.position = element.style.top = element.style.left = element.style.bottom = element.style.right = '';
+ }
+ },
+
+ /** @id MochiKit.DOM.getFirstElementByTagAndClassName */
+ getFirstElementByTagAndClassName: function (tagName, className,
+ /* optional */parent) {
+ var self = MochiKit.DOM;
+ if (typeof(tagName) == 'undefined' || tagName === null) {
+ tagName = '*';
+ }
+ if (typeof(parent) == 'undefined' || parent === null) {
+ parent = self._document;
+ }
+ parent = self.getElement(parent);
+ var children = (parent.getElementsByTagName(tagName)
+ || self._document.all);
+ if (typeof(className) == 'undefined' || className === null) {
+ return children[0];
+ }
+
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i];
+ var classNames = child.className.split(' ');
+ for (var j = 0; j < classNames.length; j++) {
+ if (classNames[j] == className) {
+ return child;
+ }
+ }
+ }
+ },
+
+ /** @id MochiKit.DOM.isParent */
+ isParent: function (child, element) {
+ if (!child.parentNode || child == element) {
+ return false;
+ }
+
+ if (child.parentNode == element) {
+ return true;
+ }
+
+ return MochiKit.DOM.isParent(child.parentNode, element);
+ },
__new__: function (win) {
var m = MochiKit.Base;
- this._document = document;
+ if (typeof(document) != "undefined") {
+ this._document = document;
+ var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+ this._xhtml = (document.documentElement &&
+ document.createElementNS &&
+ document.documentElement.namespaceURI === kXULNSURI);
+ } else if (MochiKit.MockDOM) {
+ this._document = MochiKit.MockDOM.document;
+ }
this._window = win;
this.domConverters = new m.AdapterRegistry();
@@ -1010,9 +982,12 @@ MochiKit.Base.update(MochiKit.DOM, {
return filter(attributeArray.ignoreAttrFilter, node.attributes);
};
attributeArray.ignoreAttr = {};
- MochiKit.Iter.forEach(__tmpElement.attributes, function (a) {
- attributeArray.ignoreAttr[a.name] = a.value;
- });
+ var attrs = __tmpElement.attributes;
+ var ignoreAttr = attributeArray.ignoreAttr;
+ for (var i = 0; i < attrs.length; i++) {
+ var a = attrs[i];
+ ignoreAttr[a.name] = a.value;
+ }
attributeArray.ignoreAttrFilter = function (a) {
return (attributeArray.ignoreAttr[a.name] != a.value);
};
@@ -1021,7 +996,10 @@ MochiKit.Base.update(MochiKit.DOM, {
"class": "className",
"checked": "defaultChecked",
"usemap": "useMap",
- "for": "htmlFor"
+ "for": "htmlFor",
+ "readonly": "readOnly",
+ "colspan": "colSpan",
+ "bgcolor": "bgColor"
};
} else {
attributeArray = function (node) {
@@ -1039,48 +1017,97 @@ MochiKit.Base.update(MochiKit.DOM, {
}
this.attributeArray = attributeArray;
+ // FIXME: this really belongs in Base, and could probably be cleaner
+ var _deprecated = function(fromModule, arr) {
+ var modules = arr[1].split('.');
+ var str = '';
+ var obj = {};
+
+ str += 'if (!MochiKit.' + modules[1] + ') { throw new Error("';
+ str += 'This function has been deprecated and depends on MochiKit.';
+ str += modules[1] + '.");}';
+ str += 'return MochiKit.' + modules[1] + '.' + arr[0];
+ str += '.apply(this, arguments);';
+
+ obj[modules[2]] = new Function(str);
+ MochiKit.Base.update(MochiKit[fromModule], obj);
+ }
+ for (var i; i < MochiKit.DOM.DEPRECATED.length; i++) {
+ _deprecated('DOM', MochiKit.DOM.DEPRECATED[i]);
+ }
// shorthand for createDOM syntax
var createDOMFunc = this.createDOMFunc;
+ /** @id MochiKit.DOM.UL */
this.UL = createDOMFunc("ul");
+ /** @id MochiKit.DOM.OL */
this.OL = createDOMFunc("ol");
+ /** @id MochiKit.DOM.LI */
this.LI = createDOMFunc("li");
+ /** @id MochiKit.DOM.TD */
this.TD = createDOMFunc("td");
+ /** @id MochiKit.DOM.TR */
this.TR = createDOMFunc("tr");
+ /** @id MochiKit.DOM.TBODY */
this.TBODY = createDOMFunc("tbody");
+ /** @id MochiKit.DOM.THEAD */
this.THEAD = createDOMFunc("thead");
+ /** @id MochiKit.DOM.TFOOT */
this.TFOOT = createDOMFunc("tfoot");
+ /** @id MochiKit.DOM.TABLE */
this.TABLE = createDOMFunc("table");
+ /** @id MochiKit.DOM.TH */
this.TH = createDOMFunc("th");
+ /** @id MochiKit.DOM.INPUT */
this.INPUT = createDOMFunc("input");
+ /** @id MochiKit.DOM.SPAN */
this.SPAN = createDOMFunc("span");
+ /** @id MochiKit.DOM.A */
this.A = createDOMFunc("a");
+ /** @id MochiKit.DOM.DIV */
this.DIV = createDOMFunc("div");
+ /** @id MochiKit.DOM.IMG */
this.IMG = createDOMFunc("img");
+ /** @id MochiKit.DOM.BUTTON */
this.BUTTON = createDOMFunc("button");
+ /** @id MochiKit.DOM.TT */
this.TT = createDOMFunc("tt");
+ /** @id MochiKit.DOM.PRE */
this.PRE = createDOMFunc("pre");
+ /** @id MochiKit.DOM.H1 */
this.H1 = createDOMFunc("h1");
+ /** @id MochiKit.DOM.H2 */
this.H2 = createDOMFunc("h2");
+ /** @id MochiKit.DOM.H3 */
this.H3 = createDOMFunc("h3");
+ /** @id MochiKit.DOM.BR */
this.BR = createDOMFunc("br");
+ /** @id MochiKit.DOM.HR */
this.HR = createDOMFunc("hr");
+ /** @id MochiKit.DOM.LABEL */
this.LABEL = createDOMFunc("label");
+ /** @id MochiKit.DOM.TEXTAREA */
this.TEXTAREA = createDOMFunc("textarea");
+ /** @id MochiKit.DOM.FORM */
this.FORM = createDOMFunc("form");
+ /** @id MochiKit.DOM.P */
this.P = createDOMFunc("p");
+ /** @id MochiKit.DOM.SELECT */
this.SELECT = createDOMFunc("select");
+ /** @id MochiKit.DOM.OPTION */
this.OPTION = createDOMFunc("option");
+ /** @id MochiKit.DOM.OPTGROUP */
this.OPTGROUP = createDOMFunc("optgroup");
+ /** @id MochiKit.DOM.LEGEND */
this.LEGEND = createDOMFunc("legend");
+ /** @id MochiKit.DOM.FIELDSET */
this.FIELDSET = createDOMFunc("fieldset");
+ /** @id MochiKit.DOM.STRONG */
this.STRONG = createDOMFunc("strong");
+ /** @id MochiKit.DOM.CANVAS */
this.CANVAS = createDOMFunc("canvas");
- this.hideElement = m.partial(this.setDisplayForElement, "none");
- this.showElement = m.partial(this.setDisplayForElement, "block");
- this.removeElement = this.swapDOM;
-
+ /** @id MochiKit.DOM.$ */
this.$ = this.getElement;
this.EXPORT_TAGS = {
@@ -1093,12 +1120,13 @@ MochiKit.Base.update(MochiKit.DOM, {
}
});
+
MochiKit.DOM.__new__(((typeof(window) == "undefined") ? this : window));
//
// XXX: Internet Explorer blows
//
-if (!MochiKit.__compat__) {
+if (MochiKit.__export__) {
withWindow = MochiKit.DOM.withWindow;
withDocument = MochiKit.DOM.withDocument;
}
diff --git a/thirdpartyjs/MochiKit/DateTime.js b/thirdpartyjs/MochiKit/DateTime.js
index b2d681a..1b517b3 100644
--- a/thirdpartyjs/MochiKit/DateTime.js
+++ b/thirdpartyjs/MochiKit/DateTime.js
@@ -1,6 +1,6 @@
/***
-MochiKit.DateTime 1.3.1
+MochiKit.DateTime 1.4
See for documentation, downloads, license, etc.
@@ -21,7 +21,7 @@ if (typeof(MochiKit.DateTime) == 'undefined') {
}
MochiKit.DateTime.NAME = "MochiKit.DateTime";
-MochiKit.DateTime.VERSION = "1.3.1";
+MochiKit.DateTime.VERSION = "1.4";
MochiKit.DateTime.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
@@ -29,6 +29,7 @@ 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) {
@@ -43,6 +44,7 @@ MochiKit.DateTime.isoDate = function (str) {
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) {
@@ -88,6 +90,7 @@ MochiKit.DateTime.isoTimestamp = function (str) {
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;
@@ -103,6 +106,7 @@ MochiKit.DateTime.toISOTime = function (date, realISO/* = false */) {
return lst.join(":");
};
+/** @id MochiKit.DateTime.toISOTimeStamp */
MochiKit.DateTime.toISOTimestamp = function (date, realISO/* = false*/) {
if (typeof(date) == "undefined" || date === null) {
return null;
@@ -115,6 +119,7 @@ MochiKit.DateTime.toISOTimestamp = function (date, realISO/* = false*/) {
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;
@@ -127,6 +132,7 @@ MochiKit.DateTime.toISODate = function (date) {
].join("-");
};
+/** @id MochiKit.DateTime.americanDate */
MochiKit.DateTime.americanDate = function (d) {
d = d + "";
if (typeof(d) != "string" || d.length === 0) {
@@ -140,6 +146,7 @@ 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;
@@ -152,6 +159,7 @@ MochiKit.DateTime.toPaddedAmericanDate = function (d) {
].join('/');
};
+/** @id MochiKit.DateTime.toAmericanDate */
MochiKit.DateTime.toAmericanDate = function (d) {
if (typeof(d) == "undefined" || d === null) {
return null;
@@ -198,7 +206,7 @@ if (typeof(MochiKit.Base) != "undefined") {
} else {
(function (globals, module) {
if ((typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
- || (typeof(MochiKit.__compat__) == 'boolean' && MochiKit.__compat__)) {
+ || (MochiKit.__export__ === false)) {
var all = module.EXPORT_TAGS[":all"];
for (var i = 0; i < all.length; i++) {
globals[all[i]] = module[all[i]];
diff --git a/thirdpartyjs/MochiKit/DragAndDrop.js b/thirdpartyjs/MochiKit/DragAndDrop.js
index e82b69b..fcd3c9c 100644
--- a/thirdpartyjs/MochiKit/DragAndDrop.js
+++ b/thirdpartyjs/MochiKit/DragAndDrop.js
@@ -160,6 +160,10 @@ MochiKit.DragAndDrop.Droppables = {
/** @id MochiKit.DragAndDrop.Droppable */
MochiKit.DragAndDrop.Droppable = function (element, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, options);
+ }
this.__init__(element, options);
};
@@ -180,12 +184,9 @@ MochiKit.DragAndDrop.Droppable.prototype = {
var d = MochiKit.DOM;
var b = MochiKit.Base;
this.element = d.getElement(element);
-
- d.addElementClass(element, 'droppable');
-
this.options = b.update({
-
- /** @id MochiKit.DragAndDrop.greedy */
+
+ /** @id MochiKit.DragAndDrop.greedy */
greedy: true,
/** @id MochiKit.DragAndDrop.hoverclass */
@@ -387,6 +388,10 @@ MochiKit.DragAndDrop.Draggables = {
/** @id MochiKit.DragAndDrop.Draggable */
MochiKit.DragAndDrop.Draggable = function (element, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, options);
+ }
this.__init__(element, options);
};
@@ -405,23 +410,23 @@ MochiKit.DragAndDrop.Draggable.prototype = {
var b = MochiKit.Base;
options = b.update({
- /** @id MochiKit.DragAndDrop.handle */
+ /** @id MochiKit.DragAndDrop.handle */
handle: false,
-
- /** @id MochiKit.DragAndDrop.starteffect */
+
+ /** @id MochiKit.DragAndDrop.starteffect */
starteffect: function (innerelement) {
this._savedOpacity = MochiKit.Style.getOpacity(innerelement) || 1.0;
new v.Opacity(innerelement, {duration:0.2, from:this._savedOpacity, to:0.7});
},
- /** @id MochiKit.DragAndDrop.reverteffect */
+ /** @id MochiKit.DragAndDrop.reverteffect */
reverteffect: function (innerelement, top_offset, left_offset) {
var dur = Math.sqrt(Math.abs(top_offset^2) +
Math.abs(left_offset^2))*0.02;
return new v.Move(innerelement,
{x: -left_offset, y: -top_offset, duration: dur});
},
-
- /** @id MochiKit.DragAndDrop.endeffect */
+
+ /** @id MochiKit.DragAndDrop.endeffect */
endeffect: function (innerelement) {
new v.Opacity(innerelement, {duration:0.2, from:0.7, to:this._savedOpacity});
},
@@ -676,11 +681,6 @@ MochiKit.DragAndDrop.Draggable.prototype = {
/** @id MochiKit.DragAndDrop.draw */
draw: function (point) {
var pos = MochiKit.Position.cumulativeOffset(this.element);
- if (this.options.ghosting) {
- var r = MochiKit.Position.realOffset(this.element);
- pos.x += r.x - MochiKit.Position.windowOffset.x;
- pos.y += r.y - MochiKit.Position.windowOffset.y;
- }
var d = this.currentDelta();
pos.x -= d[0];
pos.y -= d[1];
diff --git a/thirdpartyjs/MochiKit/Format.js b/thirdpartyjs/MochiKit/Format.js
index f835519..8890bd5 100644
--- a/thirdpartyjs/MochiKit/Format.js
+++ b/thirdpartyjs/MochiKit/Format.js
@@ -1,6 +1,6 @@
/***
-MochiKit.Format 1.3.1
+MochiKit.Format 1.4
See for documentation, downloads, license, etc.
@@ -21,7 +21,7 @@ if (typeof(MochiKit.Format) == 'undefined') {
}
MochiKit.Format.NAME = "MochiKit.Format";
-MochiKit.Format.VERSION = "1.3.1";
+MochiKit.Format.VERSION = "1.4";
MochiKit.Format.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
@@ -75,6 +75,7 @@ MochiKit.Format._numberFormatter = function (placeholder, header, footer, locale
};
};
+/** @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
@@ -130,6 +131,7 @@ MochiKit.Format.numberFormatter = function (pattern, placeholder/* = "" */, loca
return rval;
};
+/** @id MochiKit.Format.formatLocale */
MochiKit.Format.formatLocale = function (locale) {
if (typeof(locale) == "undefined" || locale === null) {
locale = "default";
@@ -146,6 +148,7 @@ MochiKit.Format.formatLocale = function (locale) {
}
};
+/** @id MochiKit.Format.twoDigitAverage */
MochiKit.Format.twoDigitAverage = function (numerator, denominator) {
if (denominator) {
var res = numerator / denominator;
@@ -156,6 +159,7 @@ MochiKit.Format.twoDigitAverage = function (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();
@@ -179,6 +183,7 @@ MochiKit.Format.twoDigitFloat = function (someFloat) {
}
};
+/** @id MochiKit.Format.lstrip */
MochiKit.Format.lstrip = function (str, /* optional */chars) {
str = str + "";
if (typeof(str) != "string") {
@@ -191,6 +196,7 @@ MochiKit.Format.lstrip = function (str, /* optional */chars) {
}
};
+/** @id MochiKit.Format.rstrip */
MochiKit.Format.rstrip = function (str, /* optional */chars) {
str = str + "";
if (typeof(str) != "string") {
@@ -203,11 +209,13 @@ MochiKit.Format.rstrip = function (str, /* optional */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);
@@ -217,6 +225,7 @@ MochiKit.Format.truncToFixed = function (aNumber, precision) {
return res;
};
+/** @id MochiKit.Format.roundToFixed */
MochiKit.Format.roundToFixed = function (aNumber, precision) {
return MochiKit.Format.truncToFixed(
aNumber + 0.5 * Math.pow(10, -precision),
@@ -224,6 +233,7 @@ MochiKit.Format.roundToFixed = function (aNumber, precision) {
);
};
+/** @id MochiKit.Format.percentFormat */
MochiKit.Format.percentFormat = function (someFloat) {
return MochiKit.Format.twoDigitFloat(100 * someFloat) + '%';
};
@@ -284,7 +294,7 @@ if (typeof(MochiKit.Base) != "undefined") {
} else {
(function (globals, module) {
if ((typeof(JSAN) == 'undefined' && typeof(dojo) == 'undefined')
- || (typeof(MochiKit.__compat__) == 'boolean' && MochiKit.__compat__)) {
+ || (MochiKit.__export__ === false)) {
var all = module.EXPORT_TAGS[":all"];
for (var i = 0; i < all.length; i++) {
globals[all[i]] = module[all[i]];
diff --git a/thirdpartyjs/MochiKit/Iter.js b/thirdpartyjs/MochiKit/Iter.js
index 138c796..bb3767d 100644
--- a/thirdpartyjs/MochiKit/Iter.js
+++ b/thirdpartyjs/MochiKit/Iter.js
@@ -1,12 +1,13 @@
/***
-MochiKit.Iter 1.3.1
+MochiKit.Iter 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
+
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Iter');
dojo.require('MochiKit.Base');
@@ -29,7 +30,7 @@ if (typeof(MochiKit.Iter) == 'undefined') {
}
MochiKit.Iter.NAME = "MochiKit.Iter";
-MochiKit.Iter.VERSION = "1.3.1";
+MochiKit.Iter.VERSION = "1.4";
MochiKit.Base.update(MochiKit.Iter, {
__repr__: function () {
return "[" + this.NAME + " " + this.VERSION + "]";
@@ -38,10 +39,12 @@ MochiKit.Base.update(MochiKit.Iter, {
return this.__repr__();
},
+ /** @id MochiKit.Iter.registerIteratorFactory */
registerIteratorFactory: function (name, check, iterfactory, /* optional */ override) {
MochiKit.Iter.iteratorRegistry.register(name, check, iterfactory, override);
},
+ /** @id MochiKit.Iter.iter */
iter: function (iterable, /* optional */ sentinel) {
var self = MochiKit.Iter;
if (arguments.length == 2) {
@@ -54,7 +57,16 @@ MochiKit.Base.update(MochiKit.Iter, {
return iterable;
} else if (typeof(iterable.iter) == 'function') {
return iterable.iter();
+ /*
+ } else if (typeof(iterable.__iterator__) == 'function') {
+ //
+ // XXX: We can't support JavaScript 1.7 __iterator__ directly
+ // because of Object.prototype.__iterator__
+ //
+ return iterable.__iterator__();
+ */
}
+
try {
return self.iteratorRegistry.match(iterable);
} catch (e) {
@@ -66,6 +78,7 @@ MochiKit.Base.update(MochiKit.Iter, {
}
},
+ /** @id MochiKit.Iter.count */
count: function (n) {
if (!n) {
n = 0;
@@ -78,6 +91,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.cycle */
cycle: function (p) {
var self = MochiKit.Iter;
var m = MochiKit.Base;
@@ -112,6 +126,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.repeat */
repeat: function (elem, /* optional */n) {
var m = MochiKit.Base;
if (typeof(n) == 'undefined') {
@@ -140,14 +155,17 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.next */
next: function (iterator) {
return iterator.next();
},
+ /** @id MochiKit.Iter.izip */
izip: function (p, q/*, ...*/) {
var m = MochiKit.Base;
- var next = MochiKit.Iter.next;
- var iterables = m.map(iter, arguments);
+ var self = MochiKit.Iter;
+ var next = self.next;
+ var iterables = m.map(self.iter, arguments);
return {
repr: function () { return "izip(...)"; },
toString: m.forwardCall("repr"),
@@ -155,6 +173,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.ifilter */
ifilter: function (pred, seq) {
var m = MochiKit.Base;
seq = MochiKit.Iter.iter(seq);
@@ -177,6 +196,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.ifilterfalse */
ifilterfalse: function (pred, seq) {
var m = MochiKit.Base;
seq = MochiKit.Iter.iter(seq);
@@ -199,6 +219,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.islice */
islice: function (seq/*, [start,] stop[, step] */) {
var self = MochiKit.Iter;
var m = MochiKit.Base;
@@ -237,6 +258,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.imap */
imap: function (fun, p, q/*, ...*/) {
var m = MochiKit.Base;
var self = MochiKit.Iter;
@@ -252,6 +274,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.applymap */
applymap: function (fun, seq, self) {
seq = MochiKit.Iter.iter(seq);
var m = MochiKit.Base;
@@ -264,6 +287,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.chain */
chain: function (p, q/*, ...*/) {
// dumb fast path
var self = MochiKit.Iter;
@@ -297,6 +321,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.takewhile */
takewhile: function (pred, seq) {
var self = MochiKit.Iter;
seq = self.iter(seq);
@@ -316,6 +341,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.dropwhile */
dropwhile: function (pred, seq) {
seq = MochiKit.Iter.iter(seq);
var m = MochiKit.Base;
@@ -365,6 +391,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.tee */
tee: function (iterable, n/* = 2 */) {
var rval = [];
var sync = {
@@ -373,7 +400,7 @@ MochiKit.Base.update(MochiKit.Iter, {
"max": -1,
"min": -1
};
- if (arguments.length == 1) {
+ if (arguments.length == 1 || typeof(n) == "undefined" || n === null) {
n = 2;
}
var self = MochiKit.Iter;
@@ -385,6 +412,7 @@ MochiKit.Base.update(MochiKit.Iter, {
return rval;
},
+ /** @id MochiKit.Iter.list */
list: function (iterable) {
// Fast-path for Array and Array-like
var m = MochiKit.Base;
@@ -412,6 +440,7 @@ MochiKit.Base.update(MochiKit.Iter, {
},
+ /** @id MochiKit.Iter.reduce */
reduce: function (fn, iterable, /* optional */initial) {
var i = 0;
var x = initial;
@@ -440,6 +469,7 @@ MochiKit.Base.update(MochiKit.Iter, {
return x;
},
+ /** @id MochiKit.Iter.range */
range: function (/* [start,] stop[, step] */) {
var start = 0;
var stop = 0;
@@ -475,8 +505,12 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.sum */
sum: function (iterable, start/* = 0 */) {
- var x = start || 0;
+ if (typeof(start) == "undefined" || start === null) {
+ start = 0;
+ }
+ var x = start;
var self = MochiKit.Iter;
iterable = self.iter(iterable);
try {
@@ -491,6 +525,7 @@ MochiKit.Base.update(MochiKit.Iter, {
return x;
},
+ /** @id MochiKit.Iter.exhaust */
exhaust: function (iterable) {
var self = MochiKit.Iter;
iterable = self.iter(iterable);
@@ -505,6 +540,7 @@ MochiKit.Base.update(MochiKit.Iter, {
}
},
+ /** @id MochiKit.Iter.forEach */
forEach: function (iterable, func, /* optional */self) {
var m = MochiKit.Base;
if (arguments.length > 2) {
@@ -527,6 +563,7 @@ MochiKit.Base.update(MochiKit.Iter, {
}
},
+ /** @id MochiKit.Iter.every */
every: function (iterable, func) {
var self = MochiKit.Iter;
try {
@@ -540,6 +577,7 @@ MochiKit.Base.update(MochiKit.Iter, {
}
},
+ /** @id MochiKit.Iter.sorted */
sorted: function (iterable, /* optional */cmp) {
var rval = MochiKit.Iter.list(iterable);
if (arguments.length == 1) {
@@ -549,12 +587,14 @@ MochiKit.Base.update(MochiKit.Iter, {
return rval;
},
+ /** @id MochiKit.Iter.reversed */
reversed: function (iterable) {
var rval = MochiKit.Iter.list(iterable);
rval.reverse();
return rval;
},
+ /** @id MochiKit.Iter.some */
some: function (iterable, func) {
var self = MochiKit.Iter;
try {
@@ -568,6 +608,7 @@ MochiKit.Base.update(MochiKit.Iter, {
}
},
+ /** @id MochiKit.Iter.iextend */
iextend: function (lst, iterable) {
if (MochiKit.Base.isArrayLike(iterable)) {
// fast-path for array-like
@@ -590,6 +631,7 @@ MochiKit.Base.update(MochiKit.Iter, {
return lst;
},
+ /** @id MochiKit.Iter.groupby */
groupby: function(iterable, /* optional */ keyfunc) {
var m = MochiKit.Base;
var self = MochiKit.Iter;
@@ -615,13 +657,14 @@ MochiKit.Base.update(MochiKit.Iter, {
};
var first = true;
+ var compare = m.compare;
return {
repr: function () { return "groupby(...)"; },
next: function() {
// iterator-next
// iterate until meet next group
- while (k == pk) {
+ while (compare(k, pk) === 0) {
fetch();
if (first) {
first = false;
@@ -635,7 +678,7 @@ MochiKit.Base.update(MochiKit.Iter, {
if (v == undefined) { // Is there something to eat?
fetch();
}
- if (k != pk) {
+ if (compare(k, pk) !== 0) {
throw self.StopIteration;
}
return eat();
@@ -645,6 +688,7 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.groupby_as_array */
groupby_as_array: function (iterable, /* optional */ keyfunc) {
var m = MochiKit.Base;
var self = MochiKit.Iter;
@@ -656,6 +700,7 @@ MochiKit.Base.update(MochiKit.Iter, {
var result = [];
var first = true;
var prev_key;
+ var compare = m.compare;
while (true) {
try {
var value = iterable.next();
@@ -666,7 +711,7 @@ MochiKit.Base.update(MochiKit.Iter, {
}
throw e;
}
- if (first || key != prev_key) {
+ if (first || compare(key, prev_key) !== 0) {
var values = [];
result.push([key, values]);
}
@@ -677,6 +722,7 @@ MochiKit.Base.update(MochiKit.Iter, {
return result;
},
+ /** @id MochiKit.Iter.arrayLikeIter */
arrayLikeIter: function (iterable) {
var i = 0;
return {
@@ -691,10 +737,12 @@ MochiKit.Base.update(MochiKit.Iter, {
};
},
+ /** @id MochiKit.Iter.hasIterateNext */
hasIterateNext: function (iterable) {
return (iterable && typeof(iterable.iterateNext) == "function");
},
+ /** @id MochiKit.Iter.iterateNextIter */
iterateNextIter: function (iterable) {
return {
repr: function () { return "iterateNextIter(...)"; },
@@ -753,7 +801,13 @@ MochiKit.Iter.EXPORT = [
MochiKit.Iter.__new__ = function () {
var m = MochiKit.Base;
- this.StopIteration = new m.NamedError("StopIteration");
+ // Re-use StopIteration if exists (e.g. SpiderMonkey)
+ if (typeof(StopIteration) != "undefined") {
+ this.StopIteration = StopIteration;
+ } else {
+ /** @id MochiKit.Iter.StopIteration */
+ this.StopIteration = new m.NamedError("StopIteration");
+ }
this.iteratorRegistry = new m.AdapterRegistry();
// Register the iterator factory for arrays
this.registerIteratorFactory(
@@ -782,7 +836,7 @@ MochiKit.Iter.__new__();
//
// XXX: Internet Explorer blows
//
-if (!MochiKit.__compat__) {
+if (MochiKit.__export__) {
reduce = MochiKit.Iter.reduce;
}
diff --git a/thirdpartyjs/MochiKit/Logging.js b/thirdpartyjs/MochiKit/Logging.js
index c7a0ac5..b3aed96 100644
--- a/thirdpartyjs/MochiKit/Logging.js
+++ b/thirdpartyjs/MochiKit/Logging.js
@@ -1,12 +1,13 @@
/***
-MochiKit.Logging 1.3.1
+MochiKit.Logging 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
+
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Logging');
dojo.require('MochiKit.Base');
@@ -29,7 +30,7 @@ if (typeof(MochiKit.Logging) == 'undefined') {
}
MochiKit.Logging.NAME = "MochiKit.Logging";
-MochiKit.Logging.VERSION = "1.3.1";
+MochiKit.Logging.VERSION = "1.4";
MochiKit.Logging.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
@@ -60,6 +61,7 @@ MochiKit.Logging.EXPORT_OK = [
];
+/** @id MochiKit.Logging.LogMessage */
MochiKit.Logging.LogMessage = function (num, level, info) {
this.num = num;
this.level = level;
@@ -68,6 +70,7 @@ MochiKit.Logging.LogMessage = function (num, level, info) {
};
MochiKit.Logging.LogMessage.prototype = {
+ /** @id MochiKit.Logging.LogMessage.prototype.repr */
repr: function () {
var m = MochiKit.Base;
return 'LogMessage(' +
@@ -76,10 +79,12 @@ MochiKit.Logging.LogMessage.prototype = {
[this.num, this.level, this.info]
).join(', ') + ')';
},
+ /** @id MochiKit.Logging.LogMessage.prototype.toString */
toString: MochiKit.Base.forwardCall("repr")
};
MochiKit.Base.update(MochiKit.Logging, {
+ /** @id MochiKit.Logging.logLevelAtLeast */
logLevelAtLeast: function (minLevel) {
var self = MochiKit.Logging;
if (typeof(minLevel) == 'string') {
@@ -94,6 +99,7 @@ MochiKit.Base.update(MochiKit.Logging, {
};
},
+ /** @id MochiKit.Logging.isLogMessage */
isLogMessage: function (/* ... */) {
var LogMessage = MochiKit.Logging.LogMessage;
for (var i = 0; i < arguments.length; i++) {
@@ -104,10 +110,12 @@ MochiKit.Base.update(MochiKit.Logging, {
return true;
},
+ /** @id MochiKit.Logging.compareLogMessage */
compareLogMessage: function (a, b) {
return MochiKit.Base.compare([a.level, a.info], [b.level, b.info]);
},
+ /** @id MochiKit.Logging.alertListener */
alertListener: function (msg) {
alert(
"num: " + msg.num +
@@ -118,6 +126,7 @@ MochiKit.Base.update(MochiKit.Logging, {
});
+/** @id MochiKit.Logging.Logger */
MochiKit.Logging.Logger = function (/* optional */maxSize) {
this.counter = 0;
if (typeof(maxSize) == 'undefined' || maxSize === null) {
@@ -130,24 +139,36 @@ MochiKit.Logging.Logger = function (/* optional */maxSize) {
};
MochiKit.Logging.Logger.prototype = {
+ /** @id MochiKit.Logging.Logger.prototype.clear */
clear: function () {
this._messages.splice(0, this._messages.length);
},
+ /** @id MochiKit.Logging.Logger.prototype.logToConsole */
logToConsole: function (msg) {
if (typeof(window) != "undefined" && window.console
&& window.console.log) {
- // Safari
- window.console.log(msg);
+ // Safari and FireBug 0.4
+ // Percent replacement is a workaround for cute Safari crashing bug
+ window.console.log(msg.replace(/%/g, '\uFF05'));
} else if (typeof(opera) != "undefined" && opera.postError) {
// Opera
opera.postError(msg);
} else if (typeof(printfire) == "function") {
- // FireBug
+ // FireBug 0.3 and earlier
printfire(msg);
+ } else if (typeof(Debug) != "undefined" && Debug.writeln) {
+ // IE Web Development Helper (?)
+ // http://www.nikhilk.net/Entry.aspx?id=93
+ Debug.writeln(msg);
+ } else if (typeof(debug) != "undefined" && debug.trace) {
+ // Atlas framework (?)
+ // http://www.nikhilk.net/Entry.aspx?id=93
+ debug.trace(msg);
}
},
+ /** @id MochiKit.Logging.Logger.prototype.dispatchListeners */
dispatchListeners: function (msg) {
for (var k in this.listeners) {
var pair = this.listeners[k];
@@ -158,6 +179,7 @@ MochiKit.Logging.Logger.prototype = {
}
},
+ /** @id MochiKit.Logging.Logger.prototype.addListener */
addListener: function (ident, filter, listener) {
if (typeof(filter) == 'string') {
filter = MochiKit.Logging.logLevelAtLeast(filter);
@@ -167,10 +189,12 @@ MochiKit.Logging.Logger.prototype = {
this.listeners[ident] = entry;
},
+ /** @id MochiKit.Logging.Logger.prototype.removeListener */
removeListener: function (ident) {
delete this.listeners[ident];
},
+ /** @id MochiKit.Logging.Logger.prototype.baseLog */
baseLog: function (level, message/*, ...*/) {
var msg = new MochiKit.Logging.LogMessage(
this.counter,
@@ -188,6 +212,7 @@ MochiKit.Logging.Logger.prototype = {
}
},
+ /** @id MochiKit.Logging.Logger.prototype.getMessages */
getMessages: function (howMany) {
var firstMsg = 0;
if (!(typeof(howMany) == 'undefined' || howMany === null)) {
@@ -196,6 +221,7 @@ MochiKit.Logging.Logger.prototype = {
return this._messages.slice(firstMsg);
},
+ /** @id MochiKit.Logging.Logger.prototype.getMessageText */
getMessageText: function (howMany) {
if (typeof(howMany) == 'undefined' || howMany === null) {
howMany = 30;
@@ -211,6 +237,7 @@ MochiKit.Logging.Logger.prototype = {
return '';
},
+ /** @id MochiKit.Logging.Logger.prototype.debuggingBookmarklet */
debuggingBookmarklet: function (inline) {
if (typeof(MochiKit.LoggingPane) == "undefined") {
alert(this.getMessageText());
@@ -220,7 +247,6 @@ MochiKit.Logging.Logger.prototype = {
}
};
-
MochiKit.Logging.__new__ = function () {
this.LogLevel = {
ERROR: 40,
@@ -256,10 +282,15 @@ MochiKit.Logging.__new__ = function () {
};
};
+ /** @id MochiKit.Logging.log */
this.log = connectLog('log');
+ /** @id MochiKit.Logging.logError */
this.logError = connectLog('error');
+ /** @id MochiKit.Logging.logDebug */
this.logDebug = connectLog('debug');
+ /** @id MochiKit.Logging.logFatal */
this.logFatal = connectLog('fatal');
+ /** @id MochiKit.Logging.logWarning */
this.logWarning = connectLog('warning');
this.logger = new Logger();
this.logger.useNativeConsole = true;
diff --git a/thirdpartyjs/MochiKit/LoggingPane.js b/thirdpartyjs/MochiKit/LoggingPane.js
index 5705681..7866f7f 100644
--- a/thirdpartyjs/MochiKit/LoggingPane.js
+++ b/thirdpartyjs/MochiKit/LoggingPane.js
@@ -1,12 +1,13 @@
/***
-MochiKit.LoggingPane 1.3.1
+MochiKit.LoggingPane 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
+
if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.LoggingPane');
dojo.require('MochiKit.Logging');
@@ -31,7 +32,7 @@ if (typeof(MochiKit.LoggingPane) == 'undefined') {
}
MochiKit.LoggingPane.NAME = "MochiKit.LoggingPane";
-MochiKit.LoggingPane.VERSION = "1.3.1";
+MochiKit.LoggingPane.VERSION = "1.4";
MochiKit.LoggingPane.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
@@ -40,6 +41,7 @@ MochiKit.LoggingPane.toString = function () {
return this.__repr__();
};
+/** @id MochiKit.LoggingPane.createLoggingPane */
MochiKit.LoggingPane.createLoggingPane = function (inline/* = false */) {
var m = MochiKit.LoggingPane;
inline = !(!inline);
@@ -53,7 +55,9 @@ MochiKit.LoggingPane.createLoggingPane = function (inline/* = false */) {
return m._loggingPane;
};
+/** @id MochiKit.LoggingPane.LoggingPane */
MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = MochiKit.Logging.logger */) {
+
/* Use a div if inline, pop up a window if not */
/* Create the elements */
if (typeof(logger) == "undefined" || logger === null) {
@@ -71,7 +75,7 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
}
if (!inline) {
// name the popup with the base URL for uniqueness
- var url = win.location.href.split("?")[0].replace(/[:\/.><&]/g, "_");
+ var url = win.location.href.split("?")[0].replace(/[#:\/.><&-]/g, "_");
var name = uid + "_" + url;
var nwin = win.open("", name, "dependent,resizable,height=200");
if (!nwin) {
@@ -126,6 +130,7 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
var messages = [];
var messageFilter = null;
+ /** @id MochiKit.LoggingPane.messageLevel */
var messageLevel = function (msg) {
var level = msg.level;
if (typeof(level) == "number") {
@@ -134,10 +139,12 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
return level;
};
+ /** @id MochiKit.LoggingPane.messageText */
var messageText = function (msg) {
return msg.info.join(" ");
};
+ /** @id MochiKit.LoggingPane.addMessageText */
var addMessageText = bind(function (msg) {
var level = messageLevel(msg);
var text = messageText(msg);
@@ -155,11 +162,13 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
}
}, this);
+ /** @id MochiKit.LoggingPane.addMessage */
var addMessage = function (msg) {
messages[messages.length] = msg;
addMessageText(msg);
};
+ /** @id MochiKit.LoggingPane.buildMessageFilter */
var buildMessageFilter = function () {
var levelre, infore;
try {
@@ -180,17 +189,20 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
};
};
+ /** @id MochiKit.LoggingPane.clearMessagePane */
var clearMessagePane = function () {
while (logPane.firstChild) {
logPane.removeChild(logPane.firstChild);
}
};
+ /** @id MochiKit.LoggingPane.clearMessages */
var clearMessages = function () {
messages = [];
clearMessagePane();
};
+ /** @id MochiKit.LoggingPane.closePane */
var closePane = bind(function () {
if (this.closed) {
return;
@@ -200,16 +212,19 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
MochiKit.LoggingPane._loggingPane = null;
}
this.logger.removeListener(listenerId);
-
- debugPane.loggingPane = null;
-
- if (inline) {
- debugPane.parentNode.removeChild(debugPane);
- } else {
- this.win.close();
- }
+ try {
+ try {
+ debugPane.loggingPane = null;
+ } catch(e) { logFatal("Bookmarklet was closed incorrectly."); }
+ if (inline) {
+ debugPane.parentNode.removeChild(debugPane);
+ } else {
+ this.win.close();
+ }
+ } catch(e) {}
}, this);
+ /** @id MochiKit.LoggingPane.filterMessages */
var filterMessages = function () {
clearMessagePane();
@@ -231,11 +246,13 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
};
+ /** @id MochiKit.LoggingPane.loadMessages */
var loadMessages = bind(function () {
messages = this.logger.getMessages();
filterMessages();
}, this);
+ /** @id MochiKit.LoggingPane.filterOnEnter */
var filterOnEnter = bind(function (event) {
event = event || window.event;
key = event.which || event.keyCode;
@@ -315,6 +332,7 @@ MochiKit.LoggingPane.LoggingPane = function (inline/* = false */, logger/* = Moc
this.inline = inline;
this.closePane = closePane;
this.closed = false;
+
return this;
};
diff --git a/thirdpartyjs/MochiKit/MochiKit.js b/thirdpartyjs/MochiKit/MochiKit.js
index b5335b4..f014ad9 100644
--- a/thirdpartyjs/MochiKit/MochiKit.js
+++ b/thirdpartyjs/MochiKit/MochiKit.js
@@ -1,6044 +1,153 @@
/***
- MochiKit.MochiKit 1.4 : PACKED VERSION
+MochiKit.MochiKit 1.4
- THIS FILE IS AUTOMATICALLY GENERATED. If creating patches, please
- diff against the source tree, not this file.
+See for documentation, downloads, license, etc.
- See for documentation, downloads, license, etc.
-
- (c) 2005 Bob Ippolito. All rights Reserved.
+(c) 2005 Bob Ippolito. All rights Reserved.
***/
-if(typeof (dojo)!="undefined"){
-dojo.provide("MochiKit.Base");
-}
-if(typeof (MochiKit)=="undefined"){
-MochiKit={};
-}
-if(typeof (MochiKit.Base)=="undefined"){
-MochiKit.Base={};
-}
-if(typeof (MochiKit.__export__)=="undefined"){
-MochiKit.__export__=(MochiKit.__compat__||(typeof (JSAN)=="undefined"&&typeof (dojo)=="undefined"));
-}
-MochiKit.Base.VERSION="1.4";
-MochiKit.Base.NAME="MochiKit.Base";
-MochiKit.Base.update=function(_1,_2){
-if(_1===null){
-_1={};
-}
-for(var i=1;i=0;i--){
-_15.unshift(o[i]);
-}
-}else{
-res.push(o);
-}
-}
-return res;
-},extend:function(_16,obj,_17){
-if(!_17){
-_17=0;
-}
-if(obj){
-var l=obj.length;
-if(typeof (l)!="number"){
-if(typeof (MochiKit.Iter)!="undefined"){
-obj=MochiKit.Iter.list(obj);
-l=obj.length;
-}else{
-throw new TypeError("Argument not an array-like and MochiKit.Iter not present");
-}
-}
-if(!_16){
-_16=[];
-}
-for(var i=_17;i>b;
-},zrshift:function(a,b){
-return a>>>b;
-},eq:function(a,b){
-return a==b;
-},ne:function(a,b){
-return a!=b;
-},gt:function(a,b){
-return a>b;
-},ge:function(a,b){
-return a>=b;
-},lt:function(a,b){
-return al){
-_44=l;
-}
-}
-_43=[];
-for(i=0;i<_44;i++){
-var _45=[];
-for(var j=1;j=0;i--){
-_59=[_58[i].apply(this,_59)];
-}
-return _59[0];
-};
-},bind:function(_60,_61){
-if(typeof (_60)=="string"){
-_60=_61[_60];
-}
-var _62=_60.im_func;
-var _63=_60.im_preargs;
-var _64=_60.im_self;
-var m=MochiKit.Base;
-if(typeof (_60)=="function"&&typeof (_60.apply)=="undefined"){
-_60=m._wrapDumbFunction(_60);
-}
-if(typeof (_62)!="function"){
-_62=_60;
-}
-if(typeof (_61)!="undefined"){
-_64=_61;
-}
-if(typeof (_63)=="undefined"){
-_63=[];
-}else{
-_63=_63.slice();
-}
-m.extend(_63,arguments,2);
-var _65=function(){
-var _66=arguments;
-var me=arguments.callee;
-if(me.im_preargs.length>0){
-_66=m.concat(me.im_preargs,_66);
-}
-var _61=me.im_self;
-if(!_61){
-_61=this;
-}
-return me.im_func.apply(_61,_66);
-};
-_65.im_self=_64;
-_65.im_func=_62;
-_65.im_preargs=_63;
-return _65;
-},bindMethods:function(_67){
-var _68=MochiKit.Base.bind;
-for(var k in _67){
-var _69=_67[k];
-if(typeof (_69)=="function"){
-_67[k]=_68(_69,_67);
-}
-}
-},registerComparator:function(_70,_71,_72,_73){
-MochiKit.Base.comparatorRegistry.register(_70,_71,_72,_73);
-},_primitives:{"boolean":true,"string":true,"number":true},compare:function(a,b){
-if(a==b){
-return 0;
-}
-var _74=(typeof (a)=="undefined"||a===null);
-var _75=(typeof (b)=="undefined"||b===null);
-if(_74&&_75){
-return 0;
-}else{
-if(_74){
-return -1;
-}else{
-if(_75){
-return 1;
-}
-}
-}
-var m=MochiKit.Base;
-var _76=m._primitives;
-if(!(typeof (a) in _76&&typeof (b) in _76)){
-try{
-return m.comparatorRegistry.match(a,b);
-}
-catch(e){
-if(e!=m.NotFound){
-throw e;
-}
-}
-}
-if(ab){
-return 1;
-}
-}
-var _77=m.repr;
-throw new TypeError(_77(a)+" and "+_77(b)+" can not be compared");
-},compareDateLike:function(a,b){
-return MochiKit.Base.compare(a.getTime(),b.getTime());
-},compareArrayLike:function(a,b){
-var _78=MochiKit.Base.compare;
-var _79=a.length;
-var _80=0;
-if(_79>b.length){
-_80=1;
-_79=b.length;
-}else{
-if(_79=0;i--){
-sum+=o[i];
-}
-}else{
-sum+=o;
-}
-}
-if(_115<=0){
-throw new TypeError("mean() requires at least one argument");
-}
-return sum/_115;
-},median:function(){
-var data=MochiKit.Base.flattenArguments(arguments);
-if(data.length===0){
-throw new TypeError("median() requires at least one argument");
-}
-data.sort(compare);
-if(data.length%2==0){
-var _117=data.length/2;
-return (data[_117]+data[_117-1])/2;
-}else{
-return data[(data.length-1)/2];
-}
-},findValue:function(lst,_118,_119,end){
-if(typeof (end)=="undefined"||end===null){
-end=lst.length;
-}
-if(typeof (_119)=="undefined"||_119===null){
-_119=0;
-}
-var cmp=MochiKit.Base.compare;
-for(var i=_119;i0))){
-var kv=MochiKit.DOM.formContents(_127);
-_127=kv[0];
-_128=kv[1];
-}else{
-if(arguments.length==1){
-var o=_127;
-_127=[];
-_128=[];
-for(var k in o){
-var v=o[k];
-if(typeof (v)=="function"){
-continue;
-}else{
-if(typeof (v)!="string"&&typeof (v.length)=="number"){
-for(var i=0;i=stop){
-throw self.StopIteration;
-}
-_161+=step;
-return rval;
-}};
-},imap:function(fun,p,q){
-var m=MochiKit.Base;
-var self=MochiKit.Iter;
-var _165=m.map(self.iter,m.extend(null,arguments,1));
-var map=m.map;
-var next=self.next;
-return {repr:function(){
-return "imap(...)";
-},toString:m.forwardCall("repr"),next:function(){
-return fun.apply(this,map(next,_165));
-}};
-},applymap:function(fun,seq,self){
-seq=MochiKit.Iter.iter(seq);
-var m=MochiKit.Base;
-return {repr:function(){
-return "applymap(...)";
-},toString:m.forwardCall("repr"),next:function(){
-return fun.apply(self,seq.next());
-}};
-},chain:function(p,q){
-var self=MochiKit.Iter;
-var m=MochiKit.Base;
-if(arguments.length==1){
-return self.iter(arguments[0]);
-}
-var _167=m.map(self.iter,arguments);
-return {repr:function(){
-return "chain(...)";
-},toString:m.forwardCall("repr"),next:function(){
-while(_167.length>1){
-try{
-return _167[0].next();
-}
-catch(e){
-if(e!=self.StopIteration){
-throw e;
-}
-_167.shift();
-}
-}
-if(_167.length==1){
-var arg=_167.shift();
-this.next=m.bind("next",arg);
-return this.next();
-}
-throw self.StopIteration;
-}};
-},takewhile:function(pred,seq){
-var self=MochiKit.Iter;
-seq=self.iter(seq);
-return {repr:function(){
-return "takewhile(...)";
-},toString:MochiKit.Base.forwardCall("repr"),next:function(){
-var rval=seq.next();
-if(!pred(rval)){
-this.next=function(){
-throw self.StopIteration;
+
+/** @id MochiKit.MochiKit.toString */
+MochiKit.MochiKit.toString = function () {
+ return this.__repr__();
};
-this.next();
-}
-return rval;
-}};
-},dropwhile:function(pred,seq){
-seq=MochiKit.Iter.iter(seq);
-var m=MochiKit.Base;
-var bind=m.bind;
-return {"repr":function(){
-return "dropwhile(...)";
-},"toString":m.forwardCall("repr"),"next":function(){
-while(true){
-var rval=seq.next();
-if(!pred(rval)){
-break;
-}
-}
-this.next=bind("next",seq);
-return rval;
-}};
-},_tee:function(_169,sync,_171){
-sync.pos[_169]=-1;
-var m=MochiKit.Base;
-var _172=m.listMin;
-return {repr:function(){
-return "tee("+_169+", ...)";
-},toString:m.forwardCall("repr"),next:function(){
-var rval;
-var i=sync.pos[_169];
-if(i==sync.max){
-rval=_171.next();
-sync.deque.push(rval);
-sync.max+=1;
-sync.pos[_169]+=1;
-}else{
-rval=sync.deque[i-sync.min];
-sync.pos[_169]+=1;
-if(i==sync.min&&_172(sync.pos)!=sync.min){
-sync.min+=1;
-sync.deque.shift();
-}
-}
-return rval;
-}};
-},tee:function(_173,n){
-var rval=[];
-var sync={"pos":[],"deque":[],"max":-1,"min":-1};
-if(arguments.length==1||typeof (n)=="undefined"||n===null){
-n=2;
+
+/** @id MochiKit.MochiKit.SUBMODULES */
+MochiKit.MochiKit.SUBMODULES = [
+ "Base",
+ "Iter",
+ "Logging",
+ "DateTime",
+ "Format",
+ "Async",
+ "DOM",
+ "Style",
+ "LoggingPane",
+ "Color",
+ "Signal",
+ "Position",
+ "Visual"
+];
+
+if (typeof(JSAN) != 'undefined' || typeof(dojo) != 'undefined') {
+ if (typeof(dojo) != 'undefined') {
+ dojo.provide('MochiKit.MochiKit');
+ dojo.require("MochiKit.*");
+ }
+ if (typeof(JSAN) != 'undefined') {
+ (function (lst) {
+ for (var i = 0; i < lst.length; i++) {
+ JSAN.use("MochiKit." + lst[i], []);
+ }
+ })(MochiKit.MochiKit.SUBMODULES);
+ }
+ (function () {
+ var extend = MochiKit.Base.extend;
+ var self = MochiKit.MochiKit;
+ var modules = self.SUBMODULES;
+ var EXPORT = [];
+ var EXPORT_OK = [];
+ var EXPORT_TAGS = {};
+ var i, k, m, all;
+ for (i = 0; i < modules.length; i++) {
+ m = MochiKit[modules[i]];
+ extend(EXPORT, m.EXPORT);
+ extend(EXPORT_OK, m.EXPORT_OK);
+ for (k in m.EXPORT_TAGS) {
+ EXPORT_TAGS[k] = extend(EXPORT_TAGS[k], m.EXPORT_TAGS[k]);
+ }
+ all = m.EXPORT_TAGS[":all"];
+ if (!all) {
+ all = extend(null, m.EXPORT, m.EXPORT_OK);
+ }
+ var j;
+ for (j = 0; j < all.length; j++) {
+ k = all[j];
+ self[k] = m[k];
+ }
+ }
+ self.EXPORT = EXPORT;
+ self.EXPORT_OK = EXPORT_OK;
+ self.EXPORT_TAGS = EXPORT_TAGS;
+ }());
+
+} else {
+ if (typeof(MochiKit.__compat__) == 'undefined') {
+ MochiKit.__compat__ = true;
+ }
+ (function () {
+ if (typeof(document) == "undefined") {
+ return;
+ }
+ var scripts = document.getElementsByTagName("script");
+ var kXULNSURI = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+ var base = null;
+ var baseElem = null;
+ var allScripts = {};
+ var i;
+ for (i = 0; i < scripts.length; i++) {
+ var src = scripts[i].getAttribute("src");
+ if (!src) {
+ continue;
+ }
+ allScripts[src] = true;
+ if (src.match(/MochiKit.js$/)) {
+ base = src.substring(0, src.lastIndexOf('MochiKit.js'));
+ baseElem = scripts[i];
+ }
+ }
+ if (base === null) {
+ return;
+ }
+ var modules = MochiKit.MochiKit.SUBMODULES;
+ for (var i = 0; i < modules.length; i++) {
+ if (MochiKit[modules[i]]) {
+ continue;
+ }
+ var uri = base + modules[i] + '.js';
+ if (uri in allScripts) {
+ continue;
+ }
+ if (document.documentElement &&
+ document.documentElement.namespaceURI == kXULNSURI) {
+ // XUL
+ var s = document.createElementNS(kXULNSURI, 'script');
+ s.setAttribute("id", "MochiKit_" + base + modules[i]);
+ s.setAttribute("src", uri);
+ s.setAttribute("type", "application/x-javascript");
+ baseElem.parentNode.appendChild(s);
+ } else {
+ // HTML
+ /*
+ DOM can not be used here because Safari does
+ deferred loading of scripts unless they are
+ in the document or inserted with document.write
+
+ This is not XHTML compliant. If you want XHTML
+ compliance then you must use the packed version of MochiKit
+ or include each script individually (basically unroll
+ these document.write calls into your XHTML source)
+
+ */
+ document.write('');
+ }
+ };
+ })();
}
-var self=MochiKit.Iter;
-_173=self.iter(_173);
-var _tee=self._tee;
-for(var i=0;i0&&_179>=stop)||(step<0&&_179<=stop)){
-throw MochiKit.Iter.StopIteration;
-}
-var rval=_179;
-_179+=step;
-return rval;
-},repr:function(){
-return "range("+[_179,stop,step].join(", ")+")";
-},toString:MochiKit.Base.forwardCall("repr")};
-},sum:function(_180,_181){
-if(typeof (_181)=="undefined"||_181===null){
-_181=0;
-}
-var x=_181;
-var self=MochiKit.Iter;
-_180=self.iter(_180);
-try{
-while(true){
-x+=_180.next();
-}
-}
-catch(e){
-if(e!=self.StopIteration){
-throw e;
-}
-}
-return x;
-},exhaust:function(_182){
-var self=MochiKit.Iter;
-_182=self.iter(_182);
-try{
-while(true){
-_182.next();
-}
-}
-catch(e){
-if(e!=self.StopIteration){
-throw e;
-}
-}
-},forEach:function(_183,func,self){
-var m=MochiKit.Base;
-if(arguments.length>2){
-func=m.bind(func,self);
-}
-if(m.isArrayLike(_183)){
-try{
-for(var i=0;i<_183.length;i++){
-func(_183[i]);
-}
-}
-catch(e){
-if(e!=MochiKit.Iter.StopIteration){
-throw e;
-}
-}
-}else{
-self=MochiKit.Iter;
-self.exhaust(self.imap(func,_183));
-}
-},every:function(_184,func){
-var self=MochiKit.Iter;
-try{
-self.ifilterfalse(func,_184).next();
-return false;
-}
-catch(e){
-if(e!=self.StopIteration){
-throw e;
-}
-return true;
-}
-},sorted:function(_185,cmp){
-var rval=MochiKit.Iter.list(_185);
-if(arguments.length==1){
-cmp=MochiKit.Base.compare;
-}
-rval.sort(cmp);
-return rval;
-},reversed:function(_186){
-var rval=MochiKit.Iter.list(_186);
-rval.reverse();
-return rval;
-},some:function(_187,func){
-var self=MochiKit.Iter;
-try{
-self.ifilter(func,_187).next();
-return true;
-}
-catch(e){
-if(e!=self.StopIteration){
-throw e;
-}
-return false;
-}
-},iextend:function(lst,_188){
-if(MochiKit.Base.isArrayLike(_188)){
-for(var i=0;i<_188.length;i++){
-lst.push(_188[i]);
-}
-}else{
-var self=MochiKit.Iter;
-_188=self.iter(_188);
-try{
-while(true){
-lst.push(_188.next());
-}
-}
-catch(e){
-if(e!=self.StopIteration){
-throw e;
-}
-}
-}
-return lst;
-},groupby:function(_189,_190){
-var m=MochiKit.Base;
-var self=MochiKit.Iter;
-if(arguments.length<2){
-_190=m.operator.identity;
-}
-_189=self.iter(_189);
-var pk=undefined;
-var k=undefined;
-var v;
-function fetch(){
-v=_189.next();
-k=_190(v);
-}
-function eat(){
-var ret=v;
-v=undefined;
-return ret;
-}
-var _193=true;
-var _194=m.compare;
-return {repr:function(){
-return "groupby(...)";
-},next:function(){
-while(_194(k,pk)===0){
-fetch();
-if(_193){
-_193=false;
-break;
-}
-}
-pk=k;
-return [k,{next:function(){
-if(v==undefined){
-fetch();
-}
-if(_194(k,pk)!==0){
-throw self.StopIteration;
-}
-return eat();
-}}];
-}};
-},groupby_as_array:function(_195,_196){
-var m=MochiKit.Base;
-var self=MochiKit.Iter;
-if(arguments.length<2){
-_196=m.operator.identity;
-}
-_195=self.iter(_195);
-var _197=[];
-var _198=true;
-var _199;
-var _200=m.compare;
-while(true){
-try{
-var _201=_195.next();
-var key=_196(_201);
-}
-catch(e){
-if(e==self.StopIteration){
-break;
-}
-throw e;
-}
-if(_198||_200(key,_199)!==0){
-var _202=[];
-_197.push([key,_202]);
-}
-_202.push(_201);
-_198=false;
-_199=key;
-}
-return _197;
-},arrayLikeIter:function(_203){
-var i=0;
-return {repr:function(){
-return "arrayLikeIter(...)";
-},toString:MochiKit.Base.forwardCall("repr"),next:function(){
-if(i>=_203.length){
-throw MochiKit.Iter.StopIteration;
-}
-return _203[i++];
-}};
-},hasIterateNext:function(_204){
-return (_204&&typeof (_204.iterateNext)=="function");
-},iterateNextIter:function(_205){
-return {repr:function(){
-return "iterateNextIter(...)";
-},toString:MochiKit.Base.forwardCall("repr"),next:function(){
-var rval=_205.iterateNext();
-if(rval===null||rval===undefined){
-throw MochiKit.Iter.StopIteration;
-}
-return rval;
-}};
-}});
-MochiKit.Iter.EXPORT_OK=["iteratorRegistry","arrayLikeIter","hasIterateNext","iterateNextIter",];
-MochiKit.Iter.EXPORT=["StopIteration","registerIteratorFactory","iter","count","cycle","repeat","next","izip","ifilter","ifilterfalse","islice","imap","applymap","chain","takewhile","dropwhile","tee","list","reduce","range","sum","exhaust","forEach","every","sorted","reversed","some","iextend","groupby","groupby_as_array"];
-MochiKit.Iter.__new__=function(){
-var m=MochiKit.Base;
-if(typeof (StopIteration)!="undefined"){
-this.StopIteration=StopIteration;
-}else{
-this.StopIteration=new m.NamedError("StopIteration");
-}
-this.iteratorRegistry=new m.AdapterRegistry();
-this.registerIteratorFactory("arrayLike",m.isArrayLike,this.arrayLikeIter);
-this.registerIteratorFactory("iterateNext",this.hasIterateNext,this.iterateNextIter);
-this.EXPORT_TAGS={":common":this.EXPORT,":all":m.concat(this.EXPORT,this.EXPORT_OK)};
-m.nameFunctions(this);
-};
-MochiKit.Iter.__new__();
-if(MochiKit.__export__){
-reduce=MochiKit.Iter.reduce;
-}
-MochiKit.Base._exportSymbols(this,MochiKit.Iter);
-if(typeof (dojo)!="undefined"){
-dojo.provide("MochiKit.Logging");
-dojo.require("MochiKit.Base");
-}
-if(typeof (JSAN)!="undefined"){
-JSAN.use("MochiKit.Base",[]);
-}
-try{
-if(typeof (MochiKit.Base)=="undefined"){
-throw "";
-}
-}
-catch(e){
-throw "MochiKit.Logging depends on MochiKit.Base!";
-}
-if(typeof (MochiKit.Logging)=="undefined"){
-MochiKit.Logging={};
-}
-MochiKit.Logging.NAME="MochiKit.Logging";
-MochiKit.Logging.VERSION="1.4";
-MochiKit.Logging.__repr__=function(){
-return "["+this.NAME+" "+this.VERSION+"]";
-};
-MochiKit.Logging.toString=function(){
-return this.__repr__();
-};
-MochiKit.Logging.EXPORT=["LogLevel","LogMessage","Logger","alertListener","logger","log","logError","logDebug","logFatal","logWarning"];
-MochiKit.Logging.EXPORT_OK=["logLevelAtLeast","isLogMessage","compareLogMessage"];
-MochiKit.Logging.LogMessage=function(num,_207,info){
-this.num=num;
-this.level=_207;
-this.info=info;
-this.timestamp=new Date();
-};
-MochiKit.Logging.LogMessage.prototype={repr:function(){
-var m=MochiKit.Base;
-return "LogMessage("+m.map(m.repr,[this.num,this.level,this.info]).join(", ")+")";
-},toString:MochiKit.Base.forwardCall("repr")};
-MochiKit.Base.update(MochiKit.Logging,{logLevelAtLeast:function(_209){
-var self=MochiKit.Logging;
-if(typeof (_209)=="string"){
-_209=self.LogLevel[_209];
-}
-return function(msg){
-var _211=msg.level;
-if(typeof (_211)=="string"){
-_211=self.LogLevel[_211];
-}
-return _211>=_209;
-};
-},isLogMessage:function(){
-var _212=MochiKit.Logging.LogMessage;
-for(var i=0;i=0&&this._messages.length>this.maxSize){
-this._messages.shift();
-}
-},getMessages:function(_221){
-var _222=0;
-if(!(typeof (_221)=="undefined"||_221===null)){
-_222=Math.max(0,this._messages.length-_221);
-}
-return this._messages.slice(_222);
-},getMessageText:function(_223){
-if(typeof (_223)=="undefined"||_223===null){
-_223=30;
-}
-var _224=this.getMessages(_223);
-if(_224.length){
-var lst=map(function(m){
-return "\n ["+m.num+"] "+m.level+": "+m.info.join(" ");
-},_224);
-lst.unshift("LAST "+_224.length+" MESSAGES:");
-return lst.join("");
-}
-return "";
-},debuggingBookmarklet:function(_225){
-if(typeof (MochiKit.LoggingPane)=="undefined"){
-alert(this.getMessageText());
-}else{
-MochiKit.LoggingPane.createLoggingPane(_225||false);
-}
-}};
-MochiKit.Logging.__new__=function(){
-this.LogLevel={ERROR:40,FATAL:50,WARNING:30,INFO:20,DEBUG:10};
-var m=MochiKit.Base;
-m.registerComparator("LogMessage",this.isLogMessage,this.compareLogMessage);
-var _226=m.partial;
-var _227=this.Logger;
-var _228=_227.prototype.baseLog;
-m.update(this.Logger.prototype,{debug:_226(_228,"DEBUG"),log:_226(_228,"INFO"),error:_226(_228,"ERROR"),fatal:_226(_228,"FATAL"),warning:_226(_228,"WARNING")});
-var self=this;
-var _229=function(name){
-return function(){
-self.logger[name].apply(self.logger,arguments);
-};
-};
-this.log=_229("log");
-this.logError=_229("error");
-this.logDebug=_229("debug");
-this.logFatal=_229("fatal");
-this.logWarning=_229("warning");
-this.logger=new _227();
-this.logger.useNativeConsole=true;
-this.EXPORT_TAGS={":common":this.EXPORT,":all":m.concat(this.EXPORT,this.EXPORT_OK)};
-m.nameFunctions(this);
-};
-if(typeof (printfire)=="undefined"&&typeof (document)!="undefined"&&document.createEvent&&typeof (dispatchEvent)!="undefined"){
-printfire=function(){
-printfire.args=arguments;
-var ev=document.createEvent("Events");
-ev.initEvent("printfire",false,true);
-dispatchEvent(ev);
-};
-}
-MochiKit.Logging.__new__();
-MochiKit.Base._exportSymbols(this,MochiKit.Logging);
-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__();
-};
-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}))?)?)?)?)?/;
-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*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);
-};
-MochiKit.DateTime.toISOTime=function(date,_236){
-if(typeof (date)=="undefined"||date===null){
-return null;
-}
-var hh=date.getHours();
-var mm=date.getMinutes();
-var ss=date.getSeconds();
-var lst=[((_236&&(hh<10))?"0"+hh:hh),((mm<10)?"0"+mm:mm),((ss<10)?"0"+ss:ss)];
-return lst.join(":");
-};
-MochiKit.DateTime.toISOTimestamp=function(date,_240){
-if(typeof (date)=="undefined"||date===null){
-return null;
-}
-var sep=_240?"T":" ";
-var foot=_240?"Z":"";
-if(_240){
-date=new Date(date.getTime()+(date.getTimezoneOffset()*60000));
-}
-return MochiKit.DateTime.toISODate(date)+sep+MochiKit.DateTime.toISOTime(date,_240)+foot;
-};
-MochiKit.DateTime.toISODate=function(date){
-if(typeof (date)=="undefined"||date===null){
-return null;
-}
-var _243=MochiKit.DateTime._padTwo;
-return [date.getFullYear(),_243(date.getMonth()+1),_243(date.getDate())].join("-");
-};
-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;
-};
-MochiKit.DateTime.toPaddedAmericanDate=function(d){
-if(typeof (d)=="undefined"||d===null){
-return null;
-}
-var _245=MochiKit.DateTime._padTwo;
-return [_245(d.getMonth()+1),_245(d.getDate()),d.getFullYear()].join("/");
-};
-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(){
-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){
-}
-}
-}
-};
-MochiKit.DateTime.__new__();
-if(typeof (MochiKit.Base)!="undefined"){
-MochiKit.Base._exportSymbols(this,MochiKit.DateTime);
-}else{
-(function(_246,_247){
-if((typeof (JSAN)=="undefined"&&typeof (dojo)=="undefined")||(MochiKit.__export__===false)){
-var all=_247.EXPORT_TAGS[":all"];
-for(var i=0;i_255){
-var i=_261.length-_255;
-res=fmt.separator+_261.substring(i,_261.length)+res;
-_261=_261.substring(0,i);
-}
-}
-res=_261+res;
-if(_253>0){
-while(frac.length<_256){
-frac=frac+"0";
-}
-res=res+fmt.decimal+frac;
-}
-return _257+res+_258;
-};
-};
-MochiKit.Format.numberFormatter=function(_263,_264,_265){
-if(typeof (_264)=="undefined"){
-_264="";
-}
-var _266=_263.match(/((?:[0#]+,)?[0#]+)(?:\.([0#]+))?(%)?/);
-if(!_266){
-throw TypeError("Invalid pattern");
-}
-var _267=_263.substr(0,_266.index);
-var _268=_263.substr(_266.index+_266[0].length);
-if(_267.search(/-/)==-1){
-_267=_267+"-";
-}
-var _269=_266[1];
-var frac=(typeof (_266[2])=="string"&&_266[2]!="")?_266[2]:"";
-var _270=(typeof (_266[3])=="string"&&_266[3]!="");
-var tmp=_269.split(/,/);
-var _272;
-if(typeof (_265)=="undefined"){
-_265="default";
-}
-if(tmp.length==1){
-_272=null;
-}else{
-_272=tmp[1].length;
-}
-var _273=_269.length-_269.replace(/0/g,"").length;
-var _274=frac.length-frac.replace(/0/g,"").length;
-var _275=frac.length;
-var rval=MochiKit.Format._numberFormatter(_264,_267,_268,_265,_270,_275,_273,_272,_274);
-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;
-};
-MochiKit.Format.formatLocale=function(_276){
-if(typeof (_276)=="undefined"||_276===null){
-_276="default";
-}
-if(typeof (_276)=="string"){
-var rval=MochiKit.Format.LOCALE[_276];
-if(typeof (rval)=="string"){
-rval=arguments.callee(rval);
-MochiKit.Format.LOCALE[_276]=rval;
-}
-return rval;
-}else{
-return _276;
-}
-};
-MochiKit.Format.twoDigitAverage=function(_277,_278){
-if(_278){
-var res=_277/_278;
-if(!isNaN(res)){
-return MochiKit.Format.twoDigitFloat(_277/_278);
-}
-}
-return "0";
-};
-MochiKit.Format.twoDigitFloat=function(_279){
-var sign=(_279<0?"-":"");
-var s=Math.floor(Math.abs(_279)*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;
-}
-}
-};
-MochiKit.Format.lstrip=function(str,_284){
-str=str+"";
-if(typeof (str)!="string"){
-return null;
-}
-if(!_284){
-return str.replace(/^\s+/,"");
-}else{
-return str.replace(new RegExp("^["+_284+"]+"),"");
-}
-};
-MochiKit.Format.rstrip=function(str,_285){
-str=str+"";
-if(typeof (str)!="string"){
-return null;
-}
-if(!_285){
-return str.replace(/\s+$/,"");
-}else{
-return str.replace(new RegExp("["+_285+"]+$"),"");
-}
-};
-MochiKit.Format.strip=function(str,_286){
-var self=MochiKit.Format;
-return self.rstrip(self.lstrip(str,_286),_286);
-};
-MochiKit.Format.truncToFixed=function(_287,_288){
-_287=Math.floor(_287*Math.pow(10,_288));
-var res=(_287*Math.pow(10,-_288)).toFixed(_288);
-if(res.charAt(0)=="."){
-res="0"+res;
-}
-return res;
-};
-MochiKit.Format.roundToFixed=function(_289,_290){
-return MochiKit.Format.truncToFixed(_289+0.5*Math.pow(10,-_290),_290);
-};
-MochiKit.Format.percentFormat=function(_291){
-return MochiKit.Format.twoDigitFloat(100*_291)+"%";
-};
-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:"%"},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(){
-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){
-}
-}
-}
-};
-MochiKit.Format.__new__();
-if(typeof (MochiKit.Base)!="undefined"){
-MochiKit.Base._exportSymbols(this,MochiKit.Format);
-}else{
-(function(_292,_293){
-if((typeof (JSAN)=="undefined"&&typeof (dojo)=="undefined")||(MochiKit.__export__===false)){
-var all=_293.EXPORT_TAGS[":all"];
-for(var i=0;i1){
-fn=MochiKit.Base.partial.apply(null,arguments);
-}
-return this.addCallbacks(fn,fn);
-},addCallback:function(fn){
-if(arguments.length>1){
-fn=MochiKit.Base.partial.apply(null,arguments);
-}
-return this.addCallbacks(fn,null);
-},addErrback:function(fn){
-if(arguments.length>1){
-fn=MochiKit.Base.partial.apply(null,arguments);
-}
-return this.addCallbacks(null,fn);
-},addCallbacks:function(cb,eb){
-if(this.chained){
-throw new Error("Chained Deferreds can not be re-used");
-}
-this.chain.push([cb,eb]);
-if(this.fired>=0){
-this._fire();
-}
-return this;
-},_fire:function(){
-var _298=this.chain;
-var _299=this.fired;
-var res=this.results[_299];
-var self=this;
-var cb=null;
-while(_298.length>0&&this.paused===0){
-var pair=_298.shift();
-var f=pair[_299];
-if(f===null){
-continue;
-}
-try{
-res=f(res);
-_299=((res instanceof Error)?1:0);
-if(res instanceof MochiKit.Async.Deferred){
-cb=function(res){
-self._resback(res);
-self.paused--;
-if((self.paused===0)&&(self.fired>=0)){
-self._fire();
-}
-};
-this.paused++;
-}
-}
-catch(err){
-_299=1;
-if(!(err instanceof Error)){
-err=new MochiKit.Async.GenericError(err);
-}
-res=err;
-}
-}
-this.fired=_299;
-this.results[_299]=res;
-if(cb&&this.paused){
-res.addBoth(cb);
-res.chained=true;
-}
-}};
-MochiKit.Base.update(MochiKit.Async,{evalJSONRequest:function(){
-return eval("("+arguments[0].responseText+")");
-},succeed:function(_301){
-var d=new MochiKit.Async.Deferred();
-d.callback.apply(d,arguments);
-return d;
-},fail:function(_302){
-var d=new MochiKit.Async.Deferred();
-d.errback.apply(d,arguments);
-return d;
-},getXMLHttpRequest:function(){
-var self=arguments.callee;
-if(!self.XMLHttpRequest){
-var _303=[function(){
-return new XMLHttpRequest();
-},function(){
-return new ActiveXObject("Msxml2.XMLHTTP");
-},function(){
-return new ActiveXObject("Microsoft.XMLHTTP");
-},function(){
-return new ActiveXObject("Msxml2.XMLHTTP.4.0");
-},function(){
-throw new MochiKit.Async.BrowserComplianceError("Browser does not support XMLHttpRequest");
-}];
-for(var i=0;i<_303.length;i++){
-var func=_303[i];
-try{
-self.XMLHttpRequest=func;
-return func();
-}
-catch(e){
-}
-}
-}
-return self.XMLHttpRequest();
-},_xhr_onreadystatechange:function(d){
-var m=MochiKit.Base;
-if(this.readyState==4){
-try{
-this.onreadystatechange=null;
-}
-catch(e){
-try{
-this.onreadystatechange=m.noop;
-}
-catch(e){
-}
-}
-var _304=null;
-try{
-_304=this.status;
-if(!_304&&m.isNotEmpty(this.responseText)){
-_304=304;
-}
-}
-catch(e){
-}
-if(_304==200||_304==304){
-d.callback(this);
-}else{
-var err=new MochiKit.Async.XMLHttpRequestError(this,"Request failed");
-if(err.number){
-d.errback(err);
-}else{
-d.errback(err);
-}
-}
-}
-},_xhr_canceller:function(req){
-try{
-req.onreadystatechange=null;
-}
-catch(e){
-try{
-req.onreadystatechange=MochiKit.Base.noop;
-}
-catch(e){
-}
-}
-req.abort();
-},sendXMLHttpRequest:function(req,_307){
-if(typeof (_307)=="undefined"||_307===null){
-_307="";
-}
-var m=MochiKit.Base;
-var self=MochiKit.Async;
-var d=new self.Deferred(m.partial(self._xhr_canceller,req));
-try{
-req.onreadystatechange=m.bind(self._xhr_onreadystatechange,req,d);
-req.send(_307);
-}
-catch(e){
-try{
-req.onreadystatechange=null;
-}
-catch(ignore){
-}
-d.errback(e);
-}
-return d;
-},doSimpleXMLHttpRequest:function(url){
-var self=MochiKit.Async;
-var req=self.getXMLHttpRequest();
-if(arguments.length>1){
-var m=MochiKit.Base;
-var qs=m.queryString.apply(null,m.extend(null,arguments,1));
-if(qs){
-url+="?"+qs;
-}
-}
-req.open("GET",url,true);
-return self.sendXMLHttpRequest(req);
-},loadJSONDoc:function(url){
-var self=MochiKit.Async;
-var d=self.doSimpleXMLHttpRequest.apply(self,arguments);
-d=d.addCallback(self.evalJSONRequest);
-return d;
-},wait:function(_310,_311){
-var d=new MochiKit.Async.Deferred();
-var m=MochiKit.Base;
-if(typeof (_311)!="undefined"){
-d.addCallback(function(){
-return _311;
-});
-}
-var _312=setTimeout(m.bind("callback",d),Math.floor(_310*1000));
-d.canceller=function(){
-try{
-clearTimeout(_312);
-}
-catch(e){
-}
-};
-return d;
-},callLater:function(_313,func){
-var m=MochiKit.Base;
-var _314=m.partial.apply(m,m.extend(null,arguments,1));
-return MochiKit.Async.wait(_313).addCallback(function(res){
-return _314();
-});
-}});
-MochiKit.Async.DeferredLock=function(){
-this.waiting=[];
-this.locked=false;
-this.id=this._nextId();
-};
-MochiKit.Async.DeferredLock.prototype={__class__:MochiKit.Async.DeferredLock,acquire:function(){
-var d=new MochiKit.Async.Deferred();
-if(this.locked){
-this.waiting.push(d);
-}else{
-this.locked=true;
-d.callback(this);
-}
-return d;
-},release:function(){
-if(!this.locked){
-throw TypeError("Tried to release an unlocked DeferredLock");
-}
-this.locked=false;
-if(this.waiting.length>0){
-this.locked=true;
-this.waiting.shift().callback(this);
-}
-},_nextId:MochiKit.Base.counter(),repr:function(){
-var _315;
-if(this.locked){
-_315="locked, "+this.waiting.length+" waiting";
-}else{
-_315="unlocked";
-}
-return "DeferredLock("+this.id+", "+_315+")";
-},toString:MochiKit.Base.forwardCall("repr")};
-MochiKit.Async.DeferredList=function(list,_317,_318,_319,_320){
-MochiKit.Async.Deferred.apply(this,[_320]);
-this.list=list;
-var _321=[];
-this.resultList=_321;
-this.finishedCount=0;
-this.fireOnOneCallback=_317;
-this.fireOnOneErrback=_318;
-this.consumeErrors=_319;
-var cb=MochiKit.Base.bind(this._cbDeferred,this);
-for(var i=0;i=0){
-var opt=elem.options[elem.selectedIndex];
-_335.push(name);
-_336.push(opt.value);
-return null;
-}
-_335.push(name);
-_336.push("");
-return null;
-}else{
-var opts=elem.options;
-if(!opts.length){
-_335.push(name);
-_336.push("");
-return null;
-}
-for(var i=0;i0){
-return node;
-}
-if(typeof (node)=="number"||typeof (node)=="boolean"){
-node=node.toString();
-}
-if(typeof (node)=="string"){
-return self._document.createTextNode(node);
-}
-if(typeof (node.__dom__)=="function"){
-node=node.__dom__(ctx);
-continue;
-}
-if(typeof (node.dom)=="function"){
-node=node.dom(ctx);
-continue;
-}
-if(typeof (node)=="function"){
-node=node.apply(ctx,[ctx]);
-continue;
-}
-if(im){
-var _351=null;
-try{
-_351=iter(node);
-}
-catch(e){
-}
-if(_351){
-return map(_349,_351,_347(ctx));
-}
-}
-try{
-node=_348.match(node,ctx);
-continue;
-}
-catch(e){
-if(e!=_350){
-throw e;
-}
-}
-return self._document.createTextNode(node.toString());
-}
-return undefined;
-},isChildNode:function(node,_352){
-var self=MochiKit.DOM;
-if(typeof (node)=="string"){
-node=self.getElement(node);
-}
-if(typeof (_352)=="string"){
-_352=self.getElement(_352);
-}
-if(node===_352){
-return true;
-}
-while(node&&node.tagName.toUpperCase()!="BODY"){
-node=node.parentNode;
-if(node===_352){
-return true;
-}
-}
-return false;
-},setNodeAttribute:function(node,attr,_354){
-var o={};
-o[attr]=_354;
-try{
-return MochiKit.DOM.updateNodeAttributes(node,o);
-}
-catch(e){
-}
-return null;
-},getNodeAttribute:function(node,attr){
-var self=MochiKit.DOM;
-var _355=self.attributeArray.renames[attr];
-node=self.getElement(node);
-try{
-if(_355){
-return node[_355];
-}
-return node.getAttribute(attr);
-}
-catch(e){
-}
-return null;
-},updateNodeAttributes:function(node,_356){
-var elem=node;
-var self=MochiKit.DOM;
-if(typeof (node)=="string"){
-elem=self.getElement(node);
-}
-if(_356){
-var _357=MochiKit.Base.updatetree;
-if(self.attributeArray.compliant){
-for(var k in _356){
-var v=_356[k];
-if(typeof (v)=="object"&&typeof (elem[k])=="object"){
-_357(elem[k],v);
-}else{
-if(k.substring(0,2)=="on"){
-if(typeof (v)=="string"){
-v=new Function(v);
-}
-elem[k]=v;
-}else{
-elem.setAttribute(k,v);
-}
-}
-}
-}else{
-var _358=self.attributeArray.renames;
-for(k in _356){
-v=_356[k];
-var _359=_358[k];
-if(k=="style"&&typeof (v)=="string"){
-elem.style.cssText=v;
-}else{
-if(typeof (_359)=="string"){
-elem[_359]=v;
-}else{
-if(typeof (elem[k])=="object"&&typeof (v)=="object"){
-_357(elem[k],v);
-}else{
-if(k.substring(0,2)=="on"){
-if(typeof (v)=="string"){
-v=new Function(v);
-}
-elem[k]=v;
-}else{
-elem.setAttribute(k,v);
-}
-}
-}
-}
-}
-}
-}
-return elem;
-},appendChildNodes:function(node){
-var elem=node;
-var self=MochiKit.DOM;
-if(typeof (node)=="string"){
-elem=self.getElement(node);
-}
-var _360=[self.coerceToDOM(MochiKit.Base.extend(null,arguments,1),elem)];
-var _361=MochiKit.Base.concat;
-while(_360.length){
-var n=_360.shift();
-if(typeof (n)=="undefined"||n===null){
-}else{
-if(typeof (n.nodeType)=="number"){
-elem.appendChild(n);
-}else{
-_360=_361(n,_360);
-}
-}
-}
-return elem;
-},replaceChildNodes:function(node){
-var elem=node;
-var self=MochiKit.DOM;
-if(typeof (node)=="string"){
-elem=self.getElement(node);
-arguments[0]=elem;
-}
-var _362;
-while((_362=elem.firstChild)){
-elem.removeChild(_362);
-}
-if(arguments.length<2){
-return elem;
-}else{
-return self.appendChildNodes.apply(this,arguments);
-}
-},createDOM:function(name,_363){
-var elem;
-var self=MochiKit.DOM;
-var m=MochiKit.Base;
-if(typeof (_363)=="string"||typeof (_363)=="number"){
-var args=m.extend([name,null],arguments,1);
-return arguments.callee.apply(this,args);
-}
-if(typeof (name)=="string"){
-if(_363&&!self.attributeArray.compliant){
-var _364="";
-if("name" in _363){
-_364+=" name=\""+self.escapeHTML(_363.name)+"\"";
-}
-if(name=="input"&&"type" in _363){
-_364+=" type=\""+self.escapeHTML(_363.type)+"\"";
-}
-if(_364){
-name="<"+name+_364+">";
-}
-}
-elem=self._document.createElement(name);
-}else{
-elem=name;
-}
-if(_363){
-self.updateNodeAttributes(elem,_363);
-}
-if(arguments.length<=2){
-return elem;
-}else{
-var args=m.extend([elem],arguments,2);
-return self.appendChildNodes.apply(this,args);
-}
-},createDOMFunc:function(){
-var m=MochiKit.Base;
-return m.partial.apply(this,m.extend([MochiKit.DOM.createDOM],arguments));
-},removeElement:function(elem){
-var e=MochiKit.DOM.getElement(elem);
-e.parentNode.removeChild(e);
-return e;
-},swapDOM:function(dest,src){
-var self=MochiKit.DOM;
-dest=self.getElement(dest);
-var _367=dest.parentNode;
-if(src){
-src=self.getElement(src);
-_367.replaceChild(src,dest);
-}else{
-_367.removeChild(dest);
-}
-return src;
-},getElement:function(id){
-var self=MochiKit.DOM;
-if(arguments.length==1){
-return ((typeof (id)=="string")?self._document.getElementById(id):id);
-}else{
-return MochiKit.Base.map(self.getElement,arguments);
-}
-},getElementsByTagAndClassName:function(_369,_370,_371){
-var self=MochiKit.DOM;
-if(typeof (_369)=="undefined"||_369===null){
-_369="*";
-}
-if(typeof (_371)=="undefined"||_371===null){
-_371=self._document;
-}
-_371=self.getElement(_371);
-var _372=(_371.getElementsByTagName(_369)||self._document.all);
-if(typeof (_370)=="undefined"||_370===null){
-return MochiKit.Base.extend(null,_372);
-}
-var _373=[];
-for(var i=0;i<_372.length;i++){
-var _374=_372[i];
-var cls=_374.className;
-if(!cls){
-continue;
-}
-var _376=cls.split(" ");
-for(var j=0;j<_376.length;j++){
-if(_376[j]==_370){
-_373.push(_374);
-break;
-}
-}
-}
-return _373;
-},_newCallStack:function(path,once){
-var rval=function(){
-var _379=arguments.callee.callStack;
-for(var i=0;i<_379.length;i++){
-if(_379[i].apply(this,arguments)===false){
-break;
-}
-}
-if(once){
-try{
-this[path]=null;
-}
-catch(e){
-}
-}
-};
-rval.callStack=[];
-return rval;
-},addToCallStack:function(_380,path,func,once){
-var self=MochiKit.DOM;
-var _381=_380[path];
-var _382=_381;
-if(!(typeof (_381)=="function"&&typeof (_381.callStack)=="object"&&_381.callStack!==null)){
-_382=self._newCallStack(path,once);
-if(typeof (_381)=="function"){
-_382.callStack.push(_381);
-}
-_380[path]=_382;
-}
-_382.callStack.push(func);
-},addLoadEvent:function(func){
-var self=MochiKit.DOM;
-self.addToCallStack(self._window,"onload",func,true);
-},focusOnLoad:function(_383){
-var self=MochiKit.DOM;
-self.addLoadEvent(function(){
-_383=self.getElement(_383);
-if(_383){
-_383.focus();
-}
-});
-},setElementClass:function(_384,_385){
-var self=MochiKit.DOM;
-var obj=self.getElement(_384);
-if(self.attributeArray.compliant){
-obj.setAttribute("class",_385);
-}else{
-obj.setAttribute("className",_385);
-}
-},toggleElementClass:function(_386){
-var self=MochiKit.DOM;
-for(var i=1;i/g,">");
-},toHTML:function(dom){
-return MochiKit.DOM.emitHTML(dom).join("");
-},emitHTML:function(dom,lst){
-if(typeof (lst)=="undefined"||lst===null){
-lst=[];
-}
-var _401=[dom];
-var self=MochiKit.DOM;
-var _402=self.escapeHTML;
-var _403=self.attributeArray;
-while(_401.length){
-dom=_401.pop();
-if(typeof (dom)=="string"){
-lst.push(dom);
-}else{
-if(dom.nodeType==1){
-lst.push("<"+dom.tagName.toLowerCase());
-var _404=[];
-var _405=_403(dom);
-for(var i=0;i<_405.length;i++){
-var a=_405[i];
-_404.push([" ",a.name,"=\"",_402(a.value),"\""]);
-}
-_404.sort();
-for(i=0;i<_404.length;i++){
-var _406=_404[i];
-for(var j=0;j<_406.length;j++){
-lst.push(_406[j]);
-}
-}
-if(dom.hasChildNodes()){
-lst.push(">");
-_401.push("");
-var _407=dom.childNodes;
-for(i=_407.length-1;i>=0;i--){
-_401.push(_407[i]);
-}
-}else{
-lst.push("/>");
-}
-}else{
-if(dom.nodeType==3){
-lst.push(_402(dom.nodeValue));
-}
-}
-}
-}
-return lst;
-},scrapeText:function(node,_408){
-var rval=[];
-(function(node){
-var cn=node.childNodes;
-if(cn){
-for(var i=0;i0){
-var _414=m.filter;
-_413=function(node){
-return _414(_413.ignoreAttrFilter,node.attributes);
-};
-_413.ignoreAttr={};
-var _415=_412.attributes;
-var _416=_413.ignoreAttr;
-for(var i=0;i<_415.length;i++){
-var a=_415[i];
-_416[a.name]=a.value;
-}
-_413.ignoreAttrFilter=function(a){
-return (_413.ignoreAttr[a.name]!=a.value);
-};
-_413.compliant=false;
-_413.renames={"class":"className","checked":"defaultChecked","usemap":"useMap","for":"htmlFor","readonly":"readOnly"};
-}else{
-_413=function(node){
-return node.attributes;
-};
-_413.compliant=true;
-_413.renames={};
-}
-this.attributeArray=_413;
-var _417=function(_418,arr){
-var _419=arr[1].split(".");
-var str="";
-var obj={};
-str+="if (!MochiKit."+_419[1]+") { throw new Error(\"";
-str+="This function has been deprecated and depends on MochiKit.";
-str+=_419[1]+".\");}";
-str+="return MochiKit."+_419[1]+"."+arr[0];
-str+=".apply(this, arguments);";
-obj[_419[2]]=new Function(str);
-MochiKit.Base.update(MochiKit[_418],obj);
-};
-for(var i;i<&-]/g,"_");
-var name=uid+"_"+url;
-var nwin=win.open("",name,"dependent,resizable,height=200");
-if(!nwin){
-alert("Not able to open debugging window due to pop-up blocking.");
-return undefined;
-}
-nwin.document.write(""+"[MochiKit.LoggingPane]"+"");
-nwin.document.close();
-nwin.document.title+=" "+win.document.title;
-win=nwin;
-}
-var doc=win.document;
-this.doc=doc;
-var _467=doc.getElementById(uid);
-var _468=!!_467;
-if(_467&&typeof (_467.loggingPane)!="undefined"){
-_467.loggingPane.logger=this.logger;
-_467.loggingPane.buildAndApplyFilter();
-return _467.loggingPane;
-}
-if(_468){
-var _469;
-while((_469=_467.firstChild)){
-_467.removeChild(_469);
-}
-}else{
-_467=doc.createElement("div");
-_467.id=uid;
-}
-_467.loggingPane=this;
-var _470=doc.createElement("input");
-var _471=doc.createElement("input");
-var _472=doc.createElement("button");
-var _473=doc.createElement("button");
-var _474=doc.createElement("button");
-var _475=doc.createElement("button");
-var _476=doc.createElement("div");
-var _477=doc.createElement("div");
-var _478=uid+"_Listener";
-this.colorTable=_464(this.colorTable);
-var _479=[];
-var _480=null;
-var _481=function(msg){
-var _482=msg.level;
-if(typeof (_482)=="number"){
-_482=MochiKit.Logging.LogLevel[_482];
-}
-return _482;
-};
-var _483=function(msg){
-return msg.info.join(" ");
-};
-var _484=bind(function(msg){
-var _485=_481(msg);
-var text=_483(msg);
-var c=this.colorTable[_485];
-var p=doc.createElement("span");
-p.className="MochiKit-LogMessage MochiKit-LogLevel-"+_485;
-p.style.cssText="margin: 0px; white-space: -moz-pre-wrap; white-space: -o-pre-wrap; white-space: pre-wrap; white-space: pre-line; word-wrap: break-word; wrap-option: emergency; color: "+c;
-p.appendChild(doc.createTextNode(_485+": "+text));
-_477.appendChild(p);
-_477.appendChild(doc.createElement("br"));
-if(_476.offsetHeight>_476.scrollHeight){
-_476.scrollTop=0;
-}else{
-_476.scrollTop=_476.scrollHeight;
-}
-},this);
-var _487=function(msg){
-_479[_479.length]=msg;
-_484(msg);
-};
-var _488=function(){
-var _489,infore;
-try{
-_489=new RegExp(_470.value);
-infore=new RegExp(_471.value);
-}
-catch(e){
-logDebug("Error in filter regex: "+e.message);
-return null;
-}
-return function(msg){
-return (_489.test(_481(msg))&&infore.test(_483(msg)));
-};
-};
-var _490=function(){
-while(_477.firstChild){
-_477.removeChild(_477.firstChild);
-}
-};
-var _491=function(){
-_479=[];
-_490();
-};
-var _492=bind(function(){
-if(this.closed){
-return;
-}
-this.closed=true;
-if(MochiKit.LoggingPane._loggingPane==this){
-MochiKit.LoggingPane._loggingPane=null;
-}
-this.logger.removeListener(_478);
-_467.loggingPane=null;
-if(_460){
-_467.parentNode.removeChild(_467);
-}else{
-this.win.close();
-}
-},this);
-var _493=function(){
-_490();
-for(var i=0;i<_479.length;i++){
-var msg=_479[i];
-if(_480===null||_480(msg)){
-_484(msg);
-}
-}
-};
-this.buildAndApplyFilter=function(){
-_480=_488();
-_493();
-this.logger.removeListener(_478);
-this.logger.addListener(_478,_480,_487);
-};
-var _494=bind(function(){
-_479=this.logger.getMessages();
-_493();
-},this);
-var _495=bind(function(_496){
-_496=_496||window.event;
-key=_496.which||_496.keyCode;
-if(key==13){
-this.buildAndApplyFilter();
-}
-},this);
-var _497="display: block; z-index: 1000; left: 0px; bottom: 0px; position: fixed; width: 100%; background-color: white; font: "+this.logFont;
-if(_460){
-_497+="; height: 10em; border-top: 2px solid black";
-}else{
-_497+="; height: 100%;";
-}
-_467.style.cssText=_497;
-if(!_468){
-doc.body.appendChild(_467);
-}
-_497={"cssText":"width: 33%; display: inline; font: "+this.logFont};
-_463(_470,{"value":"FATAL|ERROR|WARNING|INFO|DEBUG","onkeypress":_495,"style":_497});
-_467.appendChild(_470);
-_463(_471,{"value":".*","onkeypress":_495,"style":_497});
-_467.appendChild(_471);
-_497="width: 8%; display:inline; font: "+this.logFont;
-_472.appendChild(doc.createTextNode("Filter"));
-_472.onclick=bind("buildAndApplyFilter",this);
-_472.style.cssText=_497;
-_467.appendChild(_472);
-_473.appendChild(doc.createTextNode("Load"));
-_473.onclick=_494;
-_473.style.cssText=_497;
-_467.appendChild(_473);
-_474.appendChild(doc.createTextNode("Clear"));
-_474.onclick=_491;
-_474.style.cssText=_497;
-_467.appendChild(_474);
-_475.appendChild(doc.createTextNode("Close"));
-_475.onclick=_492;
-_475.style.cssText=_497;
-_467.appendChild(_475);
-_476.style.cssText="overflow: auto; width: 100%";
-_477.style.cssText="width: 100%; height: "+(_460?"8em":"100%");
-_476.appendChild(_477);
-_467.appendChild(_476);
-this.buildAndApplyFilter();
-_494();
-if(_460){
-this.win=undefined;
-}else{
-this.win=win;
-}
-this.inline=_460;
-this.closePane=_492;
-this.closed=false;
-return this;
-};
-MochiKit.LoggingPane.LoggingPane.prototype={"logFont":"8pt Verdana,sans-serif","colorTable":{"ERROR":"red","FATAL":"darkred","WARNING":"blue","INFO":"black","DEBUG":"green"}};
-MochiKit.LoggingPane.EXPORT_OK=["LoggingPane"];
-MochiKit.LoggingPane.EXPORT=["createLoggingPane"];
-MochiKit.LoggingPane.__new__=function(){
-this.EXPORT_TAGS={":common":this.EXPORT,":all":MochiKit.Base.concat(this.EXPORT,this.EXPORT_OK)};
-MochiKit.Base.nameFunctions(this);
-MochiKit.LoggingPane._loggingPane=null;
-};
-MochiKit.LoggingPane.__new__();
-MochiKit.Base._exportSymbols(this,MochiKit.LoggingPane);
-if(typeof (dojo)!="undefined"){
-dojo.provide("MochiKit.Color");
-dojo.require("MochiKit.Base");
-dojo.require("MochiKit.DOM");
-dojo.require("MochiKit.Style");
-}
-if(typeof (JSAN)!="undefined"){
-JSAN.use("MochiKit.Base",[]);
-JSAN.use("MochiKit.DOM",[]);
-JSAN.use("MochiKit.Style",[]);
-}
-try{
-if(typeof (MochiKit.Base)=="undefined"){
-throw "";
-}
-}
-catch(e){
-throw "MochiKit.Color depends on MochiKit.Base";
-}
-try{
-if(typeof (MochiKit.Base)=="undefined"){
-throw "";
-}
-}
-catch(e){
-throw "MochiKit.Color depends on MochiKit.DOM";
-}
-try{
-if(typeof (MochiKit.Base)=="undefined"){
-throw "";
-}
-}
-catch(e){
-throw "MochiKit.Color depends on MochiKit.Style";
-}
-if(typeof (MochiKit.Color)=="undefined"){
-MochiKit.Color={};
-}
-MochiKit.Color.NAME="MochiKit.Color";
-MochiKit.Color.VERSION="1.4";
-MochiKit.Color.__repr__=function(){
-return "["+this.NAME+" "+this.VERSION+"]";
-};
-MochiKit.Color.toString=function(){
-return this.__repr__();
-};
-MochiKit.Color.Color=function(red,_499,blue,_501){
-if(typeof (_501)=="undefined"||_501===null){
-_501=1;
-}
-this.rgb={r:red,g:_499,b:blue,a:_501};
-};
-MochiKit.Color.Color.prototype={__class__:MochiKit.Color.Color,colorWithAlpha:function(_502){
-var rgb=this.rgb;
-var m=MochiKit.Color;
-return m.Color.fromRGB(rgb.r,rgb.g,rgb.b,_502);
-},colorWithHue:function(hue){
-var hsl=this.asHSL();
-hsl.h=hue;
-var m=MochiKit.Color;
-return m.Color.fromHSL(hsl);
-},colorWithSaturation:function(_506){
-var hsl=this.asHSL();
-hsl.s=_506;
-var m=MochiKit.Color;
-return m.Color.fromHSL(hsl);
-},colorWithLightness:function(_507){
-var hsl=this.asHSL();
-hsl.l=_507;
-var m=MochiKit.Color;
-return m.Color.fromHSL(hsl);
-},darkerColorWithLevel:function(_508){
-var hsl=this.asHSL();
-hsl.l=Math.max(hsl.l-_508,0);
-var m=MochiKit.Color;
-return m.Color.fromHSL(hsl);
-},lighterColorWithLevel:function(_509){
-var hsl=this.asHSL();
-hsl.l=Math.min(hsl.l+_509,1);
-var m=MochiKit.Color;
-return m.Color.fromHSL(hsl);
-},blendedColor:function(_510,_511){
-if(typeof (_511)=="undefined"||_511===null){
-_511=0.5;
-}
-var sf=1-_511;
-var s=this.rgb;
-var d=_510.rgb;
-var df=_511;
-return MochiKit.Color.Color.fromRGB((s.r*sf)+(d.r*df),(s.g*sf)+(d.g*df),(s.b*sf)+(d.b*df),(s.a*sf)+(d.a*df));
-},compareRGB:function(_514){
-var a=this.asRGB();
-var b=_514.asRGB();
-return MochiKit.Base.compare([a.r,a.g,a.b,a.a],[b.r,b.g,b.b,b.a]);
-},isLight:function(){
-return this.asHSL().b>0.5;
-},isDark:function(){
-return (!this.isLight());
-},toHSLString:function(){
-var c=this.asHSL();
-var ccc=MochiKit.Color.clampColorComponent;
-var rval=this._hslString;
-if(!rval){
-var mid=(ccc(c.h,360).toFixed(0)+","+ccc(c.s,100).toPrecision(4)+"%"+","+ccc(c.l,100).toPrecision(4)+"%");
-var a=c.a;
-if(a>=1){
-a=1;
-rval="hsl("+mid+")";
-}else{
-if(a<=0){
-a=0;
-}
-rval="hsla("+mid+","+a+")";
-}
-this._hslString=rval;
-}
-return rval;
-},toRGBString:function(){
-var c=this.rgb;
-var ccc=MochiKit.Color.clampColorComponent;
-var rval=this._rgbString;
-if(!rval){
-var mid=(ccc(c.r,255).toFixed(0)+","+ccc(c.g,255).toFixed(0)+","+ccc(c.b,255).toFixed(0));
-if(c.a!=1){
-rval="rgba("+mid+","+c.a+")";
-}else{
-rval="rgb("+mid+")";
-}
-this._rgbString=rval;
-}
-return rval;
-},asRGB:function(){
-return MochiKit.Base.clone(this.rgb);
-},toHexString:function(){
-var m=MochiKit.Color;
-var c=this.rgb;
-var ccc=MochiKit.Color.clampColorComponent;
-var rval=this._hexString;
-if(!rval){
-rval=("#"+m.toColorPart(ccc(c.r,255))+m.toColorPart(ccc(c.g,255))+m.toColorPart(ccc(c.b,255)));
-this._hexString=rval;
-}
-return rval;
-},asHSV:function(){
-var hsv=this.hsv;
-var c=this.rgb;
-if(typeof (hsv)=="undefined"||hsv===null){
-hsv=MochiKit.Color.rgbToHSV(this.rgb);
-this.hsv=hsv;
-}
-return MochiKit.Base.clone(hsv);
-},asHSL:function(){
-var hsl=this.hsl;
-var c=this.rgb;
-if(typeof (hsl)=="undefined"||hsl===null){
-hsl=MochiKit.Color.rgbToHSL(this.rgb);
-this.hsl=hsl;
-}
-return MochiKit.Base.clone(hsl);
-},toString:function(){
-return this.toRGBString();
-},repr:function(){
-var c=this.rgb;
-var col=[c.r,c.g,c.b,c.a];
-return this.__class__.NAME+"("+col.join(", ")+")";
-}};
-MochiKit.Base.update(MochiKit.Color.Color,{fromRGB:function(red,_519,blue,_520){
-var _521=MochiKit.Color.Color;
-if(arguments.length==1){
-var rgb=red;
-red=rgb.r;
-_519=rgb.g;
-blue=rgb.b;
-if(typeof (rgb.a)=="undefined"){
-_520=undefined;
-}else{
-_520=rgb.a;
-}
-}
-return new _521(red,_519,blue,_520);
-},fromHSL:function(hue,_522,_523,_524){
-var m=MochiKit.Color;
-return m.Color.fromRGB(m.hslToRGB.apply(m,arguments));
-},fromHSV:function(hue,_525,_526,_527){
-var m=MochiKit.Color;
-return m.Color.fromRGB(m.hsvToRGB.apply(m,arguments));
-},fromName:function(name){
-var _528=MochiKit.Color.Color;
-if(name.charAt(0)=="\""){
-name=name.substr(1,name.length-2);
-}
-var _529=_528._namedColors[name.toLowerCase()];
-if(typeof (_529)=="string"){
-return _528.fromHexString(_529);
-}else{
-if(name=="transparent"){
-return _528.transparentColor();
-}
-}
-return null;
-},fromString:function(_530){
-var self=MochiKit.Color.Color;
-var _531=_530.substr(0,3);
-if(_531=="rgb"){
-return self.fromRGBString(_530);
-}else{
-if(_531=="hsl"){
-return self.fromHSLString(_530);
-}else{
-if(_530.charAt(0)=="#"){
-return self.fromHexString(_530);
-}
-}
-}
-return self.fromName(_530);
-},fromHexString:function(_532){
-if(_532.charAt(0)=="#"){
-_532=_532.substring(1);
-}
-var _533=[];
-var i,hex;
-if(_532.length==3){
-for(i=0;i<3;i++){
-hex=_532.substr(i,1);
-_533.push(parseInt(hex+hex,16)/255);
-}
-}else{
-for(i=0;i<6;i+=2){
-hex=_532.substr(i,2);
-_533.push(parseInt(hex,16)/255);
-}
-}
-var _534=MochiKit.Color.Color;
-return _534.fromRGB.apply(_534,_533);
-},_fromColorString:function(pre,_536,_537,_538){
-if(_538.indexOf(pre)===0){
-_538=_538.substring(_538.indexOf("(",3)+1,_538.length-1);
-}
-var _539=_538.split(/\s*,\s*/);
-var _540=[];
-for(var i=0;i<_539.length;i++){
-var c=_539[i];
-var val;
-var _541=c.substring(c.length-3);
-if(c.charAt(c.length-1)=="%"){
-val=0.01*parseFloat(c.substring(0,c.length-1));
-}else{
-if(_541=="deg"){
-val=parseFloat(c)/360;
-}else{
-if(_541=="rad"){
-val=parseFloat(c)/(Math.PI*2);
-}else{
-val=_537[i]*parseFloat(c);
-}
-}
-}
-_540.push(val);
-}
-return this[_536].apply(this,_540);
-},fromComputedStyle:function(elem,_542){
-var d=MochiKit.DOM;
-var cls=MochiKit.Color.Color;
-for(elem=d.getElement(elem);elem;elem=elem.parentNode){
-var _543=MochiKit.Style.computedStyle.apply(d,arguments);
-if(!_543){
-continue;
-}
-var _544=cls.fromString(_543);
-if(!_544){
-break;
-}
-if(_544.asRGB().a>0){
-return _544;
-}
-}
-return null;
-},fromBackground:function(elem){
-var cls=MochiKit.Color.Color;
-return cls.fromComputedStyle(elem,"backgroundColor","background-color")||cls.whiteColor();
-},fromText:function(elem){
-var cls=MochiKit.Color.Color;
-return cls.fromComputedStyle(elem,"color","color")||cls.blackColor();
-},namedColors:function(){
-return MochiKit.Base.clone(MochiKit.Color.Color._namedColors);
-}});
-MochiKit.Base.update(MochiKit.Color,{clampColorComponent:function(v,_545){
-v*=_545;
-if(v<0){
-return 0;
-}else{
-if(v>_545){
-return _545;
-}else{
-return v;
-}
-}
-},_hslValue:function(n1,n2,hue){
-if(hue>6){
-hue-=6;
-}else{
-if(hue<0){
-hue+=6;
-}
-}
-var val;
-if(hue<1){
-val=n1+(n2-n1)*hue;
-}else{
-if(hue<3){
-val=n2;
-}else{
-if(hue<4){
-val=n1+(n2-n1)*(4-hue);
-}else{
-val=n1;
-}
-}
-}
-return val;
-},hsvToRGB:function(hue,_548,_549,_550){
-if(arguments.length==1){
-var hsv=hue;
-hue=hsv.h;
-_548=hsv.s;
-_549=hsv.v;
-_550=hsv.a;
-}
-var red;
-var _551;
-var blue;
-if(_548===0){
-red=0;
-_551=0;
-blue=0;
-}else{
-var i=Math.floor(hue*6);
-var f=(hue*6)-i;
-var p=_549*(1-_548);
-var q=_549*(1-(_548*f));
-var t=_549*(1-(_548*(1-f)));
-switch(i){
-case 1:
-red=q;
-_551=_549;
-blue=p;
-break;
-case 2:
-red=p;
-_551=_549;
-blue=t;
-break;
-case 3:
-red=p;
-_551=q;
-blue=_549;
-break;
-case 4:
-red=t;
-_551=p;
-blue=_549;
-break;
-case 5:
-red=_549;
-_551=p;
-blue=q;
-break;
-case 6:
-case 0:
-red=_549;
-_551=t;
-blue=p;
-break;
-}
-}
-return {r:red,g:_551,b:blue,a:_550};
-},hslToRGB:function(hue,_553,_554,_555){
-if(arguments.length==1){
-var hsl=hue;
-hue=hsl.h;
-_553=hsl.s;
-_554=hsl.l;
-_555=hsl.a;
-}
-var red;
-var _556;
-var blue;
-if(_553===0){
-red=_554;
-_556=_554;
-blue=_554;
-}else{
-var m2;
-if(_554<=0.5){
-m2=_554*(1+_553);
-}else{
-m2=_554+_553-(_554*_553);
-}
-var m1=(2*_554)-m2;
-var f=MochiKit.Color._hslValue;
-var h6=hue*6;
-red=f(m1,m2,h6+2);
-_556=f(m1,m2,h6);
-blue=f(m1,m2,h6-2);
-}
-return {r:red,g:_556,b:blue,a:_555};
-},rgbToHSV:function(red,_560,blue,_561){
-if(arguments.length==1){
-var rgb=red;
-red=rgb.r;
-_560=rgb.g;
-blue=rgb.b;
-_561=rgb.a;
-}
-var max=Math.max(Math.max(red,_560),blue);
-var min=Math.min(Math.min(red,_560),blue);
-var hue;
-var _564;
-var _565=max;
-if(min==max){
-hue=0;
-_564=0;
-}else{
-var _566=(max-min);
-_564=_566/max;
-if(red==max){
-hue=(_560-blue)/_566;
-}else{
-if(_560==max){
-hue=2+((blue-red)/_566);
-}else{
-hue=4+((red-_560)/_566);
-}
-}
-hue/=6;
-if(hue<0){
-hue+=1;
-}
-if(hue>1){
-hue-=1;
-}
-}
-return {h:hue,s:_564,v:_565,a:_561};
-},rgbToHSL:function(red,_567,blue,_568){
-if(arguments.length==1){
-var rgb=red;
-red=rgb.r;
-_567=rgb.g;
-blue=rgb.b;
-_568=rgb.a;
-}
-var max=Math.max(red,Math.max(_567,blue));
-var min=Math.min(red,Math.min(_567,blue));
-var hue;
-var _569;
-var _570=(max+min)/2;
-var _571=max-min;
-if(_571===0){
-hue=0;
-_569=0;
-}else{
-if(_570<=0.5){
-_569=_571/(max+min);
-}else{
-_569=_571/(2-max-min);
-}
-if(red==max){
-hue=(_567-blue)/_571;
-}else{
-if(_567==max){
-hue=2+((blue-red)/_571);
-}else{
-hue=4+((red-_567)/_571);
-}
-}
-hue/=6;
-if(hue<0){
-hue+=1;
-}
-if(hue>1){
-hue-=1;
-}
-}
-return {h:hue,s:_569,l:_570,a:_568};
-},toColorPart:function(num){
-num=Math.round(num);
-var _572=num.toString(16);
-if(num<16){
-return "0"+_572;
-}
-return _572;
-},__new__:function(){
-var m=MochiKit.Base;
-this.Color.fromRGBString=m.bind(this.Color._fromColorString,this.Color,"rgb","fromRGB",[1/255,1/255,1/255,1]);
-this.Color.fromHSLString=m.bind(this.Color._fromColorString,this.Color,"hsl","fromHSL",[1/360,0.01,0.01,1]);
-var _573=1/3;
-var _574={black:[0,0,0],blue:[0,0,1],brown:[0.6,0.4,0.2],cyan:[0,1,1],darkGray:[_573,_573,_573],gray:[0.5,0.5,0.5],green:[0,1,0],lightGray:[2*_573,2*_573,2*_573],magenta:[1,0,1],orange:[1,0.5,0],purple:[0.5,0,0.5],red:[1,0,0],transparent:[0,0,0,0],white:[1,1,1],yellow:[1,1,0]};
-var _575=function(name,r,g,b,a){
-var rval=this.fromRGB(r,g,b,a);
-this[name]=function(){
-return rval;
-};
-return rval;
-};
-for(var k in _574){
-var name=k+"Color";
-var _577=m.concat([_575,this.Color,name],_574[k]);
-this.Color[name]=m.bind.apply(null,_577);
-}
-var _578=function(){
-for(var i=0;i1){
-var src=MochiKit.DOM.getElement(arguments[0]);
-var sig=arguments[1];
-var obj=arguments[2];
-var func=arguments[3];
-for(var i=_597.length-1;i>=0;i--){
-var o=_597[i];
-if(o[0]===src&&o[1]===sig&&o[4]===obj&&o[5]===func){
-self._disconnect(o);
-if(!self._lock){
-_597.splice(i,1);
-}else{
-self._dirty=true;
-}
-return true;
-}
-}
-}else{
-var idx=m.findIdentical(_597,_596);
-if(idx>=0){
-self._disconnect(_596);
-if(!self._lock){
-_597.splice(idx,1);
-}else{
-self._dirty=true;
-}
-return true;
-}
-}
-return false;
-},disconnectAll:function(src,sig){
-src=MochiKit.DOM.getElement(src);
-var m=MochiKit.Base;
-var _598=m.flattenArguments(m.extend(null,arguments,1));
-var self=MochiKit.Signal;
-var _599=self._disconnect;
-var _600=self._observers;
-var i,ident;
-var _601=self._lock;
-var _602=self._dirty;
-if(_598.length===0){
-for(i=_600.length-1;i>=0;i--){
-ident=_600[i];
-if(ident[0]===src){
-_599(ident);
-if(!_601){
-_600.splice(i,1);
-}else{
-_602=true;
-}
-}
-}
-}else{
-var sigs={};
-for(i=0;i<_598.length;i++){
-sigs[_598[i]]=true;
-}
-for(i=_600.length-1;i>=0;i--){
-ident=_600[i];
-if(ident[0]===src&&ident[1] in sigs){
-_599(ident);
-if(!_601){
-_600.splice(i,1);
-}else{
-_602=true;
-}
-}
-}
-}
-self._dirty=_602;
-},signal:function(src,sig){
-var self=MochiKit.Signal;
-var _604=self._observers;
-src=MochiKit.DOM.getElement(src);
-var args=MochiKit.Base.extend(null,arguments,2);
-var _605=[];
-self._lock=true;
-for(var i=0;i<_604.length;i++){
-var _606=_604[i];
-if(_606[0]===src&&_606[1]===sig){
-try{
-_606[2].apply(src,args);
-}
-catch(e){
-_605.push(e);
-}
-}
-}
-self._lock=false;
-if(self._dirty){
-self._dirty=false;
-for(var i=_604.length-1;i>=0;i--){
-if(!_604[i][6]){
-_604.splice(i,1);
-}
-}
-}
-if(_605.length==1){
-throw _605[0];
-}else{
-if(_605.length>1){
-var e=new Error("Multiple errors thrown in handling 'sig', see errors property");
-e.errors=_605;
-throw e;
-}
-}
-}});
-MochiKit.Signal.EXPORT_OK=[];
-MochiKit.Signal.EXPORT=["connect","disconnect","signal","disconnectAll"];
-MochiKit.Signal.__new__=function(win){
-var m=MochiKit.Base;
-this._document=document;
-this._window=win;
-this._lock=false;
-this._dirty=false;
-try{
-this.connect(window,"onunload",this._unloadCache);
-}
-catch(e){
-}
-this.EXPORT_TAGS={":common":this.EXPORT,":all":m.concat(this.EXPORT,this.EXPORT_OK)};
-m.nameFunctions(this);
-};
-MochiKit.Signal.__new__(this);
-if(MochiKit.__export__){
-connect=MochiKit.Signal.connect;
-disconnect=MochiKit.Signal.disconnect;
-disconnectAll=MochiKit.Signal.disconnectAll;
-signal=MochiKit.Signal.signal;
-}
-MochiKit.Base._exportSymbols(this,MochiKit.Signal);
-if(typeof (dojo)!="undefined"){
-dojo.provide("MochiKit.Visual");
-dojo.require("MochiKit.Base");
-dojo.require("MochiKit.DOM");
-dojo.require("MochiKit.Style");
-dojo.require("MochiKit.Color");
-}
-if(typeof (JSAN)!="undefined"){
-JSAN.use("MochiKit.Base",[]);
-JSAN.use("MochiKit.DOM",[]);
-JSAN.use("MochiKit.Style",[]);
-JSAN.use("MochiKit.Color",[]);
-}
-try{
-if(typeof (MochiKit.Base)==="undefined"||typeof (MochiKit.DOM)==="undefined"||typeof (MochiKit.Style)==="undefined"||typeof (MochiKit.Color)==="undefined"){
-throw "";
-}
-}
-catch(e){
-throw "MochiKit.Visual depends on MochiKit.Base, MochiKit.DOM, MochiKit.Style and MochiKit.Color!";
-}
-if(typeof (MochiKit.Visual)=="undefined"){
-MochiKit.Visual={};
-}
-MochiKit.Visual.NAME="MochiKit.Visual";
-MochiKit.Visual.VERSION="1.4";
-MochiKit.Visual.__repr__=function(){
-return "["+this.NAME+" "+this.VERSION+"]";
-};
-MochiKit.Visual.toString=function(){
-return this.__repr__();
-};
-MochiKit.Visual._RoundCorners=function(e,_607){
-e=MochiKit.DOM.getElement(e);
-this._setOptions(_607);
-if(this.options.__unstable__wrapElement){
-e=this._doWrap(e);
-}
-var _608=this.options.color;
-var C=MochiKit.Color.Color;
-if(this.options.color==="fromElement"){
-_608=C.fromBackground(e);
-}else{
-if(!(_608 instanceof C)){
-_608=C.fromString(_608);
-}
-}
-this.isTransparent=(_608.asRGB().a<=0);
-var _610=this.options.bgColor;
-if(this.options.bgColor==="fromParent"){
-_610=C.fromBackground(e.offsetParent);
-}else{
-if(!(_610 instanceof C)){
-_610=C.fromString(_610);
-}
-}
-this._roundCornersImpl(e,_608,_610);
-};
-MochiKit.Visual._RoundCorners.prototype={_doWrap:function(e){
-var _611=e.parentNode;
-var doc=MochiKit.DOM.currentDocument();
-if(typeof (doc.defaultView)==="undefined"||doc.defaultView===null){
-return e;
-}
-var _612=doc.defaultView.getComputedStyle(e,null);
-if(typeof (_612)==="undefined"||_612===null){
-return e;
-}
-var _613=MochiKit.DOM.DIV({"style":{display:"block",marginTop:_612.getPropertyValue("padding-top"),marginRight:_612.getPropertyValue("padding-right"),marginBottom:_612.getPropertyValue("padding-bottom"),marginLeft:_612.getPropertyValue("padding-left"),padding:"0px"}});
-_613.innerHTML=e.innerHTML;
-e.innerHTML="";
-e.appendChild(_613);
-return e;
-},_roundCornersImpl:function(e,_614,_615){
-if(this.options.border){
-this._renderBorder(e,_615);
-}
-if(this._isTopRounded()){
-this._roundTopCorners(e,_614,_615);
-}
-if(this._isBottomRounded()){
-this._roundBottomCorners(e,_614,_615);
-}
-},_renderBorder:function(el,_617){
-var _618="1px solid "+this._borderColor(_617);
-var _619="border-left: "+_618;
-var _620="border-right: "+_618;
-var _621="style='"+_619+";"+_620+"'";
-el.innerHTML=""+el.innerHTML+"
";
-},_roundTopCorners:function(el,_622,_623){
-var _624=this._createCorner(_623);
-for(var i=0;i=0;i--){
-_627.appendChild(this._createCornerSlice(_625,_626,i,"bottom"));
-}
-el.style.paddingBottom=0;
-el.appendChild(_627);
-},_createCorner:function(_628){
-var dom=MochiKit.DOM;
-return dom.DIV({style:{backgroundColor:_628.toString()}});
-},_createCornerSlice:function(_629,_630,n,_631){
-var _632=MochiKit.DOM.SPAN();
-var _633=_632.style;
-_633.backgroundColor=_629.toString();
-_633.display="block";
-_633.height="1px";
-_633.overflow="hidden";
-_633.fontSize="1px";
-var _634=this._borderColor(_629,_630);
-if(this.options.border&&n===0){
-_633.borderTopStyle="solid";
-_633.borderTopWidth="1px";
-_633.borderLeftWidth="0px";
-_633.borderRightWidth="0px";
-_633.borderBottomWidth="0px";
-_633.height="0px";
-_633.borderColor=_634.toString();
-}else{
-if(_634){
-_633.borderColor=_634.toString();
-_633.borderStyle="solid";
-_633.borderWidth="0px 1px";
-}
-}
-if(!this.options.compact&&(n==(this.options.numSlices-1))){
-_633.height="2px";
-}
-this._setMargin(_632,n,_631);
-this._setBorder(_632,n,_631);
-return _632;
-},_setOptions:function(_635){
-this.options={corners:"all",color:"fromElement",bgColor:"fromParent",blend:true,border:false,compact:false,__unstable__wrapElement:false};
-MochiKit.Base.update(this.options,_635);
-this.options.numSlices=(this.options.compact?2:4);
-},_whichSideTop:function(){
-var _636=this.options.corners;
-if(this._hasString(_636,"all","top")){
-return "";
-}
-var _637=(_636.indexOf("tl")!=-1);
-var _638=(_636.indexOf("tr")!=-1);
-if(_637&&_638){
-return "";
-}
-if(_637){
-return "left";
-}
-if(_638){
-return "right";
-}
-return "";
-},_whichSideBottom:function(){
-var _639=this.options.corners;
-if(this._hasString(_639,"all","bottom")){
-return "";
-}
-var _640=(_639.indexOf("bl")!=-1);
-var _641=(_639.indexOf("br")!=-1);
-if(_640&&_641){
-return "";
-}
-if(_640){
-return "left";
-}
-if(_641){
-return "right";
-}
-return "";
-},_borderColor:function(_642,_643){
-if(_642=="transparent"){
-return _643;
-}else{
-if(this.options.border){
-return this.options.border;
-}else{
-if(this.options.blend){
-return _643.blendedColor(_642);
-}
-}
-}
-return "";
-},_setMargin:function(el,n,_644){
-var _645=this._marginSize(n)+"px";
-var _646=(_644=="top"?this._whichSideTop():this._whichSideBottom());
-var _647=el.style;
-if(_646=="left"){
-_647.marginLeft=_645;
-_647.marginRight="0px";
-}else{
-if(_646=="right"){
-_647.marginRight=_645;
-_647.marginLeft="0px";
-}else{
-_647.marginLeft=_645;
-_647.marginRight=_645;
-}
-}
-},_setBorder:function(el,n,_648){
-var _649=this._borderSize(n)+"px";
-var _650=(_648=="top"?this._whichSideTop():this._whichSideBottom());
-var _651=el.style;
-if(_650=="left"){
-_651.borderLeftWidth=_649;
-_651.borderRightWidth="0px";
-}else{
-if(_650=="right"){
-_651.borderRightWidth=_649;
-_651.borderLeftWidth="0px";
-}else{
-_651.borderLeftWidth=_649;
-_651.borderRightWidth=_649;
-}
-}
-},_marginSize:function(n){
-if(this.isTransparent){
-return 0;
-}
-var o=this.options;
-if(o.compact&&o.blend){
-var _652=[1,0];
-return _652[n];
-}else{
-if(o.compact){
-var _653=[2,1];
-return _653[n];
-}else{
-if(o.blend){
-var _654=[3,2,1,0];
-return _654[n];
-}else{
-var _655=[5,3,2,1];
-return _655[n];
-}
-}
-}
-},_borderSize:function(n){
-var o=this.options;
-var _656;
-if(o.compact&&(o.blend||this.isTransparent)){
-return 1;
-}else{
-if(o.compact){
-_656=[1,0];
-}else{
-if(o.blend){
-_656=[2,1,1,1];
-}else{
-if(o.border){
-_656=[0,2,0,0];
-}else{
-if(this.isTransparent){
-_656=[5,3,2,1];
-}else{
-return 0;
-}
-}
-}
-}
-}
-return _656[n];
-},_hasString:function(str){
-for(var i=1;i=(_681||i)){
-_681=i;
-}
-},this.effects);
-_679=_681||_679;
-break;
-case "break":
-ma(function(e){
-e.finalize();
-},this.effects);
-break;
-}
-_678.startOn+=_679;
-_678.finishOn+=_679;
-if(!_678.options.queue.limit||this.effects.length<_678.options.queue.limit){
-this.effects.push(_678);
-}
-if(!this.interval){
-this.interval=this.startLoop(MochiKit.Base.bind(this.loop,this),40);
-}
-},startLoop:function(func,_682){
-return setInterval(func,_682);
-},remove:function(_683){
-this.effects=MochiKit.Base.filter(function(e){
-return e!=_683;
-},this.effects);
-if(this.effects.length==0){
-this.stopLoop(this.interval);
-this.interval=null;
-}
-},stopLoop:function(_684){
-clearInterval(_684);
-},loop:function(){
-var _685=new Date().getTime();
-MochiKit.Base.map(function(_686){
-_686.loop(_685);
-},this.effects);
-}});
-MochiKit.Visual.Queues={instances:{},get:function(_687){
-if(typeof (_687)!="string"){
-return _687;
-}
-if(!this.instances[_687]){
-this.instances[_687]=new MochiKit.Visual.ScopedQueue();
-}
-return this.instances[_687];
-}};
-MochiKit.Visual.Queue=MochiKit.Visual.Queues.get("global");
-MochiKit.Visual.DefaultOptions={transition:MochiKit.Visual.Transitions.sinoidal,duration:1,fps:25,sync:false,from:0,to:1,delay:0,queue:"parallel"};
-MochiKit.Visual.Base=function(){
-};
-MochiKit.Visual.Base.prototype={__class__:MochiKit.Visual.Base,start:function(_688){
-var v=MochiKit.Visual;
-this.options=MochiKit.Base.setdefault(_688||{},v.DefaultOptions);
-this.currentFrame=0;
-this.state="idle";
-this.startOn=this.options.delay*1000;
-this.finishOn=this.startOn+(this.options.duration*1000);
-this.event("beforeStart");
-if(!this.options.sync){
-v.Queues.get(typeof (this.options.queue)=="string"?"global":this.options.queue.scope).add(this);
-}
-},loop:function(_689){
-if(_689>=this.startOn){
-if(_689>=this.finishOn){
-return this.finalize();
-}
-var pos=(_689-this.startOn)/(this.finishOn-this.startOn);
-var _690=Math.round(pos*this.options.fps*this.options.duration);
-if(_690>this.currentFrame){
-this.render(pos);
-this.currentFrame=_690;
-}
-}
-},render:function(pos){
-if(this.state=="idle"){
-this.state="running";
-this.event("beforeSetup");
-this.setup();
-this.event("afterSetup");
-}
-if(this.state=="running"){
-if(this.options.transition){
-pos=this.options.transition(pos);
-}
-pos*=(this.options.to-this.options.from);
-pos+=this.options.from;
-this.event("beforeUpdate");
-this.update(pos);
-this.event("afterUpdate");
-}
-},cancel:function(){
-if(!this.options.sync){
-MochiKit.Visual.Queues.get(typeof (this.options.queue)=="string"?"global":this.options.queue.scope).remove(this);
-}
-this.state="finished";
-},finalize:function(){
-this.render(1);
-this.cancel();
-this.event("beforeFinish");
-this.finish();
-this.event("afterFinish");
-},setup:function(){
-},finish:function(){
-},update:function(_691){
-},event:function(_692){
-if(this.options[_692+"Internal"]){
-this.options[_692+"Internal"](this);
-}
-if(this.options[_692]){
-this.options[_692](this);
-}
-},repr:function(){
-return "["+this.__class__.NAME+", options:"+MochiKit.Base.repr(this.options)+"]";
-}};
-MochiKit.Visual.Parallel=function(_693,_694){
-this.__init__(_693,_694);
-};
-MochiKit.Visual.Parallel.prototype=new MochiKit.Visual.Base();
-MochiKit.Base.update(MochiKit.Visual.Parallel.prototype,{__init__:function(_695,_696){
-this.effects=_695||[];
-this.start(_696);
-},update:function(_697){
-MochiKit.Base.map(function(_698){
-_698.render(_697);
-},this.effects);
-},finish:function(){
-MochiKit.Base.map(function(_699){
-_699.finalize();
-},this.effects);
-}});
-MochiKit.Visual.Opacity=function(_700,_701){
-this.__init__(_700,_701);
-};
-MochiKit.Visual.Opacity.prototype=new MochiKit.Visual.Base();
-MochiKit.Base.update(MochiKit.Visual.Opacity.prototype,{__init__:function(_702,_703){
-var b=MochiKit.Base;
-var s=MochiKit.Style;
-this.element=MochiKit.DOM.getElement(_702);
-if(this.element.currentStyle&&(!this.element.currentStyle.hasLayout)){
-s.setStyle(this.element,{zoom:1});
-}
-_703=b.update({from:s.getOpacity(this.element)||0,to:1},_703||{});
-this.start(_703);
-},update:function(_704){
-MochiKit.Style.setOpacity(this.element,_704);
-}});
-MochiKit.Visual.Move=function(_705,_706){
-this.__init__(_705,_706);
-};
-MochiKit.Visual.Move.prototype=new MochiKit.Visual.Base();
-MochiKit.Base.update(MochiKit.Visual.Move.prototype,{__init__:function(_707,_708){
-this.element=MochiKit.DOM.getElement(_707);
-_708=MochiKit.Base.update({x:0,y:0,mode:"relative"},_708||{});
-this.start(_708);
-},setup:function(){
-MochiKit.DOM.makePositioned(this.element);
-var s=this.element.style;
-var _709=s.visibility;
-var _710=s.display;
-if(_710=="none"){
-s.visibility="hidden";
-s.display="";
-}
-this.originalLeft=parseFloat(MochiKit.Style.getStyle(this.element,"left")||"0");
-this.originalTop=parseFloat(MochiKit.Style.getStyle(this.element,"top")||"0");
-if(this.options.mode=="absolute"){
-this.options.x-=this.originalLeft;
-this.options.y-=this.originalTop;
-}
-if(_710=="none"){
-s.visibility=_709;
-s.display=_710;
-}
-},update:function(_711){
-MochiKit.Style.setStyle(this.element,{left:Math.round(this.options.x*_711+this.originalLeft)+"px",top:Math.round(this.options.y*_711+this.originalTop)+"px"});
-}});
-MochiKit.Visual.Scale=function(_712,_713,_714){
-this.__init__(_712,_713,_714);
-};
-MochiKit.Visual.Scale.prototype=new MochiKit.Visual.Base();
-MochiKit.Base.update(MochiKit.Visual.Scale.prototype,{__init__:function(_715,_716,_717){
-this.element=MochiKit.DOM.getElement(_715);
-_717=MochiKit.Base.update({scaleX:true,scaleY:true,scaleContent:true,scaleFromCenter:false,scaleMode:"box",scaleFrom:100,scaleTo:_716},_717||{});
-this.start(_717);
-},setup:function(){
-this.restoreAfterFinish=this.options.restoreAfterFinish||false;
-this.elementPositioning=MochiKit.Style.getStyle(this.element,"position");
-var ma=MochiKit.Base.map;
-var b=MochiKit.Base.bind;
-this.originalStyle={};
-ma(b(function(k){
-this.originalStyle[k]=this.element.style[k];
-},this),["top","left","width","height","fontSize"]);
-this.originalTop=this.element.offsetTop;
-this.originalLeft=this.element.offsetLeft;
-var _718=MochiKit.Style.getStyle(this.element,"font-size")||"100%";
-ma(b(function(_719){
-if(_718.indexOf(_719)>0){
-this.fontSize=parseFloat(_718);
-this.fontSizeType=_719;
-}
-},this),["em","px","%"]);
-this.factor=(this.options.scaleTo-this.options.scaleFrom)/100;
-if(/^content/.test(this.options.scaleMode)){
-this.dims=[this.element.scrollHeight,this.element.scrollWidth];
-}else{
-if(this.options.scaleMode=="box"){
-this.dims=[this.element.offsetHeight,this.element.offsetWidth];
-}else{
-this.dims=[this.options.scaleMode.originalHeight,this.options.scaleMode.originalWidth];
-}
-}
-},update:function(_720){
-var _721=(this.options.scaleFrom/100)+(this.factor*_720);
-if(this.options.scaleContent&&this.fontSize){
-MochiKit.Style.setStyle(this.element,{fontSize:this.fontSize*_721+this.fontSizeType});
-}
-this.setDimensions(this.dims[0]*_721,this.dims[1]*_721);
-},finish:function(){
-if(this.restoreAfterFinish){
-MochiKit.Style.setStyle(this.element,this.originalStyle);
-}
-},setDimensions:function(_722,_723){
-var d={};
-var r=Math.round;
-if(/MSIE/.test(navigator.userAgent)){
-r=Math.ceil;
-}
-if(this.options.scaleX){
-d.width=r(_723)+"px";
-}
-if(this.options.scaleY){
-d.height=r(_722)+"px";
-}
-if(this.options.scaleFromCenter){
-var topd=(_722-this.dims[0])/2;
-var _725=(_723-this.dims[1])/2;
-if(this.elementPositioning=="absolute"){
-if(this.options.scaleY){
-d.top=this.originalTop-topd+"px";
-}
-if(this.options.scaleX){
-d.left=this.originalLeft-_725+"px";
-}
-}else{
-if(this.options.scaleY){
-d.top=-topd+"px";
-}
-if(this.options.scaleX){
-d.left=-_725+"px";
-}
-}
-}
-MochiKit.Style.setStyle(this.element,d);
-}});
-MochiKit.Visual.Highlight=function(_726,_727){
-this.__init__(_726,_727);
-};
-MochiKit.Visual.Highlight.prototype=new MochiKit.Visual.Base();
-MochiKit.Base.update(MochiKit.Visual.Highlight.prototype,{__init__:function(_728,_729){
-this.element=MochiKit.DOM.getElement(_728);
-_729=MochiKit.Base.update({startcolor:"#ffff99"},_729||{});
-this.start(_729);
-},setup:function(){
-var b=MochiKit.Base;
-var s=MochiKit.Style;
-if(s.getStyle(this.element,"display")=="none"){
-this.cancel();
-return;
-}
-this.oldStyle={backgroundImage:s.getStyle(this.element,"background-image")};
-s.setStyle(this.element,{backgroundImage:"none"});
-if(!this.options.endcolor){
-this.options.endcolor=MochiKit.Color.Color.fromBackground(this.element).toHexString();
-}
-if(b.isUndefinedOrNull(this.options.restorecolor)){
-this.options.restorecolor=s.getStyle(this.element,"background-color");
-}
-this._base=b.map(b.bind(function(i){
-return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16);
-},this),[0,1,2]);
-this._delta=b.map(b.bind(function(i){
-return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i];
-},this),[0,1,2]);
-},update:function(_730){
-var m="#";
-MochiKit.Base.map(MochiKit.Base.bind(function(i){
-m+=MochiKit.Color.toColorPart(Math.round(this._base[i]+this._delta[i]*_730));
-},this),[0,1,2]);
-MochiKit.Style.setStyle(this.element,{backgroundColor:m});
-},finish:function(){
-MochiKit.Style.setStyle(this.element,MochiKit.Base.update(this.oldStyle,{backgroundColor:this.options.restorecolor}));
-}});
-MochiKit.Visual.ScrollTo=function(_731,_732){
-this.__init__(_731,_732);
-};
-MochiKit.Visual.ScrollTo.prototype=new MochiKit.Visual.Base();
-MochiKit.Base.update(MochiKit.Visual.ScrollTo.prototype,{__init__:function(_733,_734){
-this.element=MochiKit.DOM.getElement(_733);
-this.start(_734||{});
-},setup:function(){
-var p=MochiKit.Position;
-p.prepare();
-var _735=p.cumulativeOffset(this.element);
-if(this.options.offset){
-_735.y+=this.options.offset;
-}
-var max;
-if(window.innerHeight){
-max=window.innerHeight-window.height;
-}else{
-if(document.documentElement&&document.documentElement.clientHeight){
-max=document.documentElement.clientHeight-document.body.scrollHeight;
-}else{
-if(document.body){
-max=document.body.clientHeight-document.body.scrollHeight;
-}
-}
-}
-this.scrollStart=p.windowOffset.y;
-this.delta=(_735.y>max?max:_735.y)-this.scrollStart;
-},update:function(_736){
-var p=MochiKit.Position;
-p.prepare();
-window.scrollTo(p.windowOffset.x,this.scrollStart+(_736*this.delta));
-}});
-MochiKit.Visual.fade=function(_737,_738){
-var s=MochiKit.Style;
-var _739=MochiKit.DOM.getElement(_737).style.opacity||"";
-_738=MochiKit.Base.update({from:s.getOpacity(_737)||1,to:0,afterFinishInternal:function(_740){
-if(_740.options.to!==0){
-return;
-}
-s.hideElement(_740.element);
-s.setStyle(_740.element,{opacity:_739});
-}},_738||{});
-return new MochiKit.Visual.Opacity(_737,_738);
-};
-MochiKit.Visual.appear=function(_741,_742){
-var s=MochiKit.Style;
-var v=MochiKit.Visual;
-_742=MochiKit.Base.update({from:(s.getStyle(_741,"display")=="none"?0:s.getOpacity(_741)||0),to:1,afterFinishInternal:function(_743){
-v.forceRerendering(_743.element);
-},beforeSetupInternal:function(_744){
-s.setOpacity(_744.element,_744.options.from);
-s.showElement(_744.element);
-}},_742||{});
-return new v.Opacity(_741,_742);
-};
-MochiKit.Visual.puff=function(_745,_746){
-var s=MochiKit.Style;
-var v=MochiKit.Visual;
-_745=MochiKit.DOM.getElement(_745);
-var _747={opacity:_745.style.opacity||"",position:s.getStyle(_745,"position"),top:_745.style.top,left:_745.style.left,width:_745.style.width,height:_745.style.height};
-_746=MochiKit.Base.update({beforeSetupInternal:function(_748){
-MochiKit.Position.absolutize(_748.effects[0].element);
-},afterFinishInternal:function(_749){
-s.hideElement(_749.effects[0].element);
-s.setStyle(_749.effects[0].element,_747);
-}},_746||{});
-return new v.Parallel([new v.Scale(_745,200,{sync:true,scaleFromCenter:true,scaleContent:true,restoreAfterFinish:true}),new v.Opacity(_745,{sync:true,to:0})],_746);
-};
-MochiKit.Visual.blindUp=function(_750,_751){
-var d=MochiKit.DOM;
-_750=d.getElement(_750);
-var _752=d.makeClipping(_750);
-_751=MochiKit.Base.update({scaleContent:false,scaleX:false,restoreAfterFinish:true,afterFinishInternal:function(_753){
-MochiKit.Style.hideElement(_753.element);
-d.undoClipping(_753.element,_752);
-}},_751||{});
-return new MochiKit.Visual.Scale(_750,0,_751);
-};
-MochiKit.Visual.blindDown=function(_754,_755){
-var d=MochiKit.DOM;
-var s=MochiKit.Style;
-_754=d.getElement(_754);
-var _756=s.getElementDimensions(_754);
-var _757;
-_755=MochiKit.Base.update({scaleContent:false,scaleX:false,scaleFrom:0,scaleMode:{originalHeight:_756.h,originalWidth:_756.w},restoreAfterFinish:true,afterSetupInternal:function(_758){
-_757=d.makeClipping(_758.element);
-s.setStyle(_758.element,{height:"0px"});
-s.showElement(_758.element);
-},afterFinishInternal:function(_759){
-d.undoClipping(_759.element,_757);
-}},_755||{});
-return new MochiKit.Visual.Scale(_754,100,_755);
-};
-MochiKit.Visual.switchOff=function(_760,_761){
-var d=MochiKit.DOM;
-_760=d.getElement(_760);
-var _762=_760.style.opacity||"";
-var _763;
-var _761=MochiKit.Base.update({duration:0.3,scaleFromCenter:true,scaleX:false,scaleContent:false,restoreAfterFinish:true,beforeSetupInternal:function(_764){
-d.makePositioned(_764.element);
-_763=d.makeClipping(_764.element);
-},afterFinishInternal:function(_765){
-MochiKit.Style.hideElement(_765.element);
-d.undoClipping(_765.element,_763);
-d.undoPositioned(_765.element);
-MochiKit.Style.setStyle(_765.element,{opacity:_762});
-}},_761||{});
-var v=MochiKit.Visual;
-return new v.appear(_760,{duration:0.4,from:0,transition:v.Transitions.flicker,afterFinishInternal:function(_766){
-new v.Scale(_766.element,1,_761);
-}});
-};
-MochiKit.Visual.dropOut=function(_767,_768){
-var d=MochiKit.DOM;
-var s=MochiKit.Style;
-_767=d.getElement(_767);
-var _769={top:s.getStyle(_767,"top"),left:s.getStyle(_767,"left"),opacity:_767.style.opacity||""};
-_768=MochiKit.Base.update({duration:0.5,beforeSetupInternal:function(_770){
-d.makePositioned(_770.effects[0].element);
-},afterFinishInternal:function(_771){
-s.hideElement(_771.effects[0].element);
-d.undoPositioned(_771.effects[0].element);
-s.setStyle(_771.effects[0].element,_769);
-}},_768||{});
-var v=MochiKit.Visual;
-return new v.Parallel([new v.Move(_767,{x:0,y:100,sync:true}),new v.Opacity(_767,{sync:true,to:0})],_768);
-};
-MochiKit.Visual.shake=function(_772,_773){
-var d=MochiKit.DOM;
-var v=MochiKit.Visual;
-var s=MochiKit.Style;
-_772=d.getElement(_772);
-_773=MochiKit.Base.update({x:-20,y:0,duration:0.05,afterFinishInternal:function(_774){
-d.undoPositioned(_774.element);
-s.setStyle(_774.element,oldStyle);
-}},_773||{});
-var _775={top:s.getStyle(_772,"top"),left:s.getStyle(_772,"left")};
-return new v.Move(_772,{x:20,y:0,duration:0.05,afterFinishInternal:function(_776){
-new v.Move(_776.element,{x:-40,y:0,duration:0.1,afterFinishInternal:function(_776){
-new v.Move(_776.element,{x:40,y:0,duration:0.1,afterFinishInternal:function(_776){
-new v.Move(_776.element,{x:-40,y:0,duration:0.1,afterFinishInternal:function(_776){
-new v.Move(_776.element,{x:40,y:0,duration:0.1,afterFinishInternal:function(_776){
-new v.Move(_776.element,_773);
-}});
-}});
-}});
-}});
-}});
-};
-MochiKit.Visual.slideDown=function(_777,_778){
-var d=MochiKit.DOM;
-var b=MochiKit.Base;
-var s=MochiKit.Style;
-_777=d.getElement(_777);
-if(!_777.firstChild){
-throw "MochiKit.Visual.slideDown must be used on a element with a child";
-}
-d.removeEmptyTextNodes(_777);
-var _779=s.getStyle(_777.firstChild,"bottom")||0;
-var _780=s.getElementDimensions(_777);
-var _781;
-_778=b.update({scaleContent:false,scaleX:false,scaleFrom:0,scaleMode:{originalHeight:_780.h,originalWidth:_780.w},restoreAfterFinish:true,afterSetupInternal:function(_782){
-d.makePositioned(_782.element);
-d.makePositioned(_782.element.firstChild);
-if(/Opera/.test(navigator.userAgent)){
-s.setStyle(_782.element,{top:""});
-}
-_781=d.makeClipping(_782.element);
-s.setStyle(_782.element,{height:"0px"});
-s.showElement(_782.element);
-},afterUpdateInternal:function(_783){
-s.setStyle(_783.element.firstChild,{bottom:(_783.dims[0]-_783.element.clientHeight)+"px"});
-},afterFinishInternal:function(_784){
-d.undoClipping(_784.element,_781);
-if(/MSIE/.test(navigator.userAgent)){
-d.undoPositioned(_784.element);
-d.undoPositioned(_784.element.firstChild);
-}else{
-d.undoPositioned(_784.element.firstChild);
-d.undoPositioned(_784.element);
-}
-s.setStyle(_784.element.firstChild,{bottom:_779});
-}},_778||{});
-return new MochiKit.Visual.Scale(_777,100,_778);
-};
-MochiKit.Visual.slideUp=function(_785,_786){
-var d=MochiKit.DOM;
-var b=MochiKit.Base;
-var s=MochiKit.Style;
-_785=d.getElement(_785);
-if(!_785.firstChild){
-throw "MochiKit.Visual.slideUp must be used on a element with a child";
-}
-d.removeEmptyTextNodes(_785);
-var _787=s.getStyle(_785.firstChild,"bottom");
-var _788;
-_786=b.update({scaleContent:false,scaleX:false,scaleMode:"box",scaleFrom:100,restoreAfterFinish:true,beforeStartInternal:function(_789){
-d.makePositioned(_789.element);
-d.makePositioned(_789.element.firstChild);
-if(/Opera/.test(navigator.userAgent)){
-s.setStyle(_789.element,{top:""});
-}
-_788=d.makeClipping(_789.element);
-s.showElement(_789.element);
-},afterUpdateInternal:function(_790){
-s.setStyle(_790.element.firstChild,{bottom:(_790.dims[0]-_790.element.clientHeight)+"px"});
-},afterFinishInternal:function(_791){
-s.hideElement(_791.element);
-d.undoClipping(_791.element,_788);
-d.undoPositioned(_791.element.firstChild);
-d.undoPositioned(_791.element);
-s.setStyle(_791.element.firstChild,{bottom:_787});
-}},_786||{});
-return new MochiKit.Visual.Scale(_785,0,_786);
-};
-MochiKit.Visual.squish=function(_792,_793){
-var d=MochiKit.DOM;
-var b=MochiKit.Base;
-var _794;
-_793=b.update({restoreAfterFinish:true,beforeSetupInternal:function(_795){
-_794=d.makeClipping(_795.element);
-},afterFinishInternal:function(_796){
-MochiKit.Style.hideElement(_796.element);
-d.undoClipping(_796.element,_794);
-}},_793||{});
-return new MochiKit.Visual.Scale(_792,/Opera/.test(navigator.userAgent)?1:0,_793);
-};
-MochiKit.Visual.grow=function(_797,_798){
-var d=MochiKit.DOM;
-var v=MochiKit.Visual;
-var s=MochiKit.Style;
-_797=d.getElement(_797);
-_798=MochiKit.Base.update({direction:"center",moveTransition:v.Transitions.sinoidal,scaleTransition:v.Transitions.sinoidal,opacityTransition:v.Transitions.full},_798||{});
-var _799={top:_797.style.top,left:_797.style.left,height:_797.style.height,width:_797.style.width,opacity:_797.style.opacity||""};
-var dims=s.getElementDimensions(_797);
-var _801,initialMoveY;
-var _802,moveY;
-switch(_798.direction){
-case "top-left":
-_801=initialMoveY=_802=moveY=0;
-break;
-case "top-right":
-_801=dims.w;
-initialMoveY=moveY=0;
-_802=-dims.w;
-break;
-case "bottom-left":
-_801=_802=0;
-initialMoveY=dims.h;
-moveY=-dims.h;
-break;
-case "bottom-right":
-_801=dims.w;
-initialMoveY=dims.h;
-_802=-dims.w;
-moveY=-dims.h;
-break;
-case "center":
-_801=dims.w/2;
-initialMoveY=dims.h/2;
-_802=-dims.w/2;
-moveY=-dims.h/2;
-break;
-}
-var _803=MochiKit.Base.update({beforeSetupInternal:function(_804){
-s.setStyle(_804.effects[0].element,{height:"0px"});
-s.showElement(_804.effects[0].element);
-},afterFinishInternal:function(_805){
-d.undoClipping(_805.effects[0].element);
-d.undoPositioned(_805.effects[0].element);
-s.setStyle(_805.effects[0].element,_799);
-}},_798||{});
-return new v.Move(_797,{x:_801,y:initialMoveY,duration:0.01,beforeSetupInternal:function(_806){
-s.hideElement(_806.element);
-d.makeClipping(_806.element);
-d.makePositioned(_806.element);
-},afterFinishInternal:function(_807){
-new v.Parallel([new v.Opacity(_807.element,{sync:true,to:1,from:0,transition:_798.opacityTransition}),new v.Move(_807.element,{x:_802,y:moveY,sync:true,transition:_798.moveTransition}),new v.Scale(_807.element,100,{scaleMode:{originalHeight:dims.h,originalWidth:dims.w},sync:true,scaleFrom:/Opera/.test(navigator.userAgent)?1:0,transition:_798.scaleTransition,restoreAfterFinish:true})],_803);
-}});
-};
-MochiKit.Visual.shrink=function(_808,_809){
-var d=MochiKit.DOM;
-var v=MochiKit.Visual;
-var s=MochiKit.Style;
-_808=d.getElement(_808);
-_809=MochiKit.Base.update({direction:"center",moveTransition:v.Transitions.sinoidal,scaleTransition:v.Transitions.sinoidal,opacityTransition:v.Transitions.none},_809||{});
-var _810={top:_808.style.top,left:_808.style.left,height:_808.style.height,width:_808.style.width,opacity:_808.style.opacity||""};
-var dims=s.getElementDimensions(_808);
-var _811,moveY;
-switch(_809.direction){
-case "top-left":
-_811=moveY=0;
-break;
-case "top-right":
-_811=dims.w;
-moveY=0;
-break;
-case "bottom-left":
-_811=0;
-moveY=dims.h;
-break;
-case "bottom-right":
-_811=dims.w;
-moveY=dims.h;
-break;
-case "center":
-_811=dims.w/2;
-moveY=dims.h/2;
-break;
-}
-var _812;
-var _813=MochiKit.Base.update({beforeStartInternal:function(_814){
-_812=d.makePositioned(_814.effects[0].element);
-d.makeClipping(_814.effects[0].element);
-},afterFinishInternal:function(_815){
-s.hideElement(_815.effects[0].element);
-d.undoClipping(_815.effects[0].element,_812);
-d.undoPositioned(_815.effects[0].element);
-s.setStyle(_815.effects[0].element,_810);
-}},_809||{});
-return new v.Parallel([new v.Opacity(_808,{sync:true,to:0,from:1,transition:_809.opacityTransition}),new v.Scale(_808,/Opera/.test(navigator.userAgent)?1:0,{sync:true,transition:_809.scaleTransition,restoreAfterFinish:true}),new v.Move(_808,{x:_811,y:moveY,sync:true,transition:_809.moveTransition})],_813);
-};
-MochiKit.Visual.pulsate=function(_816,_817){
-var d=MochiKit.DOM;
-var v=MochiKit.Visual;
-var b=MochiKit.Base;
-var _818=d.getElement(_816).style.opacity||"";
-_817=b.update({duration:3,from:0,afterFinishInternal:function(_819){
-MochiKit.Style.setStyle(_819.element,{opacity:_818});
-}},_817||{});
-var _820=_817.transition||v.Transitions.sinoidal;
-var _821=b.bind(function(pos){
-return _820(1-v.Transitions.pulse(pos));
-},_820);
-b.bind(_821,_820);
-return new v.Opacity(_816,b.update({transition:_821},_817));
-};
-MochiKit.Visual.fold=function(_822,_823){
-var d=MochiKit.DOM;
-var v=MochiKit.Visual;
-var s=MochiKit.Style;
-_822=d.getElement(_822);
-var _824={top:_822.style.top,left:_822.style.left,width:_822.style.width,height:_822.style.height};
-var _825=d.makeClipping(_822);
-_823=MochiKit.Base.update({scaleContent:false,scaleX:false,afterFinishInternal:function(_826){
-new v.Scale(_822,1,{scaleContent:false,scaleY:false,afterFinishInternal:function(_826){
-s.hideElement(_826.element);
-d.undoClipping(_826.element,_825);
-s.setStyle(_826.element,_824);
-}});
-}},_823||{});
-return new v.Scale(_822,5,_823);
-};
-MochiKit.Visual.Color=MochiKit.Color.Color;
-MochiKit.Visual.getElementsComputedStyle=MochiKit.DOM.computedStyle;
-MochiKit.Visual.__new__=function(){
-var m=MochiKit.Base;
-m.nameFunctions(this);
-this.EXPORT_TAGS={":common":this.EXPORT,":all":m.concat(this.EXPORT,this.EXPORT_OK)};
-};
-MochiKit.Visual.EXPORT=["roundElement","roundClass","tagifyText","multiple","toggle","Base","Parallel","Opacity","Move","Scale","Highlight","ScrollTo","fade","appear","puff","blindUp","blindDown","switchOff","dropOut","shake","slideDown","slideUp","squish","grow","shrink","pulsate","fold"];
-MochiKit.Visual.EXPORT_OK=["PAIRS"];
-MochiKit.Visual.__new__();
-MochiKit.Base._exportSymbols(this,MochiKit.Visual);
-if(typeof (MochiKit)=="undefined"){
-MochiKit={};
-}
-if(typeof (MochiKit.MochiKit)=="undefined"){
-MochiKit.MochiKit={};
-}
-MochiKit.MochiKit.NAME="MochiKit.MochiKit";
-MochiKit.MochiKit.VERSION="1.4";
-MochiKit.MochiKit.__repr__=function(){
-return "["+this.NAME+" "+this.VERSION+"]";
-};
-MochiKit.MochiKit.toString=function(){
-return this.__repr__();
-};
-MochiKit.MochiKit.SUBMODULES=["Base","Iter","Logging","DateTime","Format","Async","DOM","Style","LoggingPane","Color","Signal","Visual"];
-if(typeof (JSAN)!="undefined"||typeof (dojo)!="undefined"){
-if(typeof (dojo)!="undefined"){
-dojo.provide("MochiKit.MochiKit");
-dojo.require("MochiKit.*");
-}
-if(typeof (JSAN)!="undefined"){
-(function(lst){
-for(var i=0;i");
-}
-}
-})();
-}
-
-
diff --git a/thirdpartyjs/MochiKit/MockDOM.js b/thirdpartyjs/MochiKit/MockDOM.js
index 471ef05..f9476ba 100644
--- a/thirdpartyjs/MochiKit/MockDOM.js
+++ b/thirdpartyjs/MochiKit/MockDOM.js
@@ -1,14 +1,15 @@
/***
-MochiKit.MockDOM 1.3.1
+MochiKit.MockDOM 1.4
See for documentation, downloads, license, etc.
(c) 2005 Bob Ippolito. All rights Reserved.
***/
+
if (typeof(MochiKit) == "undefined") {
- var MochiKit = {};
+ MochiKit = {};
}
if (typeof(MochiKit.MockDOM) == "undefined") {
@@ -16,16 +17,18 @@ if (typeof(MochiKit.MockDOM) == "undefined") {
}
MochiKit.MockDOM.NAME = "MochiKit.MockDOM";
-MochiKit.MockDOM.VERSION = "1.3.1";
+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");
@@ -33,9 +36,14 @@ MochiKit.MockDOM.createDocument = function () {
return doc;
};
-MochiKit.MockDOM.MockElement = function (name, data) {
- this.nodeName = name.toUpperCase();
- if (typeof(data) == "string") {
+/** @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 {
@@ -46,28 +54,62 @@ MochiKit.MockDOM.MockElement = function (name, data) {
var nameattr = name.substring(
name.indexOf('"') + 1, name.lastIndexOf('"'));
name = name.substring(1, name.indexOf(" "));
- this.nodeName = name.toUpperCase();
+ this.tagName = this.nodeName = name.toUpperCase();
this.setAttribute("name", nameattr);
}
};
MochiKit.MockDOM.MockElement.prototype = {
- createElement: function (nodeName) {
- return new MochiKit.MockDOM.MockElement(nodeName);
+ /** @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);
+ 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.nodeName + ")";
+ 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__();
diff --git a/thirdpartyjs/MochiKit/New.js b/thirdpartyjs/MochiKit/New.js
index 529f1e7..8b13789 100644
--- a/thirdpartyjs/MochiKit/New.js
+++ b/thirdpartyjs/MochiKit/New.js
@@ -1,283 +1 @@
-MochiKit.Base.update(MochiKit.DOM, {
- /** @id MochiKit.DOM.makeClipping */
- makeClipping: function (element) {
- element = MochiKit.DOM.getElement(element);
- var oldOverflow = element.style.overflow;
- if ((MochiKit.Style.getStyle(element, 'overflow') || 'visible') != 'hidden') {
- element.style.overflow = 'hidden';
- }
- return oldOverflow;
- },
-
- /** @id MochiKit.DOM.undoClipping */
- undoClipping: function (element, overflow) {
- element = MochiKit.DOM.getElement(element);
- if (!overflow) {
- return;
- }
- element.style.overflow = overflow;
- },
-
- /** @id MochiKit.DOM.makePositioned */
- makePositioned: function (element) {
- element = MochiKit.DOM.getElement(element);
- var pos = MochiKit.Style.getStyle(element, 'position');
- if (pos == 'static' || !pos) {
- element.style.position = 'relative';
- // Opera returns the offset relative to the positioning context,
- // when an element is position relative but top and left have
- // not been defined
- if (/Opera/.test(navigator.userAgent)) {
- element.style.top = 0;
- element.style.left = 0;
- }
- }
- },
-
- /** @id MochiKit.DOM.undoPositioned */
- undoPositioned: function (element) {
- element = MochiKit.DOM.getElement(element);
- if (element.style.position == 'relative') {
- element.style.position = element.style.top = element.style.left = element.style.bottom = element.style.right = '';
- }
- },
-
- /** @id MochiKit.DOM.getFirstElementByTagAndClassName */
- getFirstElementByTagAndClassName: function (tagName, className,
- /* optional */parent) {
- var self = MochiKit.DOM;
- if (typeof(tagName) == 'undefined' || tagName === null) {
- tagName = '*';
- }
- if (typeof(parent) == 'undefined' || parent === null) {
- parent = self._document;
- }
- parent = self.getElement(parent);
- var children = (parent.getElementsByTagName(tagName)
- || self._document.all);
- if (typeof(className) == 'undefined' || className === null) {
- return children[0];
- }
-
- for (var i = 0; i < children.length; i++) {
- var child = children[i];
- var classNames = child.className.split(' ');
- for (var j = 0; j < classNames.length; j++) {
- if (classNames[j] == className) {
- return child;
- }
- }
- }
- },
-
- /** @id MochiKit.DOM.isParent */
- isParent: function (child, element) {
- if (!child.parentNode || child == element) {
- return false;
- }
-
- if (child.parentNode == element) {
- return true;
- }
-
- return MochiKit.DOM.isParent(child.parentNode, element);
- }
-});
-
-MochiKit.Position = {
- // set to true if needed, warning: firefox performance problems
- // NOT neeeded for page scrolling, only if draggable contained in
- // scrollable elements
- includeScrollOffsets: false,
-
- /** @id MochiKit.Position.prepare */
- prepare: function () {
- var deltaX = window.pageXOffset
- || document.documentElement.scrollLeft
- || document.body.scrollLeft
- || 0;
- var deltaY = window.pageYOffset
- || document.documentElement.scrollTop
- || document.body.scrollTop
- || 0;
- this.windowOffset = new MochiKit.Style.Coordinates(deltaX, deltaY);
- },
-
- /** @id MochiKit.Position.cumulativeOffset */
- cumulativeOffset: function (element) {
- var valueT = 0;
- var valueL = 0;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- element = element.offsetParent;
- } while (element);
- return new MochiKit.Style.Coordinates(valueL, valueT);
- },
-
- /** @id MochiKit.Position.realOffset */
- realOffset: function (element) {
- var valueT = 0;
- var valueL = 0;
- do {
- valueT += element.scrollTop || 0;
- valueL += element.scrollLeft || 0;
- element = element.parentNode;
- } while (element);
- return new MochiKit.Style.Coordinates(valueL, valueT);
- },
-
- /** @id MochiKit.Position.within */
- within: function (element, x, y) {
- if (this.includeScrollOffsets) {
- return this.withinIncludingScrolloffsets(element, x, y);
- }
- this.xcomp = x;
- this.ycomp = y;
- this.offset = this.cumulativeOffset(element);
- if (element.style.position == "fixed") {
- this.offset.x += this.windowOffset.x;
- this.offset.y += this.windowOffset.y;
- }
-
- return (y >= this.offset.y &&
- y < this.offset.y + element.offsetHeight &&
- x >= this.offset.x &&
- x < this.offset.x + element.offsetWidth);
- },
-
- /** @id MochiKit.Position.withinIncludingScrolloffsets */
- withinIncludingScrolloffsets: function (element, x, y) {
- var offsetcache = this.realOffset(element);
-
- this.xcomp = x + offsetcache.x - this.windowOffset.x;
- this.ycomp = y + offsetcache.y - this.windowOffset.y;
- this.offset = this.cumulativeOffset(element);
-
- return (this.ycomp >= this.offset.y &&
- this.ycomp < this.offset.y + element.offsetHeight &&
- this.xcomp >= this.offset.x &&
- this.xcomp < this.offset.x + element.offsetWidth);
- },
-
- // within must be called directly before
- /** @id MochiKit.Position.overlap */
- overlap: function (mode, element) {
- if (!mode) {
- return 0;
- }
- if (mode == 'vertical') {
- return ((this.offset.y + element.offsetHeight) - this.ycomp) /
- element.offsetHeight;
- }
- if (mode == 'horizontal') {
- return ((this.offset.x + element.offsetWidth) - this.xcomp) /
- element.offsetWidth;
- }
- },
-
- /** @id MochiKit.Position.absolutize */
- absolutize: function (element) {
- element = MochiKit.DOM.getElement(element);
- if (element.style.position == 'absolute') {
- return;
- }
- MochiKit.Position.prepare();
-
- var offsets = MochiKit.Position.positionedOffset(element);
- var width = element.clientWidth;
- var height = element.clientHeight;
-
- var oldStyle = {
- 'position': element.style.position,
- 'left': offsets.x - parseFloat(element.style.left || 0),
- 'top': offsets.y - parseFloat(element.style.top || 0),
- 'width': element.style.width,
- 'height': element.style.height
- };
-
- element.style.position = 'absolute';
- element.style.top = offsets.y + 'px';
- element.style.left = offsets.x + 'px';
- element.style.width = width + 'px';
- element.style.height = height + 'px';
-
- return oldStyle;
- },
-
- /** @id MochiKit.Position.positionedOffset */
- positionedOffset: function (element) {
- var valueT = 0, valueL = 0;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- element = element.offsetParent;
- if (element) {
- p = MochiKit.Style.getStyle(element, 'position');
- if (p == 'relative' || p == 'absolute') {
- break;
- }
- }
- } while (element);
- return new MochiKit.Style.Coordinates(valueL, valueT);
- },
-
- /** @id MochiKit.Position.relativize */
- relativize: function (element, oldPos) {
- element = MochiKit.DOM.getElement(element);
- if (element.style.position == 'relative') {
- return;
- }
- MochiKit.Position.prepare();
-
- var top = parseFloat(element.style.top || 0) -
- (oldPos['top'] || 0);
- var left = parseFloat(element.style.left || 0) -
- (oldPos['left'] || 0);
-
- element.style.position = oldPos['position'];
- element.style.top = top + 'px';
- element.style.left = left + 'px';
- element.style.width = oldPos['width'];
- element.style.height = oldPos['height'];
- },
-
- /** @id MochiKit.Position.clone */
- clone: function (source, target) {
- source = MochiKit.DOM.getElement(source);
- target = MochiKit.DOM.getElement(target);
- target.style.position = 'absolute';
- var offsets = this.cumulativeOffset(source);
- target.style.top = offsets.y + 'px';
- target.style.left = offsets.x + 'px';
- target.style.width = source.offsetWidth + 'px';
- target.style.height = source.offsetHeight + 'px';
- },
-
- /** @id MochiKit.Position.page */
- page: function (forElement) {
- var valueT = 0;
- var valueL = 0;
-
- var element = forElement;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
-
- // Safari fix
- if (element.offsetParent == document.body && MochiKit.Style.getStyle(element, 'position') == 'absolute') {
- break;
- }
- } while (element = element.offsetParent);
-
- element = forElement;
- do {
- valueT -= element.scrollTop || 0;
- valueL -= element.scrollLeft || 0;
- } while (element = element.parentNode);
-
- return new MochiKit.Style.Coordinates(valueL, valueT);
- }
-};
-
diff --git a/thirdpartyjs/MochiKit/Position.js b/thirdpartyjs/MochiKit/Position.js
new file mode 100644
index 0000000..6092fe9
--- /dev/null
+++ b/thirdpartyjs/MochiKit/Position.js
@@ -0,0 +1,246 @@
+/***
+
+MochiKit.Position 1.4
+
+See for documentation, downloads, license, etc.
+
+(c) 2005-2006 Bob Ippolito and others. All rights Reserved.
+
+***/
+
+if (typeof(dojo) != 'undefined') {
+ dojo.provide('MochiKit.Position');
+ dojo.require('MochiKit.Base');
+ dojo.require('MochiKit.DOM');
+ dojo.require('MochiKit.Style');
+}
+if (typeof(JSAN) != 'undefined') {
+ JSAN.use('MochiKit.Base', []);
+ JSAN.use('MochiKit.DOM', []);
+ JSAN.use('MochiKit.Style', []);
+}
+
+try {
+ if (typeof(MochiKit.Base) == 'undefined' ||
+ typeof(MochiKit.Style) == 'undefined' ||
+ typeof(MochiKit.DOM) == 'undefined') {
+ throw '';
+ }
+} catch (e) {
+ throw 'MochiKit.Style depends on MochiKit.Base, MochiKit.DOM, and MochiKit.Style!';
+}
+
+if (typeof(MochiKit.Position) == 'undefined') {
+ MochiKit.Position = {};
+}
+
+MochiKit.Position.NAME = 'MochiKit.Position';
+MochiKit.Position.VERSION = '1.4';
+MochiKit.Position.__repr__ = function () {
+ return '[' + this.NAME + ' ' + this.VERSION + ']';
+};
+MochiKit.Position.toString = function () {
+ return this.__repr__();
+};
+
+MochiKit.Position.EXPORT_OK = [];
+
+MochiKit.Position.EXPORT = [
+];
+
+
+MochiKit.Base.update(MochiKit.Position, {
+ // set to true if needed, warning: firefox performance problems
+ // NOT neeeded for page scrolling, only if draggable contained in
+ // scrollable elements
+ includeScrollOffsets: false,
+
+ /** @id MochiKit.Position.prepare */
+ prepare: function () {
+ var deltaX = window.pageXOffset
+ || document.documentElement.scrollLeft
+ || document.body.scrollLeft
+ || 0;
+ var deltaY = window.pageYOffset
+ || document.documentElement.scrollTop
+ || document.body.scrollTop
+ || 0;
+ this.windowOffset = new MochiKit.Style.Coordinates(deltaX, deltaY);
+ },
+
+ /** @id MochiKit.Position.cumulativeOffset */
+ cumulativeOffset: function (element) {
+ var valueT = 0;
+ var valueL = 0;
+ do {
+ valueT += element.offsetTop || 0;
+ valueL += element.offsetLeft || 0;
+ element = element.offsetParent;
+ } while (element);
+ return new MochiKit.Style.Coordinates(valueL, valueT);
+ },
+
+ /** @id MochiKit.Position.realOffset */
+ realOffset: function (element) {
+ var valueT = 0;
+ var valueL = 0;
+ do {
+ valueT += element.scrollTop || 0;
+ valueL += element.scrollLeft || 0;
+ element = element.parentNode;
+ } while (element);
+ return new MochiKit.Style.Coordinates(valueL, valueT);
+ },
+
+ /** @id MochiKit.Position.within */
+ within: function (element, x, y) {
+ if (this.includeScrollOffsets) {
+ return this.withinIncludingScrolloffsets(element, x, y);
+ }
+ this.xcomp = x;
+ this.ycomp = y;
+ this.offset = this.cumulativeOffset(element);
+ if (element.style.position == "fixed") {
+ this.offset.x += this.windowOffset.x;
+ this.offset.y += this.windowOffset.y;
+ }
+
+ return (y >= this.offset.y &&
+ y < this.offset.y + element.offsetHeight &&
+ x >= this.offset.x &&
+ x < this.offset.x + element.offsetWidth);
+ },
+
+ /** @id MochiKit.Position.withinIncludingScrolloffsets */
+ withinIncludingScrolloffsets: function (element, x, y) {
+ var offsetcache = this.realOffset(element);
+
+ this.xcomp = x + offsetcache.x - this.windowOffset.x;
+ this.ycomp = y + offsetcache.y - this.windowOffset.y;
+ this.offset = this.cumulativeOffset(element);
+
+ return (this.ycomp >= this.offset.y &&
+ this.ycomp < this.offset.y + element.offsetHeight &&
+ this.xcomp >= this.offset.x &&
+ this.xcomp < this.offset.x + element.offsetWidth);
+ },
+
+ // within must be called directly before
+ /** @id MochiKit.Position.overlap */
+ overlap: function (mode, element) {
+ if (!mode) {
+ return 0;
+ }
+ if (mode == 'vertical') {
+ return ((this.offset.y + element.offsetHeight) - this.ycomp) /
+ element.offsetHeight;
+ }
+ if (mode == 'horizontal') {
+ return ((this.offset.x + element.offsetWidth) - this.xcomp) /
+ element.offsetWidth;
+ }
+ },
+
+ /** @id MochiKit.Position.absolutize */
+ absolutize: function (element) {
+ element = MochiKit.DOM.getElement(element);
+ if (element.style.position == 'absolute') {
+ return;
+ }
+ MochiKit.Position.prepare();
+
+ var offsets = MochiKit.Position.positionedOffset(element);
+ var width = element.clientWidth;
+ var height = element.clientHeight;
+
+ var oldStyle = {
+ 'position': element.style.position,
+ 'left': offsets.x - parseFloat(element.style.left || 0),
+ 'top': offsets.y - parseFloat(element.style.top || 0),
+ 'width': element.style.width,
+ 'height': element.style.height
+ };
+
+ element.style.position = 'absolute';
+ element.style.top = offsets.y + 'px';
+ element.style.left = offsets.x + 'px';
+ element.style.width = width + 'px';
+ element.style.height = height + 'px';
+
+ return oldStyle;
+ },
+
+ /** @id MochiKit.Position.positionedOffset */
+ positionedOffset: function (element) {
+ var valueT = 0, valueL = 0;
+ do {
+ valueT += element.offsetTop || 0;
+ valueL += element.offsetLeft || 0;
+ element = element.offsetParent;
+ if (element) {
+ p = MochiKit.Style.getStyle(element, 'position');
+ if (p == 'relative' || p == 'absolute') {
+ break;
+ }
+ }
+ } while (element);
+ return new MochiKit.Style.Coordinates(valueL, valueT);
+ },
+
+ /** @id MochiKit.Position.relativize */
+ relativize: function (element, oldPos) {
+ element = MochiKit.DOM.getElement(element);
+ if (element.style.position == 'relative') {
+ return;
+ }
+ MochiKit.Position.prepare();
+
+ var top = parseFloat(element.style.top || 0) -
+ (oldPos['top'] || 0);
+ var left = parseFloat(element.style.left || 0) -
+ (oldPos['left'] || 0);
+
+ element.style.position = oldPos['position'];
+ element.style.top = top + 'px';
+ element.style.left = left + 'px';
+ element.style.width = oldPos['width'];
+ element.style.height = oldPos['height'];
+ },
+
+ /** @id MochiKit.Position.clone */
+ clone: function (source, target) {
+ source = MochiKit.DOM.getElement(source);
+ target = MochiKit.DOM.getElement(target);
+ target.style.position = 'absolute';
+ var offsets = this.cumulativeOffset(source);
+ target.style.top = offsets.y + 'px';
+ target.style.left = offsets.x + 'px';
+ target.style.width = source.offsetWidth + 'px';
+ target.style.height = source.offsetHeight + 'px';
+ },
+
+ /** @id MochiKit.Position.page */
+ page: function (forElement) {
+ var valueT = 0;
+ var valueL = 0;
+
+ var element = forElement;
+ do {
+ valueT += element.offsetTop || 0;
+ valueL += element.offsetLeft || 0;
+
+ // Safari fix
+ if (element.offsetParent == document.body && MochiKit.Style.getStyle(element, 'position') == 'absolute') {
+ break;
+ }
+ } while (element = element.offsetParent);
+
+ element = forElement;
+ do {
+ valueT -= element.scrollTop || 0;
+ valueL -= element.scrollLeft || 0;
+ } while (element = element.parentNode);
+
+ return new MochiKit.Style.Coordinates(valueL, valueT);
+ }
+});
diff --git a/thirdpartyjs/MochiKit/Selector.js b/thirdpartyjs/MochiKit/Selector.js
new file mode 100644
index 0000000..085c531
--- /dev/null
+++ b/thirdpartyjs/MochiKit/Selector.js
@@ -0,0 +1,400 @@
+/***
+
+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.0";
+MochiKit.Selector.__repr__ = function () {
+ return "[" + this.NAME + " " + this.VERSION + "]";
+};
+MochiKit.Selector.toString = function () {
+ return this.__repr__();
+};
+
+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 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 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 + ' && ' + value + '.split(' + repr(delimiter) + ')';
+ }
+
+ switch (attribute.operator) {
+ case '=':
+ conditions.push(value + ' == ' + repr(attribute.value));
+ break;
+ case '~=':
+ conditions.push('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(
+ 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 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 || 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));
+ }
+
+});
+
+function $$() {
+ return MochiKit.Selector.findChildElements(MochiKit.DOM.currentDocument(), arguments);
+}
+
diff --git a/thirdpartyjs/MochiKit/Signal.js b/thirdpartyjs/MochiKit/Signal.js
index 5624b3d..74199c1 100644
--- a/thirdpartyjs/MochiKit/Signal.js
+++ b/thirdpartyjs/MochiKit/Signal.js
@@ -1,6 +1,6 @@
/***
-MochiKit.Signal 1.3.1
+MochiKit.Signal 1.4
See for documentation, downloads, license, etc.
@@ -12,10 +12,12 @@ if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Signal');
dojo.require('MochiKit.Base');
dojo.require('MochiKit.DOM');
+ dojo.require('MochiKit.Style');
}
if (typeof(JSAN) != 'undefined') {
JSAN.use('MochiKit.Base', []);
JSAN.use('MochiKit.DOM', []);
+ JSAN.use('MochiKit.Style', []);
}
try {
@@ -34,15 +36,24 @@ try {
throw 'MochiKit.Signal depends on MochiKit.DOM!';
}
+try {
+ if (typeof(MochiKit.Style) == 'undefined') {
+ throw '';
+ }
+} catch (e) {
+ throw 'MochiKit.Signal depends on MochiKit.Style!';
+}
+
if (typeof(MochiKit.Signal) == 'undefined') {
MochiKit.Signal = {};
}
MochiKit.Signal.NAME = 'MochiKit.Signal';
-MochiKit.Signal.VERSION = '1.3.1';
+MochiKit.Signal.VERSION = '1.4';
MochiKit.Signal._observers = [];
+/** @id MochiKit.Signal.Event */
MochiKit.Signal.Event = function (src, e) {
this._event = e || window.event;
this._src = src;
@@ -50,18 +61,18 @@ MochiKit.Signal.Event = function (src, e) {
MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
- __repr__: function() {
+ __repr__: function () {
var repr = MochiKit.Base.repr;
var str = '{event(): ' + repr(this.event()) +
- ', src(): ' + repr(this.src()) +
+ ', src(): ' + repr(this.src()) +
', type(): ' + repr(this.type()) +
', target(): ' + repr(this.target()) +
', modifier(): ' + '{alt: ' + repr(this.modifier().alt) +
', ctrl: ' + repr(this.modifier().ctrl) +
', meta: ' + repr(this.modifier().meta) +
- ', shift: ' + repr(this.modifier().shift) +
+ ', shift: ' + repr(this.modifier().shift) +
', any: ' + repr(this.modifier().any) + '}';
-
+
if (this.type() && this.type().indexOf('key') === 0) {
str += ', key(): {code: ' + repr(this.key().code) +
', string: ' + repr(this.key().string) + '}';
@@ -90,108 +101,135 @@ MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
return str;
},
+ /** @id MochiKit.Signal.Event.prototype.toString */
toString: function () {
return this.__repr__();
},
+ /** @id MochiKit.Signal.Event.prototype.src */
src: function () {
return this._src;
},
+ /** @id MochiKit.Signal.Event.prototype.event */
event: function () {
return this._event;
},
+ /** @id MochiKit.Signal.Event.prototype.type */
type: function () {
return this._event.type || undefined;
},
+ /** @id MochiKit.Signal.Event.prototype.target */
target: function () {
return this._event.target || this._event.srcElement;
},
+ _relatedTarget: null,
+ /** @id MochiKit.Signal.Event.prototype.relatedTarget */
relatedTarget: function () {
+ if (this._relatedTarget !== null) {
+ return this._relatedTarget;
+ }
+
+ var elem = null;
if (this.type() == 'mouseover') {
- return (this._event.relatedTarget ||
+ elem = (this._event.relatedTarget ||
this._event.fromElement);
} else if (this.type() == 'mouseout') {
- return (this._event.relatedTarget ||
+ elem = (this._event.relatedTarget ||
this._event.toElement);
}
- // throw new Error("relatedTarget only available for 'mouseover' and 'mouseout'");
+ if (elem !== null) {
+ this._relatedTarget = elem;
+ return elem;
+ }
+
return undefined;
},
+ _modifier: null,
+ /** @id MochiKit.Signal.Event.prototype.modifier */
modifier: function () {
+ if (this._modifier !== null) {
+ return this._modifier;
+ }
var m = {};
m.alt = this._event.altKey;
m.ctrl = this._event.ctrlKey;
m.meta = this._event.metaKey || false; // IE and Opera punt here
m.shift = this._event.shiftKey;
m.any = m.alt || m.ctrl || m.shift || m.meta;
+ this._modifier = m;
return m;
},
+ _key: null,
+ /** @id MochiKit.Signal.Event.prototype.key */
key: function () {
+ if (this._key !== null) {
+ return this._key;
+ }
var k = {};
if (this.type() && this.type().indexOf('key') === 0) {
/*
- If you're looking for a special key, look for it in keydown or
+ If you're looking for a special key, look for it in keydown or
keyup, but never keypress. If you're looking for a Unicode
chracter, look for it with keypress, but never keyup or
keydown.
-
- Notes:
-
- FF key event behavior:
- key event charCode keyCode
- DOWN ku,kd 0 40
- DOWN kp 0 40
- ESC ku,kd 0 27
- ESC kp 0 27
- a ku,kd 0 65
- a kp 97 0
- shift+a ku,kd 0 65
- shift+a kp 65 0
- 1 ku,kd 0 49
- 1 kp 49 0
- shift+1 ku,kd 0 0
- shift+1 kp 33 0
-
- IE key event behavior:
- (IE doesn't fire keypress events for special keys.)
- key event keyCode
- DOWN ku,kd 40
- DOWN kp undefined
- ESC ku,kd 27
- ESC kp 27
- a ku,kd 65
- a kp 97
- shift+a ku,kd 65
- shift+a kp 65
- 1 ku,kd 49
- 1 kp 49
- shift+1 ku,kd 49
- shift+1 kp 33
-
- Safari key event behavior:
- (Safari sets charCode and keyCode to something crazy for
- special keys.)
- key event charCode keyCode
- DOWN ku,kd 63233 40
- DOWN kp 63233 63233
- ESC ku,kd 27 27
- ESC kp 27 27
- a ku,kd 97 65
- a kp 97 97
- shift+a ku,kd 65 65
- shift+a kp 65 65
- 1 ku,kd 49 49
- 1 kp 49 49
- shift+1 ku,kd 33 49
- shift+1 kp 33 33
+
+ Notes:
+
+ FF key event behavior:
+ key event charCode keyCode
+ DOWN ku,kd 0 40
+ DOWN kp 0 40
+ ESC ku,kd 0 27
+ ESC kp 0 27
+ a ku,kd 0 65
+ a kp 97 0
+ shift+a ku,kd 0 65
+ shift+a kp 65 0
+ 1 ku,kd 0 49
+ 1 kp 49 0
+ shift+1 ku,kd 0 0
+ shift+1 kp 33 0
+
+ IE key event behavior:
+ (IE doesn't fire keypress events for special keys.)
+ key event keyCode
+ DOWN ku,kd 40
+ DOWN kp undefined
+ ESC ku,kd 27
+ ESC kp 27
+ a ku,kd 65
+ a kp 97
+ shift+a ku,kd 65
+ shift+a kp 65
+ 1 ku,kd 49
+ 1 kp 49
+ shift+1 ku,kd 49
+ shift+1 kp 33
+
+ Safari key event behavior:
+ (Safari sets charCode and keyCode to something crazy for
+ special keys.)
+ key event charCode keyCode
+ DOWN ku,kd 63233 40
+ DOWN kp 63233 63233
+ ESC ku,kd 27 27
+ ESC kp 27 27
+ a ku,kd 97 65
+ a kp 97 97
+ shift+a ku,kd 65 65
+ shift+a kp 65 65
+ 1 ku,kd 49 49
+ 1 kp 49 49
+ shift+1 ku,kd 33 49
+ shift+1 kp 33 33
*/
@@ -200,91 +238,89 @@ MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
k.code = this._event.keyCode;
k.string = (MochiKit.Signal._specialKeys[k.code] ||
'KEY_UNKNOWN');
+ this._key = k;
return k;
-
+
/* look for characters here */
} else if (this.type() == 'keypress') {
-
+
/*
-
+
Special key behavior:
-
+
IE: does not fire keypress events for special keys
FF: sets charCode to 0, and sets the correct keyCode
Safari: sets keyCode and charCode to something stupid
-
+
*/
-
+
k.code = 0;
k.string = '';
-
- if (typeof(this._event.charCode) != 'undefined' &&
+
+ if (typeof(this._event.charCode) != 'undefined' &&
this._event.charCode !== 0 &&
!MochiKit.Signal._specialMacKeys[this._event.charCode]) {
k.code = this._event.charCode;
k.string = String.fromCharCode(k.code);
- } else if (this._event.keyCode &&
+ } else if (this._event.keyCode &&
typeof(this._event.charCode) == 'undefined') { // IE
k.code = this._event.keyCode;
k.string = String.fromCharCode(k.code);
}
-
+
+ this._key = k;
return k;
}
}
- // throw new Error('This is not a key event');
return undefined;
},
+ _mouse: null,
+ /** @id MochiKit.Signal.Event.prototype.mouse */
mouse: function () {
+ if (this._mouse !== null) {
+ return this._mouse;
+ }
+
var m = {};
var e = this._event;
-
+
if (this.type() && (
this.type().indexOf('mouse') === 0 ||
this.type().indexOf('click') != -1 ||
this.type() == 'contextmenu')) {
-
- m.client = new MochiKit.DOM.Coordinates(0, 0);
+
+ m.client = new MochiKit.Style.Coordinates(0, 0);
if (e.clientX || e.clientY) {
m.client.x = (!e.clientX || e.clientX < 0) ? 0 : e.clientX;
m.client.y = (!e.clientY || e.clientY < 0) ? 0 : e.clientY;
}
- m.page = new MochiKit.DOM.Coordinates(0, 0);
+ m.page = new MochiKit.Style.Coordinates(0, 0);
if (e.pageX || e.pageY) {
m.page.x = (!e.pageX || e.pageX < 0) ? 0 : e.pageX;
m.page.y = (!e.pageY || e.pageY < 0) ? 0 : e.pageY;
} else {
/*
-
- IE keeps the document offset in:
- document.documentElement.clientTop ||
- document.body.clientTop
-
- and:
- document.documentElement.clientLeft ||
- document.body.clientLeft
-
- see:
- http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
-
- The offset is (2,2) in standards mode and (0,0) in quirks
- mode.
-
+
+ The IE shortcut can be off by two. We fix it. See:
+ http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
+
+ This is similar to the method used in
+ MochiKit.Style.getElementPosition().
+
*/
-
var de = MochiKit.DOM._document.documentElement;
var b = MochiKit.DOM._document.body;
-
+
m.page.x = e.clientX +
- (de.scrollLeft || b.scrollLeft) -
- (de.clientLeft || b.clientLeft);
-
+ (de.scrollLeft || b.scrollLeft) -
+ (de.clientLeft || 0);
+
m.page.y = e.clientY +
- (de.scrollTop || b.scrollTop) -
- (de.clientTop || b.clientTop);
-
+ (de.scrollTop || b.scrollTop) -
+ (de.clientTop || 0);
+
}
if (this.type() != 'mousemove') {
m.button = {};
@@ -299,39 +335,41 @@ MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
m.button.right = (e.which == 3);
/*
-
- Mac browsers and right click:
-
- - Safari doesn't fire any click events on a right
- click:
- http://bugzilla.opendarwin.org/show_bug.cgi?id=6595
-
- - Firefox fires the event, and sets ctrlKey = true
-
- - Opera fires the event, and sets metaKey = true
-
- oncontextmenu is fired on right clicks between
- browsers and across platforms.
-
+
+ Mac browsers and right click:
+
+ - Safari doesn't fire any click events on a right
+ click:
+ http://bugzilla.opendarwin.org/show_bug.cgi?id=6595
+
+ - Firefox fires the event, and sets ctrlKey = true
+
+ - Opera fires the event, and sets metaKey = true
+
+ oncontextmenu is fired on right clicks between
+ browsers and across platforms.
+
*/
-
+
} else {
m.button.left = !!(e.button & 1);
m.button.right = !!(e.button & 2);
m.button.middle = !!(e.button & 4);
}
}
+ this._mouse = m;
return m;
}
- // throw new Error('This is not a mouse event');
return undefined;
},
+ /** @id MochiKit.Signal.Event.prototype.stop */
stop: function () {
this.stopPropagation();
this.preventDefault();
},
+ /** @id MochiKit.Signal.Event.prototype.stopPropagation */
stopPropagation: function () {
if (this._event.stopPropagation) {
this._event.stopPropagation();
@@ -340,14 +378,24 @@ MochiKit.Base.update(MochiKit.Signal.Event.prototype, {
}
},
+ /** @id MochiKit.Signal.Event.prototype.preventDefault */
preventDefault: function () {
if (this._event.preventDefault) {
this._event.preventDefault();
- } else {
+ } else if (this._confirmUnload === null) {
this._event.returnValue = false;
}
- }
+ },
+ _confirmUnload: null,
+
+ /** @id MochiKit.Signal.Event.prototype.confirmUnload */
+ confirmUnload: function (msg) {
+ if (this.type() == 'beforeunload') {
+ this._confirmUnload = msg;
+ this._event.returnValue = msg;
+ }
+ }
});
/* Safari sets keyCode to these special values onkeypress. */
@@ -367,9 +415,13 @@ MochiKit.Signal._specialMacKeys = {
};
/* for KEY_F1 - KEY_F12 */
-for (i = 63236; i <= 63242; i++) {
- MochiKit.Signal._specialMacKeys[i] = 'KEY_F' + (i - 63236 + 1); // no F0
-}
+(function () {
+ var _specialMacKeys = MochiKit.Signal._specialMacKeys;
+ for (i = 63236; i <= 63242; i++) {
+ // no F0
+ _specialMacKeys[i] = 'KEY_F' + (i - 63236 + 1);
+ }
+})();
/* Standard keyboard key codes. */
MochiKit.Signal._specialKeys = {
@@ -392,13 +444,13 @@ MochiKit.Signal._specialKeys = {
38: 'KEY_ARROW_UP',
39: 'KEY_ARROW_RIGHT',
40: 'KEY_ARROW_DOWN',
- 44: 'KEY_PRINT_SCREEN',
+ 44: 'KEY_PRINT_SCREEN',
45: 'KEY_INSERT',
46: 'KEY_DELETE',
59: 'KEY_SEMICOLON', // weird, for Safari and IE only
- 91: 'KEY_WINDOWS_LEFT',
- 92: 'KEY_WINDOWS_RIGHT',
- 93: 'KEY_SELECT',
+ 91: 'KEY_WINDOWS_LEFT',
+ 92: 'KEY_WINDOWS_RIGHT',
+ 93: 'KEY_SELECT',
106: 'KEY_NUM_PAD_ASTERISK',
107: 'KEY_NUM_PAD_PLUS_SIGN',
109: 'KEY_NUM_PAD_HYPHEN-MINUS',
@@ -420,25 +472,29 @@ MochiKit.Signal._specialKeys = {
// undefined: 'KEY_UNKNOWN'
};
-/* for KEY_0 - KEY_9 */
-for (var i = 48; i <= 57; i++) {
- MochiKit.Signal._specialKeys[i] = 'KEY_' + (i - 48);
-}
+(function () {
+ /* for KEY_0 - KEY_9 */
+ var _specialKeys = MochiKit.Signal._specialKeys;
+ for (var i = 48; i <= 57; i++) {
+ _specialKeys[i] = 'KEY_' + (i - 48);
+ }
-/* for KEY_A - KEY_Z */
-for (i = 65; i <= 90; i++) {
- MochiKit.Signal._specialKeys[i] = 'KEY_' + String.fromCharCode(i);
-}
+ /* for KEY_A - KEY_Z */
+ for (i = 65; i <= 90; i++) {
+ _specialKeys[i] = 'KEY_' + String.fromCharCode(i);
+ }
-/* for KEY_NUM_PAD_0 - KEY_NUM_PAD_9 */
-for (i = 96; i <= 105; i++) {
- MochiKit.Signal._specialKeys[i] = 'KEY_NUM_PAD_' + (i - 96);
-}
+ /* for KEY_NUM_PAD_0 - KEY_NUM_PAD_9 */
+ for (i = 96; i <= 105; i++) {
+ _specialKeys[i] = 'KEY_NUM_PAD_' + (i - 96);
+ }
-/* for KEY_F1 - KEY_F12 */
-for (i = 112; i <= 123; i++) {
- MochiKit.Signal._specialKeys[i] = 'KEY_F' + (i - 112 + 1); // no F0
-}
+ /* for KEY_F1 - KEY_F12 */
+ for (i = 112; i <= 123; i++) {
+ // no F0
+ _specialKeys[i] = 'KEY_F' + (i - 112 + 1);
+ }
+})();
MochiKit.Base.update(MochiKit.Signal, {
@@ -453,13 +509,13 @@ MochiKit.Base.update(MochiKit.Signal, {
_unloadCache: function () {
var self = MochiKit.Signal;
var observers = self._observers;
-
+
for (var i = 0; i < observers.length; i++) {
self._disconnect(observers[i]);
}
-
+
delete self._observers;
-
+
try {
window.onload = undefined;
} catch(e) {
@@ -474,10 +530,11 @@ MochiKit.Base.update(MochiKit.Signal, {
},
_listener: function (src, func, obj, isDOM) {
- var E = MochiKit.Signal.Event;
+ var self = MochiKit.Signal;
+ var E = self.Event;
if (!isDOM) {
return MochiKit.Base.bind(func, obj);
- }
+ }
obj = obj || src;
if (typeof(func) == "string") {
return function (nativeEvent) {
@@ -489,15 +546,39 @@ MochiKit.Base.update(MochiKit.Signal, {
};
}
},
-
- connect: function (src, sig, objOrFunc/* optional */, funcOrStr) {
- src = MochiKit.DOM.getElement(src);
- var self = MochiKit.Signal;
-
- if (typeof(sig) != 'string') {
- throw new Error("'sig' must be a string");
- }
-
+
+ _browserAlreadyHasMouseEnterAndLeave: function () {
+ return /MSIE/.test(navigator.userAgent);
+ },
+
+ _mouseEnterListener: function (src, sig, func, obj) {
+ var E = MochiKit.Signal.Event;
+ return function (nativeEvent) {
+ var e = new E(src, nativeEvent);
+ try {
+ e.relatedTarget().nodeName;
+ } catch (err) {
+ /* probably hit a permission denied error; possibly one of
+ * firefox's screwy anonymous DIVs inside an input element.
+ * Allow this event to propogate up.
+ */
+ return;
+ }
+ e.stop();
+ if (MochiKit.DOM.isChildNode(e.relatedTarget(), src)) {
+ /* We've moved between our node and a child. Ignore. */
+ return;
+ }
+ e.type = function () { return sig; };
+ if (typeof(func) == "string") {
+ return obj[func].apply(obj, [e]);
+ } else {
+ return func.apply(obj, [e]);
+ }
+ };
+ },
+
+ _getDestPair: function (objOrFunc, funcOrStr) {
var obj = null;
var func = null;
if (typeof(funcOrStr) != 'undefined') {
@@ -515,27 +596,62 @@ MochiKit.Base.update(MochiKit.Signal, {
} else {
func = objOrFunc;
}
+ return [obj, func];
+
+ },
+
+ /** @id MochiKit.Signal.connect */
+ connect: function (src, sig, objOrFunc/* optional */, funcOrStr) {
+ src = MochiKit.DOM.getElement(src);
+ var self = MochiKit.Signal;
+
+ if (typeof(sig) != 'string') {
+ throw new Error("'sig' must be a string");
+ }
+
+ var destPair = self._getDestPair(objOrFunc, funcOrStr);
+ var obj = destPair[0];
+ var func = destPair[1];
if (typeof(obj) == 'undefined' || obj === null) {
obj = src;
}
-
+
var isDOM = !!(src.addEventListener || src.attachEvent);
- var listener = self._listener(src, func, obj, isDOM);
-
+ if (isDOM && (sig === "onmouseenter" || sig === "onmouseleave")
+ && !self._browserAlreadyHasMouseEnterAndLeave()) {
+ var listener = self._mouseEnterListener(src, sig.substr(2), func, obj);
+ if (sig === "onmouseenter") {
+ sig = "onmouseover";
+ } else {
+ sig = "onmouseout";
+ }
+ } else {
+ var listener = self._listener(src, func, obj, isDOM);
+ }
+
if (src.addEventListener) {
src.addEventListener(sig.substr(2), listener, false);
} else if (src.attachEvent) {
src.attachEvent(sig, listener); // useCapture unsupported
}
- var ident = [src, sig, listener, isDOM, objOrFunc, funcOrStr];
+ var ident = [src, sig, listener, isDOM, objOrFunc, funcOrStr, true];
self._observers.push(ident);
-
-
+
+
+ if (!isDOM && typeof(src.__connect__) == 'function') {
+ var args = MochiKit.Base.extend([ident], arguments, 1);
+ src.__connect__.apply(src, args);
+ }
+
+
return ident;
},
-
+
_disconnect: function (ident) {
+ // already disconnected
+ if (!ident[6]) { return; }
+ ident[6] = false;
// check isDOM
if (!ident[3]) { return; }
var src = ident[0];
@@ -549,7 +665,8 @@ MochiKit.Base.update(MochiKit.Signal, {
throw new Error("'src' must be a DOM element");
}
},
-
+
+ /** @id MochiKit.Signal.disconnect */
disconnect: function (ident) {
var self = MochiKit.Signal;
var observers = self._observers;
@@ -564,7 +681,11 @@ MochiKit.Base.update(MochiKit.Signal, {
var o = observers[i];
if (o[0] === src && o[1] === sig && o[4] === obj && o[5] === func) {
self._disconnect(o);
- observers.splice(i, 1);
+ if (!self._lock) {
+ observers.splice(i, 1);
+ } else {
+ self._dirty = true;
+ }
return true;
}
}
@@ -572,50 +693,94 @@ MochiKit.Base.update(MochiKit.Signal, {
var idx = m.findIdentical(observers, ident);
if (idx >= 0) {
self._disconnect(ident);
- observers.splice(idx, 1);
+ if (!self._lock) {
+ observers.splice(idx, 1);
+ } else {
+ self._dirty = true;
+ }
return true;
}
}
return false;
},
-
- disconnectAll: function(src/* optional */, sig) {
+
+ /** @id MochiKit.Signal.disconnectAllTo */
+ disconnectAllTo: function (objOrFunc, /* optional */funcOrStr) {
+ var self = MochiKit.Signal;
+ var observers = self._observers;
+ var disconnect = self._disconnect;
+ var locked = self._lock;
+ var dirty = self._dirty;
+ if (typeof(funcOrStr) === 'undefined') {
+ funcOrStr = null;
+ }
+ for (var i = observers.length - 1; i >= 0; i--) {
+ var ident = observers[i];
+ if (ident[4] === objOrFunc &&
+ (funcOrStr === null || ident[5] === funcOrStr)) {
+ disconnect(ident);
+ if (locked) {
+ dirty = true;
+ } else {
+ observers.splice(i, 1);
+ }
+ }
+ }
+ self._dirty = dirty;
+ },
+
+ /** @id MochiKit.Signal.disconnectAll */
+ disconnectAll: function (src/* optional */, sig) {
src = MochiKit.DOM.getElement(src);
var m = MochiKit.Base;
var signals = m.flattenArguments(m.extend(null, arguments, 1));
var self = MochiKit.Signal;
var disconnect = self._disconnect;
var observers = self._observers;
+ var i, ident;
+ var locked = self._lock;
+ var dirty = self._dirty;
if (signals.length === 0) {
// disconnect all
- for (var i = observers.length - 1; i >= 0; i--) {
- var ident = observers[i];
+ for (i = observers.length - 1; i >= 0; i--) {
+ ident = observers[i];
if (ident[0] === src) {
disconnect(ident);
- observers.splice(i, 1);
+ if (!locked) {
+ observers.splice(i, 1);
+ } else {
+ dirty = true;
+ }
}
}
} else {
var sigs = {};
- for (var i = 0; i < signals.length; i++) {
+ for (i = 0; i < signals.length; i++) {
sigs[signals[i]] = true;
}
- for (var i = observers.length - 1; i >= 0; i--) {
- var ident = observers[i];
+ for (i = observers.length - 1; i >= 0; i--) {
+ ident = observers[i];
if (ident[0] === src && ident[1] in sigs) {
disconnect(ident);
- observers.splice(i, 1);
+ if (!locked) {
+ observers.splice(i, 1);
+ } else {
+ dirty = true;
+ }
}
}
}
-
+ self._dirty = dirty;
},
+ /** @id MochiKit.Signal.signal */
signal: function (src, sig) {
- var observers = MochiKit.Signal._observers;
+ var self = MochiKit.Signal;
+ var observers = self._observers;
src = MochiKit.DOM.getElement(src);
var args = MochiKit.Base.extend(null, arguments, 2);
var errors = [];
+ self._lock = true;
for (var i = 0; i < observers.length; i++) {
var ident = observers[i];
if (ident[0] === src && ident[1] === sig) {
@@ -626,6 +791,15 @@ MochiKit.Base.update(MochiKit.Signal, {
}
}
}
+ self._lock = false;
+ if (self._dirty) {
+ self._dirty = false;
+ for (var i = observers.length - 1; i >= 0; i--) {
+ if (!observers[i][6]) {
+ observers.splice(i, 1);
+ }
+ }
+ }
if (errors.length == 1) {
throw errors[0];
} else if (errors.length > 1) {
@@ -643,13 +817,16 @@ MochiKit.Signal.EXPORT = [
'connect',
'disconnect',
'signal',
- 'disconnectAll'
+ 'disconnectAll',
+ 'disconnectAllTo'
];
MochiKit.Signal.__new__ = function (win) {
var m = MochiKit.Base;
this._document = document;
this._window = win;
+ this._lock = false;
+ this._dirty = false;
try {
this.connect(window, 'onunload', this._unloadCache);
@@ -670,7 +847,7 @@ MochiKit.Signal.__new__(this);
//
// XXX: Internet Explorer blows
//
-if (!MochiKit.__compat__) {
+if (MochiKit.__export__) {
connect = MochiKit.Signal.connect;
disconnect = MochiKit.Signal.disconnect;
disconnectAll = MochiKit.Signal.disconnectAll;
diff --git a/thirdpartyjs/MochiKit/Sortable.js b/thirdpartyjs/MochiKit/Sortable.js
index 1a6d7ce..44a60cd 100644
--- a/thirdpartyjs/MochiKit/Sortable.js
+++ b/thirdpartyjs/MochiKit/Sortable.js
@@ -7,7 +7,7 @@ See scriptaculous.js for full license.
***/
if (typeof(dojo) != 'undefined') {
- dojo.provide('MochiKit.DragAndDrop');
+ dojo.provide('MochiKit.Sortable');
dojo.require('MochiKit.Base');
dojo.require('MochiKit.DOM');
dojo.require('MochiKit.Iter');
@@ -47,11 +47,10 @@ MochiKit.Sortable.toString = function () {
MochiKit.Sortable.EXPORT = [
];
-MochiKit.DragAndDrop.EXPORT_OK = [
- "Sortable"
+MochiKit.Sortable.EXPORT_OK = [
];
-MochiKit.Sortable.Sortable = {
+MochiKit.Base.update(MochiKit.Sortable, {
/***
Manage sortables. Mainly use the create function to add a sortable.
@@ -61,25 +60,25 @@ MochiKit.Sortable.Sortable = {
_findRootElement: function (element) {
while (element.tagName.toUpperCase() != "BODY") {
- if (element.id && MochiKit.Sortable.Sortable.sortables[element.id]) {
+ if (element.id && MochiKit.Sortable.sortables[element.id]) {
return element;
}
element = element.parentNode;
}
},
- /** @id MochiKit.Sortable.Sortable.options */
+ /** @id MochiKit.Sortable.options */
options: function (element) {
- element = MochiKit.Sortable.Sortable._findRootElement(MochiKit.DOM.getElement(element));
+ element = MochiKit.Sortable._findRootElement(MochiKit.DOM.getElement(element));
if (!element) {
return;
}
- return MochiKit.Sortable.Sortable.sortables[element.id];
+ return MochiKit.Sortable.sortables[element.id];
},
- /** @id MochiKit.Sortable.Sortable.destroy */
+ /** @id MochiKit.Sortable.destroy */
destroy: function (element){
- var s = MochiKit.Sortable.Sortable.options(element);
+ var s = MochiKit.Sortable.options(element);
var b = MochiKit.Base;
var d = MochiKit.DragAndDrop;
@@ -93,74 +92,74 @@ MochiKit.Sortable.Sortable = {
dr.destroy();
}, s.draggables);
- delete MochiKit.Sortable.Sortable.sortables[s.element.id];
+ delete MochiKit.Sortable.sortables[s.element.id];
}
},
- /** @id MochiKit.Sortable.Sortable.create */
- create: function (element, options) {
+ /** @id MochiKit.Sortable.create */
+ create: function (element, options) {
element = MochiKit.DOM.getElement(element);
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
- /** @id MochiKit.Sortable.Sortable.options */
+ /** @id MochiKit.Sortable.options */
options = MochiKit.Base.update({
- /** @id MochiKit.Sortable.Sortable.element */
+ /** @id MochiKit.Sortable.element */
element: element,
- /** @id MochiKit.Sortable.Sortable.tag */
+ /** @id MochiKit.Sortable.tag */
tag: 'li', // assumes li children, override with tag: 'tagname'
- /** @id MochiKit.Sortable.Sortable.dropOnEmpty */
+ /** @id MochiKit.Sortable.dropOnEmpty */
dropOnEmpty: false,
- /** @id MochiKit.Sortable.Sortable.tree */
+ /** @id MochiKit.Sortable.tree */
tree: false,
- /** @id MochiKit.Sortable.Sortable.treeTag */
+ /** @id MochiKit.Sortable.treeTag */
treeTag: 'ul',
- /** @id MochiKit.Sortable.Sortable.overlap */
+ /** @id MochiKit.Sortable.overlap */
overlap: 'vertical', // one of 'vertical', 'horizontal'
- /** @id MochiKit.Sortable.Sortable.constraint */
+ /** @id MochiKit.Sortable.constraint */
constraint: 'vertical', // one of 'vertical', 'horizontal', false
// also takes array of elements (or ids); or false
- /** @id MochiKit.Sortable.Sortable.containment */
+ /** @id MochiKit.Sortable.containment */
containment: [element],
- /** @id MochiKit.Sortable.Sortable.handle */
+ /** @id MochiKit.Sortable.handle */
handle: false, // or a CSS class
- /** @id MochiKit.Sortable.Sortable.only */
+ /** @id MochiKit.Sortable.only */
only: false,
- /** @id MochiKit.Sortable.Sortable.hoverclass */
+ /** @id MochiKit.Sortable.hoverclass */
hoverclass: null,
- /** @id MochiKit.Sortable.Sortable.ghosting */
+ /** @id MochiKit.Sortable.ghosting */
ghosting: false,
- /** @id MochiKit.Sortable.Sortable.scroll */
+ /** @id MochiKit.Sortable.scroll */
scroll: false,
- /** @id MochiKit.Sortable.Sortable.scrollSensitivity */
+ /** @id MochiKit.Sortable.scrollSensitivity */
scrollSensitivity: 20,
- /** @id MochiKit.Sortable.Sortable.scrollSpeed */
+ /** @id MochiKit.Sortable.scrollSpeed */
scrollSpeed: 15,
- /** @id MochiKit.Sortable.Sortable.format */
+ /** @id MochiKit.Sortable.format */
format: /^[^_]*_(.*)$/,
- /** @id MochiKit.Sortable.Sortable.onChange */
+ /** @id MochiKit.Sortable.onChange */
onChange: MochiKit.Base.noop,
- /** @id MochiKit.Sortable.Sortable.onUpdate */
+ /** @id MochiKit.Sortable.onUpdate */
onUpdate: MochiKit.Base.noop,
- /** @id MochiKit.Sortable.Sortable.accept */
+ /** @id MochiKit.Sortable.accept */
accept: null
}, options);
@@ -228,7 +227,6 @@ MochiKit.Sortable.Sortable = {
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 ?
@@ -263,16 +261,16 @@ MochiKit.Sortable.Sortable = {
MochiKit.Base.partial(self.onEnd, element));
},
- /** @id MochiKit.Sortable.Sortable.onStart */
+ /** @id MochiKit.Sortable.onStart */
onStart: function (element, draggable) {
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
var options = self.options(element);
options.lastValue = self.serialize(options.element);
},
- /** @id MochiKit.Sortable.Sortable.onEnd */
+ /** @id MochiKit.Sortable.onEnd */
onEnd: function (element, draggable) {
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
self.unmark();
var options = self.options(element);
if (options.lastValue != self.serialize(options.element)) {
@@ -282,19 +280,19 @@ MochiKit.Sortable.Sortable = {
// return all suitable-for-sortable elements in a guaranteed order
- /** @id MochiKit.Sortable.Sortable.findElements */
+ /** @id MochiKit.Sortable.findElements */
findElements: function (element, options) {
- return MochiKit.Sortable.Sortable.findChildren(
+ return MochiKit.Sortable.findChildren(
element, options.only, options.tree ? true : false, options.tag);
},
- /** @id MochiKit.Sortable.Sortable.findTreeElements */
+ /** @id MochiKit.Sortable.findTreeElements */
findTreeElements: function (element, options) {
- return MochiKit.Sortable.Sortable.findChildren(
+ return MochiKit.Sortable.findChildren(
element, options.only, options.tree ? true : false, options.treeTag);
},
- /** @id MochiKit.Sortable.Sortable.findChildren */
+ /** @id MochiKit.Sortable.findChildren */
findChildren: function (element, only, recursive, tagName) {
if (!element.hasChildNodes()) {
return null;
@@ -314,7 +312,7 @@ MochiKit.Sortable.Sortable = {
elements.push(e);
}
if (recursive) {
- var grandchildren = MochiKit.Sortable.Sortable.findChildren(e, only, recursive, tagName);
+ var grandchildren = MochiKit.Sortable.findChildren(e, only, recursive, tagName);
if (grandchildren && grandchildren.length > 0) {
elements = elements.concat(grandchildren);
}
@@ -323,12 +321,12 @@ MochiKit.Sortable.Sortable = {
return elements;
},
- /** @id MochiKit.Sortable.Sortable.onHover */
+ /** @id MochiKit.Sortable.onHover */
onHover: function (element, dropon, overlap) {
if (MochiKit.DOM.isParent(dropon, element)) {
return;
}
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
if (overlap > .33 && overlap < .66 && self.options(dropon).tree) {
return;
@@ -366,10 +364,10 @@ MochiKit.Sortable.Sortable = {
}
},
- /** @id MochiKit.Sortable.Sortable.onEmptyHover */
+ /** @id MochiKit.Sortable.onEmptyHover */
onEmptyHover: function (element, dropon, overlap) {
var oldParentNode = element.parentNode;
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
var droponOptions = self.options(dropon);
if (!MochiKit.DOM.isParent(dropon, element)) {
@@ -402,19 +400,19 @@ MochiKit.Sortable.Sortable = {
}
},
- /** @id MochiKit.Sortable.Sortable.unmark */
+ /** @id MochiKit.Sortable.unmark */
unmark: function () {
- var m = MochiKit.Sortable.Sortable._marker;
+ var m = MochiKit.Sortable._marker;
if (m) {
MochiKit.Style.hideElement(m);
}
},
- /** @id MochiKit.Sortable.Sortable.mark */
+ /** @id MochiKit.Sortable.mark */
mark: function (dropon, position) {
// mark on ghosting only
var d = MochiKit.DOM;
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
var sortable = self.options(dropon.parentNode);
if (sortable && !sortable.ghosting) {
return;
@@ -443,7 +441,7 @@ MochiKit.Sortable.Sortable = {
},
_tree: function (element, options, parent) {
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
var children = self.findElements(element, options) || [];
for (var i = 0; i < children.length; ++i) {
@@ -487,10 +485,10 @@ MochiKit.Sortable.Sortable = {
return null;
},
- /** @id MochiKit.Sortable.Sortable.tree */
+ /** @id MochiKit.Sortable.tree */
tree: function (element, options) {
element = MochiKit.DOM.getElement(element);
- var sortableOptions = MochiKit.Sortable.Sortable.options(element);
+ var sortableOptions = MochiKit.Sortable.options(element);
options = MochiKit.Base.update({
tag: sortableOptions.tag,
treeTag: sortableOptions.treeTag,
@@ -507,7 +505,7 @@ MochiKit.Sortable.Sortable = {
position: 0
}
- return MochiKit.Sortable.Sortable._tree(element, options, root);
+ return MochiKit.Sortable._tree(element, options, root);
},
/**
@@ -517,7 +515,7 @@ MochiKit.Sortable.Sortable = {
* @param {Object} options Options to use fro the Sortable.
*/
setSequence: function (element, newSequence, options) {
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
var b = MochiKit.Base;
element = MochiKit.DOM.getElement(element);
options = b.update(self.options(element), options || {});
@@ -551,10 +549,10 @@ MochiKit.Sortable.Sortable = {
return index;
},
- /** @id MochiKit.Sortable.Sortable.sequence */
+ /** @id MochiKit.Sortable.sequence */
sequence: function (element, options) {
element = MochiKit.DOM.getElement(element);
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
var options = MochiKit.Base.update(self.options(element), options || {});
return MochiKit.Base.map(function (item) {
@@ -570,7 +568,7 @@ MochiKit.Sortable.Sortable = {
*/
serialize: function (element, options) {
element = MochiKit.DOM.getElement(element);
- var self = MochiKit.Sortable.Sortable;
+ var self = MochiKit.Sortable;
options = MochiKit.Base.update(self.options(element), options || {});
var name = encodeURIComponent(options.name || element.id);
@@ -585,5 +583,7 @@ MochiKit.Sortable.Sortable = {
}, self.sequence(element, options)).join('&');
}
}
-};
+});
+// trunk compatibility
+MochiKit.Sortable.Sortable = MochiKit.Sortable;
diff --git a/thirdpartyjs/MochiKit/Style.js b/thirdpartyjs/MochiKit/Style.js
new file mode 100644
index 0000000..6abf6d7
--- /dev/null
+++ b/thirdpartyjs/MochiKit/Style.js
@@ -0,0 +1,475 @@
+/***
+
+MochiKit.Style 1.4
+
+See for documentation, downloads, license, etc.
+
+(c) 2005-2006 Bob Ippolito, Beau Hartshorne. All rights Reserved.
+
+***/
+
+if (typeof(dojo) != 'undefined') {
+ dojo.provide('MochiKit.Style');
+ dojo.require('MochiKit.Base');
+ dojo.require('MochiKit.DOM');
+}
+if (typeof(JSAN) != 'undefined') {
+ JSAN.use('MochiKit.Base', []);
+}
+
+try {
+ if (typeof(MochiKit.Base) == 'undefined') {
+ throw '';
+ }
+} catch (e) {
+ throw 'MochiKit.Style depends on MochiKit.Base!';
+}
+
+try {
+ if (typeof(MochiKit.DOM) == 'undefined') {
+ throw '';
+ }
+} catch (e) {
+ throw 'MochiKit.Style depends on MochiKit.DOM!';
+}
+
+
+if (typeof(MochiKit.Style) == 'undefined') {
+ MochiKit.Style = {};
+}
+
+MochiKit.Style.NAME = 'MochiKit.Style';
+MochiKit.Style.VERSION = '1.4';
+MochiKit.Style.__repr__ = function () {
+ return '[' + this.NAME + ' ' + this.VERSION + ']';
+};
+MochiKit.Style.toString = function () {
+ return this.__repr__();
+};
+
+MochiKit.Style.EXPORT_OK = [];
+
+MochiKit.Style.EXPORT = [
+ 'setOpacity',
+ 'getOpacity',
+ 'setStyle',
+ 'getStyle', // temporary
+ 'computedStyle',
+ 'getElementDimensions',
+ 'elementDimensions', // deprecated
+ 'setElementDimensions',
+ 'getElementPosition',
+ 'elementPosition', // deprecated
+ 'setElementPosition',
+ 'setDisplayForElement',
+ 'hideElement',
+ 'showElement',
+ 'getViewportDimensions',
+ 'getViewportPosition',
+ 'Dimensions',
+ 'Coordinates'
+];
+
+
+/*
+
+ Dimensions
+
+*/
+/** @id MochiKit.Style.Dimensions */
+MochiKit.Style.Dimensions = function (w, h) {
+ this.w = w;
+ this.h = h;
+};
+
+MochiKit.Style.Dimensions.prototype.__repr__ = function () {
+ var repr = MochiKit.Base.repr;
+ return '{w: ' + repr(this.w) + ', h: ' + repr(this.h) + '}';
+};
+
+MochiKit.Style.Dimensions.prototype.toString = function () {
+ return this.__repr__();
+};
+
+
+/*
+
+ Coordinates
+
+*/
+/** @id MochiKit.Style.Coordinates */
+MochiKit.Style.Coordinates = function (x, y) {
+ this.x = x;
+ this.y = y;
+};
+
+MochiKit.Style.Coordinates.prototype.__repr__ = function () {
+ var repr = MochiKit.Base.repr;
+ return '{x: ' + repr(this.x) + ', y: ' + repr(this.y) + '}';
+};
+
+MochiKit.Style.Coordinates.prototype.toString = function () {
+ return this.__repr__();
+};
+
+
+MochiKit.Base.update(MochiKit.Style, {
+
+ /** @id MochiKit.Style.computedStyle */
+ computedStyle: function (elem, cssProperty) {
+ var dom = MochiKit.DOM;
+ var d = dom._document;
+
+ elem = dom.getElement(elem);
+ cssProperty = MochiKit.Base.camelize(cssProperty);
+
+ if (!elem || elem == d) {
+ return undefined;
+ }
+
+ /* from YUI 0.10.0 */
+ if (cssProperty == 'opacity' && elem.filters) { // IE opacity
+ try {
+ return elem.filters.item('DXImageTransform.Microsoft.Alpha'
+ ).opacity / 100;
+ } catch(e) {
+ try {
+ return elem.filters.item('alpha').opacity / 100;
+ } catch(e) {}
+ }
+ }
+
+ if (elem.currentStyle) {
+ return elem.currentStyle[cssProperty];
+ }
+ if (typeof(d.defaultView) == 'undefined') {
+ return undefined;
+ }
+ if (d.defaultView === null) {
+ return undefined;
+ }
+ var style = d.defaultView.getComputedStyle(elem, null);
+ if (typeof(style) == 'undefined' || style === null) {
+ return undefined;
+ }
+
+ var selectorCase = cssProperty.replace(/([A-Z])/g, '-$1'
+ ).toLowerCase(); // from dojo.style.toSelectorCase
+
+ return style.getPropertyValue(selectorCase);
+ },
+
+ /** @id MochiKit.Style.getStyle */
+ getStyle: function (elem, style) {
+ elem = MochiKit.DOM.getElement(elem);
+ var value = elem.style[MochiKit.Base.camelize(style)];
+ if (!value) {
+ if (document.defaultView && document.defaultView.getComputedStyle) {
+ var css = document.defaultView.getComputedStyle(elem, null);
+ value = css ? css.getPropertyValue(style) : null;
+ } else if (elem.currentStyle) {
+ value = elem.currentStyle[MochiKit.Base.camelize(style)];
+ }
+ }
+
+ if (/Opera/.test(navigator.userAgent) && (MochiKit.Base.find(['left', 'top', 'right', 'bottom'], style) != -1)) {
+ if (MochiKit.Style.getStyle(elem, 'position') == 'static') {
+ value = 'auto';
+ }
+ }
+
+ return value == 'auto' ? null : value;
+ },
+
+ /** @id MochiKit.Style.setStyle */
+ setStyle: function (elem, style) {
+ elem = MochiKit.DOM.getElement(elem);
+ for (name in style) {
+ elem.style[MochiKit.Base.camelize(name)] = style[name];
+ }
+ },
+
+ /** @id MochiKit.Style.getOpacity */
+ getOpacity: function (elem) {
+ var opacity;
+ if (opacity = MochiKit.Style.getStyle(elem, 'opacity')) {
+ return parseFloat(opacity);
+ }
+ if (opacity = (MochiKit.Style.getStyle(elem, 'filter') || '').match(/alpha\(opacity=(.*)\)/)) {
+ if (opacity[1]) {
+ return parseFloat(opacity[1]) / 100;
+ }
+ }
+ return 1.0;
+ },
+ /** @id MochiKit.Style.setOpacity */
+ setOpacity: function(elem, o) {
+ elem = MochiKit.DOM.getElement(elem);
+ var self = MochiKit.Style;
+ if (o == 1) {
+ var toSet = /Gecko/.test(navigator.userAgent) && !(/Konqueror|Safari|KHTML/.test(navigator.userAgent));
+ self.setStyle(elem, {opacity: toSet ? 0.999999 : 1.0});
+ if (/MSIE/.test(navigator.userAgent)) {
+ self.setStyle(elem, {filter:
+ self.getStyle(elem, 'filter').replace(/alpha\([^\)]*\)/gi, '')});
+ }
+ } else {
+ if (o < 0.00001) {
+ o = 0;
+ }
+ self.setStyle(elem, {opacity: o});
+ if (/MSIE/.test(navigator.userAgent)) {
+ self.setStyle(elem,
+ {filter: self.getStyle(elem, 'filter').replace(/alpha\([^\)]*\)/gi, '') + 'alpha(opacity=' + o * 100 + ')' });
+ }
+ }
+ },
+
+ /*
+
+ getElementPosition is adapted from YAHOO.util.Dom.getXY v0.9.0.
+ Copyright: Copyright (c) 2006, Yahoo! Inc. All rights reserved.
+ License: BSD, http://developer.yahoo.net/yui/license.txt
+
+ */
+
+ /** @id MochiKit.Style.getElementPosition */
+ getElementPosition: function (elem, /* optional */relativeTo) {
+ var self = MochiKit.Style;
+ var dom = MochiKit.DOM;
+ elem = dom.getElement(elem);
+
+ if (!elem ||
+ (!(elem.x && elem.y) &&
+ (!elem.parentNode == null ||
+ self.computedStyle(elem, 'display') == 'none'))) {
+ return undefined;
+ }
+
+ var c = new self.Coordinates(0, 0);
+ var box = null;
+ var parent = null;
+
+ var d = MochiKit.DOM._document;
+ var de = d.documentElement;
+ var b = d.body;
+
+ if (!elem.parentNode && elem.x && elem.y) {
+ /* it's just a MochiKit.Style.Coordinates object */
+ c.x += elem.x || 0;
+ c.y += elem.y || 0;
+ } else if (elem.getBoundingClientRect) { // IE shortcut
+ /*
+
+ The IE shortcut can be off by two. We fix it. See:
+ http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/getboundingclientrect.asp
+
+ This is similar to the method used in
+ MochiKit.Signal.Event.mouse().
+
+ */
+ box = elem.getBoundingClientRect();
+
+ c.x += box.left +
+ (de.scrollLeft || b.scrollLeft) -
+ (de.clientLeft || 0);
+
+ c.y += box.top +
+ (de.scrollTop || b.scrollTop) -
+ (de.clientTop || 0);
+
+ } else if (elem.offsetParent) {
+ c.x += elem.offsetLeft;
+ c.y += elem.offsetTop;
+ parent = elem.offsetParent;
+
+ if (parent != elem) {
+ while (parent) {
+ c.x += parent.offsetLeft;
+ c.y += parent.offsetTop;
+ parent = parent.offsetParent;
+ }
+ }
+
+ /*
+
+ Opera < 9 and old Safari (absolute) incorrectly account for
+ body offsetTop and offsetLeft.
+
+ */
+ var ua = navigator.userAgent.toLowerCase();
+ if ((typeof(opera) != 'undefined' &&
+ parseFloat(opera.version()) < 9) ||
+ (ua.indexOf('safari') != -1 &&
+ self.computedStyle(elem, 'position') == 'absolute')) {
+
+ c.x -= b.offsetLeft;
+ c.y -= b.offsetTop;
+
+ }
+ }
+
+ if (typeof(relativeTo) != 'undefined') {
+ relativeTo = arguments.callee(relativeTo);
+ if (relativeTo) {
+ c.x -= (relativeTo.x || 0);
+ c.y -= (relativeTo.y || 0);
+ }
+ }
+
+ if (elem.parentNode) {
+ parent = elem.parentNode;
+ } else {
+ parent = null;
+ }
+
+ while (parent) {
+ var tagName = parent.tagName.toUpperCase();
+ if (tagName === 'BODY' || tagName === 'HTML') {
+ break;
+ }
+ c.x -= parent.scrollLeft;
+ c.y -= parent.scrollTop;
+ if (parent.parentNode) {
+ parent = parent.parentNode;
+ } else {
+ parent = null;
+ }
+ }
+
+ return c;
+ },
+
+ /** @id MochiKit.Style.setElementPosition */
+ setElementPosition: function (elem, newPos/* optional */, units) {
+ elem = MochiKit.DOM.getElement(elem);
+ if (typeof(units) == 'undefined') {
+ units = 'px';
+ }
+ var newStyle = {};
+ var isUndefNull = MochiKit.Base.isUndefinedOrNull;
+ if (!isUndefNull(newPos.x)) {
+ newStyle['left'] = newPos.x + units;
+ }
+ if (!isUndefNull(newPos.y)) {
+ newStyle['top'] = newPos.y + units;
+ }
+ MochiKit.DOM.updateNodeAttributes(elem, {'style': newStyle});
+ },
+
+ /** @id MochiKit.Style.getElementDimensions */
+ getElementDimensions: function (elem) {
+ var self = MochiKit.Style;
+ var dom = MochiKit.DOM;
+ if (typeof(elem.w) == 'number' || typeof(elem.h) == 'number') {
+ return new self.Dimensions(elem.w || 0, elem.h || 0);
+ }
+ elem = dom.getElement(elem);
+ if (!elem) {
+ return undefined;
+ }
+ var disp = self.computedStyle(elem, 'display');
+ // display can be empty/undefined on WebKit/KHTML
+ if (disp != 'none' && disp != '' && typeof(disp) != 'undefined') {
+ return new self.Dimensions(elem.offsetWidth || 0,
+ elem.offsetHeight || 0);
+ }
+ var s = elem.style;
+ var originalVisibility = s.visibility;
+ var originalPosition = s.position;
+ s.visibility = 'hidden';
+ s.position = 'absolute';
+ s.display = '';
+ var originalWidth = elem.offsetWidth;
+ var originalHeight = elem.offsetHeight;
+ s.display = 'none';
+ s.position = originalPosition;
+ s.visibility = originalVisibility;
+ return new self.Dimensions(originalWidth, originalHeight);
+ },
+
+ /** @id MochiKit.Style.setElementDimensions */
+ setElementDimensions: function (elem, newSize/* optional */, units) {
+ elem = MochiKit.DOM.getElement(elem);
+ if (typeof(units) == 'undefined') {
+ units = 'px';
+ }
+ var newStyle = {};
+ var isUndefNull = MochiKit.Base.isUndefinedOrNull;
+ if (!isUndefNull(newSize.w)) {
+ newStyle['width'] = newSize.w + units;
+ }
+ if (!isUndefNull(newSize.h)) {
+ newStyle['height'] = newSize.h + units;
+ }
+ MochiKit.DOM.updateNodeAttributes(elem, {'style': newStyle});
+ },
+
+ /** @id MochiKit.Style.setDisplayForElement */
+ setDisplayForElement: function (display, element/*, ...*/) {
+ var elements = MochiKit.Base.extend(null, arguments, 1);
+ var getElement = MochiKit.DOM.getElement;
+ for (var i = 0; i < elements.length; i++) {
+ var element = getElement(elements[i]);
+ if (element) {
+ element.style.display = display;
+ }
+ }
+ },
+
+ /** @id MochiKit.Style.getViewportDimensions */
+ getViewportDimensions: function () {
+ var d = new MochiKit.Style.Dimensions();
+
+ var w = MochiKit.DOM._window;
+ var b = MochiKit.DOM._document.body;
+
+ if (w.innerWidth) {
+ d.w = w.innerWidth;
+ d.h = w.innerHeight;
+ } else if (b.parentElement.clientWidth) {
+ d.w = b.parentElement.clientWidth;
+ d.h = b.parentElement.clientHeight;
+ } else if (b && b.clientWidth) {
+ d.w = b.clientWidth;
+ d.h = b.clientHeight;
+ }
+ return d;
+ },
+
+ /** @id MochiKit.Style.getViewportPosition */
+ getViewportPosition: function () {
+ var c = new MochiKit.Style.Coordinates(0, 0);
+ var d = MochiKit.DOM._document;
+ var de = d.documentElement;
+ var db = d.body;
+ if (de && (de.scrollTop || de.scrollLeft)) {
+ c.x = de.scrollLeft;
+ c.y = de.scrollTop;
+ } else if (db) {
+ c.x = db.scrollLeft;
+ c.y = db.scrollTop;
+ }
+ return c;
+ },
+
+ __new__: function () {
+ var m = MochiKit.Base;
+
+ this.elementPosition = this.getElementPosition;
+ this.elementDimensions = this.getElementDimensions;
+
+ this.hideElement = m.partial(this.setDisplayForElement, 'none');
+ this.showElement = m.partial(this.setDisplayForElement, 'block');
+
+ this.EXPORT_TAGS = {
+ ':common': this.EXPORT,
+ ':all': m.concat(this.EXPORT, this.EXPORT_OK)
+ };
+
+ m.nameFunctions(this);
+ }
+});
+
+MochiKit.Style.__new__();
+MochiKit.Base._exportSymbols(this, MochiKit.Style);
diff --git a/thirdpartyjs/MochiKit/Test.js b/thirdpartyjs/MochiKit/Test.js
index 8517e7e..632356a 100644
--- a/thirdpartyjs/MochiKit/Test.js
+++ b/thirdpartyjs/MochiKit/Test.js
@@ -1,6 +1,6 @@
/***
-MochiKit.Test 1.3.1
+MochiKit.Test 1.4
See for documentation, downloads, license, etc.
@@ -30,7 +30,7 @@ if (typeof(MochiKit.Test) == 'undefined') {
}
MochiKit.Test.NAME = "MochiKit.Test";
-MochiKit.Test.VERSION = "1.3.1";
+MochiKit.Test.VERSION = "1.4";
MochiKit.Test.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
};
diff --git a/thirdpartyjs/MochiKit/Visual.js b/thirdpartyjs/MochiKit/Visual.js
index 02cee54..ed48be9 100644
--- a/thirdpartyjs/MochiKit/Visual.js
+++ b/thirdpartyjs/MochiKit/Visual.js
@@ -1,6 +1,6 @@
/***
-MochiKit.Visual 1.3.1
+MochiKit.Visual 1.4
See for documentation, downloads, license, etc.
@@ -12,23 +12,29 @@ if (typeof(dojo) != 'undefined') {
dojo.provide('MochiKit.Visual');
dojo.require('MochiKit.Base');
dojo.require('MochiKit.DOM');
+ dojo.require('MochiKit.Style');
dojo.require('MochiKit.Color');
+ dojo.require('MochiKit.Position');
}
if (typeof(JSAN) != 'undefined') {
JSAN.use("MochiKit.Base", []);
JSAN.use("MochiKit.DOM", []);
+ JSAN.use("MochiKit.Style", []);
JSAN.use("MochiKit.Color", []);
+ JSAN.use("MochiKit.Position", []);
}
try {
- if (typeof(MochiKit.Base) == 'undefined' ||
- typeof(MochiKit.DOM) == 'undefined' ||
- typeof(MochiKit.Color) == 'undefined') {
+ if (typeof(MochiKit.Base) === 'undefined' ||
+ typeof(MochiKit.DOM) === 'undefined' ||
+ typeof(MochiKit.Style) === 'undefined' ||
+ typeof(MochiKit.Position) === 'undefined' ||
+ typeof(MochiKit.Color) === 'undefined') {
throw "";
}
} catch (e) {
- throw "MochiKit.Visual depends on MochiKit.Base, MochiKit.DOM and MochiKit.Color!";
+ throw "MochiKit.Visual depends on MochiKit.Base, MochiKit.DOM, MochiKit.Style, MochiKit.Position and MochiKit.Color!";
}
if (typeof(MochiKit.Visual) == "undefined") {
@@ -36,7 +42,7 @@ if (typeof(MochiKit.Visual) == "undefined") {
}
MochiKit.Visual.NAME = "MochiKit.Visual";
-MochiKit.Visual.VERSION = "1.3.1";
+MochiKit.Visual.VERSION = "1.4";
MochiKit.Visual.__repr__ = function () {
return "[" + this.NAME + " " + this.VERSION + "]";
@@ -46,7 +52,6 @@ MochiKit.Visual.toString = function () {
return this.__repr__();
};
-
MochiKit.Visual._RoundCorners = function (e, options) {
e = MochiKit.DOM.getElement(e);
this._setOptions(options);
@@ -56,7 +61,7 @@ MochiKit.Visual._RoundCorners = function (e, options) {
var color = this.options.color;
var C = MochiKit.Color.Color;
- if (this.options.color == "fromElement") {
+ if (this.options.color === "fromElement") {
color = C.fromBackground(e);
} else if (!(color instanceof C)) {
color = C.fromString(color);
@@ -64,7 +69,7 @@ MochiKit.Visual._RoundCorners = function (e, options) {
this.isTransparent = (color.asRGB().a <= 0);
var bgColor = this.options.bgColor;
- if (this.options.bgColor == "fromParent") {
+ if (this.options.bgColor === "fromParent") {
bgColor = C.fromBackground(e.offsetParent);
} else if (!(bgColor instanceof C)) {
bgColor = C.fromString(bgColor);
@@ -77,12 +82,12 @@ MochiKit.Visual._RoundCorners.prototype = {
_doWrap: function (e) {
var parent = e.parentNode;
var doc = MochiKit.DOM.currentDocument();
- if (typeof(doc.defaultView) == "undefined"
+ if (typeof(doc.defaultView) === "undefined"
|| doc.defaultView === null) {
return e;
}
var style = doc.defaultView.getComputedStyle(e, null);
- if (typeof(style) == "undefined" || style === null) {
+ if (typeof(style) === "undefined" || style === null) {
return e;
}
var wrapper = MochiKit.DOM.DIV({"style": {
@@ -121,7 +126,7 @@ MochiKit.Visual._RoundCorners.prototype = {
var borderValue = "1px solid " + this._borderColor(bgColor);
var borderL = "border-left: " + borderValue;
var borderR = "border-right: " + borderValue;
- var style = "style='" + borderL + ";" + borderR + "'";
+ var style = "style='" + borderL + ";" + borderR + "'";
el.innerHTML = "" + el.innerHTML + "
";
},
@@ -267,7 +272,7 @@ MochiKit.Visual._RoundCorners.prototype = {
style.marginRight = "0px";
} else if (whichSide == "right") {
style.marginRight = marginSize;
- style.marginLeft = "0px";
+ style.marginLeft = "0px";
} else {
style.marginLeft = marginSize;
style.marginRight = marginSize;
@@ -286,7 +291,7 @@ MochiKit.Visual._RoundCorners.prototype = {
style.borderRightWidth = "0px";
} else if (whichSide == "right") {
style.borderRightWidth = borderSize;
- style.borderLeftWidth = "0px";
+ style.borderLeftWidth = "0px";
} else {
style.borderLeftWidth = borderSize;
style.borderRightWidth = borderSize;
@@ -359,10 +364,12 @@ MochiKit.Visual._RoundCorners.prototype = {
}
};
+/** @id MochiKit.Visual.roundElement */
MochiKit.Visual.roundElement = function (e, options) {
new MochiKit.Visual._RoundCorners(e, options);
};
+/** @id MochiKit.Visual.roundClass */
MochiKit.Visual.roundClass = function (tagName, className, options) {
var elements = MochiKit.DOM.getElementsByTagAndClassName(
tagName, className
@@ -372,13 +379,1432 @@ MochiKit.Visual.roundClass = function (tagName, className, options) {
}
};
+/** @id MochiKit.Visual.tagifyText */
+MochiKit.Visual.tagifyText = function (element, /* optional */tagifyStyle) {
+ /***
+
+ Change a node text to character in tags.
+
+ @param tagifyStyle: the style to apply to character nodes, default to
+ 'position: relative'.
+
+ ***/
+ var tagifyStyle = tagifyStyle || 'position:relative';
+ if (/MSIE/.test(navigator.userAgent)) {
+ tagifyStyle += ';zoom:1';
+ }
+ element = MochiKit.DOM.getElement(element);
+ var ma = MochiKit.Base.map;
+ ma(function (child) {
+ if (child.nodeType == 3) {
+ ma(function (character) {
+ element.insertBefore(
+ MochiKit.DOM.SPAN({style: tagifyStyle},
+ character == ' ' ? String.fromCharCode(160) : character), child);
+ }, child.nodeValue.split(''));
+ MochiKit.DOM.removeElement(child);
+ }
+ }, element.childNodes);
+};
+
+/** @id MochiKit.Visual.forceRerendering */
+MochiKit.Visual.forceRerendering = function (element) {
+ try {
+ element = MochiKit.DOM.getElement(element);
+ var n = document.createTextNode(' ');
+ element.appendChild(n);
+ element.removeChild(n);
+ } catch(e) {
+ }
+};
+
+/** @id MochiKit.Visual.multiple */
+MochiKit.Visual.multiple = function (elements, effect, /* optional */options) {
+ /***
+
+ Launch the same effect subsequently on given elements.
+
+ ***/
+ options = MochiKit.Base.update({
+ speed: 0.1, delay: 0.0
+ }, options || {});
+ var masterDelay = options.delay;
+ var index = 0;
+ MochiKit.Base.map(function (innerelement) {
+ options.delay = index * options.speed + masterDelay;
+ new effect(innerelement, options);
+ index += 1;
+ }, elements);
+};
+
+MochiKit.Visual.PAIRS = {
+ 'slide': ['slideDown', 'slideUp'],
+ 'blind': ['blindDown', 'blindUp'],
+ 'appear': ['appear', 'fade'],
+ 'size': ['grow', 'shrink']
+};
+
+/** @id MochiKit.Visual.toggle */
+MochiKit.Visual.toggle = function (element, /* optional */effect, /* optional */options) {
+ /***
+
+ Toggle an item between two state depending of its visibility, making
+ a effect between these states. Default effect is 'appear', can be
+ 'slide' or 'blind'.
+
+ ***/
+ element = MochiKit.DOM.getElement(element);
+ effect = (effect || 'appear').toLowerCase();
+ options = MochiKit.Base.update({
+ queue: {position: 'end', scope: (element.id || 'global'), limit: 1}
+ }, options || {});
+ var v = MochiKit.Visual;
+ v[element.style.display != 'none' ?
+ v.PAIRS[effect][1] : v.PAIRS[effect][0]](element, options);
+};
+
+/***
+
+Transitions: define functions calculating variations depending of a position.
+
+***/
+
+MochiKit.Visual.Transitions = {}
+
+/** @id MochiKit.Visual.Transitions.linear */
+MochiKit.Visual.Transitions.linear = function (pos) {
+ return pos;
+};
+
+/** @id MochiKit.Visual.Transitions.sinoidal */
+MochiKit.Visual.Transitions.sinoidal = function (pos) {
+ return (-Math.cos(pos*Math.PI)/2) + 0.5;
+};
+
+/** @id MochiKit.Visual.Transitions.reverse */
+MochiKit.Visual.Transitions.reverse = function (pos) {
+ return 1 - pos;
+};
+
+/** @id MochiKit.Visual.Transitions.flicker */
+MochiKit.Visual.Transitions.flicker = function (pos) {
+ return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
+};
+
+/** @id MochiKit.Visual.Transitions.wobble */
+MochiKit.Visual.Transitions.wobble = function (pos) {
+ return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
+};
+
+/** @id MochiKit.Visual.Transitions.pulse */
+MochiKit.Visual.Transitions.pulse = function (pos) {
+ return (Math.floor(pos*10) % 2 == 0 ?
+ (pos*10 - Math.floor(pos*10)) : 1 - (pos*10 - Math.floor(pos*10)));
+};
+
+/** @id MochiKit.Visual.Transitions.none */
+MochiKit.Visual.Transitions.none = function (pos) {
+ return 0;
+};
+
+/** @id MochiKit.Visual.Transitions.full */
+MochiKit.Visual.Transitions.full = function (pos) {
+ return 1;
+};
+
+/***
+
+Core effects
+
+***/
+
+MochiKit.Visual.ScopedQueue = function () {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls();
+ }
+ this.__init__();
+};
+
+MochiKit.Base.update(MochiKit.Visual.ScopedQueue.prototype, {
+ __init__: function () {
+ this.effects = [];
+ this.interval = null;
+ },
+
+ /** @id MochiKit.Visual.ScopedQueue.prototype.add */
+ add: function (effect) {
+ var timestamp = new Date().getTime();
+
+ var position = (typeof(effect.options.queue) == 'string') ?
+ effect.options.queue : effect.options.queue.position;
+
+ var ma = MochiKit.Base.map;
+ switch (position) {
+ case 'front':
+ // move unstarted effects after this effect
+ ma(function (e) {
+ if (e.state == 'idle') {
+ e.startOn += effect.finishOn;
+ e.finishOn += effect.finishOn;
+ }
+ }, this.effects);
+ break;
+ case 'end':
+ var finish;
+ // start effect after last queued effect has finished
+ ma(function (e) {
+ var i = e.finishOn;
+ if (i >= (finish || i)) {
+ finish = i;
+ }
+ }, this.effects);
+ timestamp = finish || timestamp;
+ break;
+ case 'break':
+ ma(function (e) {
+ e.finalize();
+ }, this.effects);
+ break;
+ }
+
+ effect.startOn += timestamp;
+ effect.finishOn += timestamp;
+ if (!effect.options.queue.limit ||
+ this.effects.length < effect.options.queue.limit) {
+ this.effects.push(effect);
+ }
+
+ if (!this.interval) {
+ this.interval = this.startLoop(MochiKit.Base.bind(this.loop, this),
+ 40);
+ }
+ },
+
+ /** @id MochiKit.Visual.ScopedQueue.prototype.startLoop */
+ startLoop: function (func, interval) {
+ return setInterval(func, interval)
+ },
+
+ /** @id MochiKit.Visual.ScopedQueue.prototype.remove */
+ remove: function (effect) {
+ this.effects = MochiKit.Base.filter(function (e) {
+ return e != effect;
+ }, this.effects);
+ if (this.effects.length == 0) {
+ this.stopLoop(this.interval);
+ this.interval = null;
+ }
+ },
+
+ /** @id MochiKit.Visual.ScopedQueue.prototype.stopLoop */
+ stopLoop: function (interval) {
+ clearInterval(interval)
+ },
+
+ /** @id MochiKit.Visual.ScopedQueue.prototype.loop */
+ loop: function () {
+ var timePos = new Date().getTime();
+ MochiKit.Base.map(function (effect) {
+ effect.loop(timePos);
+ }, this.effects);
+ }
+});
+
+MochiKit.Visual.Queues = {
+ instances: {},
+
+ get: function (queueName) {
+ if (typeof(queueName) != 'string') {
+ return queueName;
+ }
+
+ if (!this.instances[queueName]) {
+ this.instances[queueName] = new MochiKit.Visual.ScopedQueue();
+ }
+ return this.instances[queueName];
+ }
+};
+
+MochiKit.Visual.Queue = MochiKit.Visual.Queues.get('global');
+
+MochiKit.Visual.DefaultOptions = {
+ transition: MochiKit.Visual.Transitions.sinoidal,
+ duration: 1.0, // seconds
+ fps: 25.0, // max. 25fps due to MochiKit.Visual.Queue implementation
+ sync: false, // true for combining
+ from: 0.0,
+ to: 1.0,
+ delay: 0.0,
+ queue: 'parallel'
+};
+
+MochiKit.Visual.Base = function () {};
+
+MochiKit.Visual.Base.prototype = {
+ /***
+
+ Basic class for all Effects. Define a looping mechanism called for each step
+ of an effect. Don't instantiate it, only subclass it.
+
+ ***/
+
+ __class__ : MochiKit.Visual.Base,
+
+ /** @id MochiKit.Visual.Base.prototype.start */
+ start: function (options) {
+ var v = MochiKit.Visual;
+ this.options = MochiKit.Base.setdefault(options || {},
+ v.DefaultOptions);
+ this.currentFrame = 0;
+ this.state = 'idle';
+ this.startOn = this.options.delay*1000;
+ this.finishOn = this.startOn + (this.options.duration*1000);
+ this.event('beforeStart');
+ if (!this.options.sync) {
+ v.Queues.get(typeof(this.options.queue) == 'string' ?
+ 'global' : this.options.queue.scope).add(this);
+ }
+ },
+
+ /** @id MochiKit.Visual.Base.prototype.loop */
+ loop: function (timePos) {
+ if (timePos >= this.startOn) {
+ if (timePos >= this.finishOn) {
+ return this.finalize();
+ }
+ var pos = (timePos - this.startOn) / (this.finishOn - this.startOn);
+ var frame =
+ Math.round(pos * this.options.fps * this.options.duration);
+ if (frame > this.currentFrame) {
+ this.render(pos);
+ this.currentFrame = frame;
+ }
+ }
+ },
+
+ /** @id MochiKit.Visual.Base.prototype.render */
+ render: function (pos) {
+ if (this.state == 'idle') {
+ this.state = 'running';
+ this.event('beforeSetup');
+ this.setup();
+ this.event('afterSetup');
+ }
+ if (this.state == 'running') {
+ if (this.options.transition) {
+ pos = this.options.transition(pos);
+ }
+ pos *= (this.options.to - this.options.from);
+ pos += this.options.from;
+ this.event('beforeUpdate');
+ this.update(pos);
+ this.event('afterUpdate');
+ }
+ },
+
+ /** @id MochiKit.Visual.Base.prototype.cancel */
+ cancel: function () {
+ if (!this.options.sync) {
+ MochiKit.Visual.Queues.get(typeof(this.options.queue) == 'string' ?
+ 'global' : this.options.queue.scope).remove(this);
+ }
+ this.state = 'finished';
+ },
+
+ /** @id MochiKit.Visual.Base.prototype.finalize */
+ finalize: function () {
+ this.render(1.0);
+ this.cancel();
+ this.event('beforeFinish');
+ this.finish();
+ this.event('afterFinish');
+ },
+
+ setup: function () {
+ },
+
+ finish: function () {
+ },
+
+ update: function (position) {
+ },
+
+ /** @id MochiKit.Visual.Base.prototype.event */
+ event: function (eventName) {
+ if (this.options[eventName + 'Internal']) {
+ this.options[eventName + 'Internal'](this);
+ }
+ if (this.options[eventName]) {
+ this.options[eventName](this);
+ }
+ },
+
+ /** @id MochiKit.Visual.Base.prototype.repr */
+ repr: function () {
+ return '[' + this.__class__.NAME + ', options:' +
+ MochiKit.Base.repr(this.options) + ']';
+ }
+}
+
+ /** @id MochiKit.Visual.Parallel */
+MochiKit.Visual.Parallel = function (effects, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(effects, options);
+ }
+
+ this.__init__(effects, options);
+};
+
+MochiKit.Visual.Parallel.prototype = new MochiKit.Visual.Base();
+
+MochiKit.Base.update(MochiKit.Visual.Parallel.prototype, {
+ /***
+
+ Run multiple effects at the same time.
+
+ ***/
+ __init__: function (effects, options) {
+ this.effects = effects || [];
+ this.start(options);
+ },
+
+ /** @id MochiKit.Visual.Parallel.prototype.update */
+ update: function (position) {
+ MochiKit.Base.map(function (effect) {
+ effect.render(position);
+ }, this.effects);
+ },
+
+ /** @id MochiKit.Visual.Parallel.prototype.finish */
+ finish: function () {
+ MochiKit.Base.map(function (effect) {
+ effect.finalize();
+ }, this.effects);
+ }
+});
+
+/** @id MochiKit.Visual.Opacity */
+MochiKit.Visual.Opacity = function (element, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, options);
+ }
+ this.__init__(element, options);
+};
+
+MochiKit.Visual.Opacity.prototype = new MochiKit.Visual.Base();
+
+MochiKit.Base.update(MochiKit.Visual.Opacity.prototype, {
+ /***
+
+ Change the opacity of an element.
+
+ @param options: 'from' and 'to' change the starting and ending opacities.
+ Must be between 0.0 and 1.0. Default to current opacity and 1.0.
+
+ ***/
+ __init__: function (element, /* optional */options) {
+ var b = MochiKit.Base;
+ var s = MochiKit.Style;
+ this.element = MochiKit.DOM.getElement(element);
+ // make this work on IE on elements without 'layout'
+ if (this.element.currentStyle &&
+ (!this.element.currentStyle.hasLayout)) {
+ s.setStyle(this.element, {zoom: 1});
+ }
+ options = b.update({
+ from: s.getOpacity(this.element) || 0.0,
+ to: 1.0
+ }, options || {});
+ this.start(options);
+ },
+
+ /** @id MochiKit.Visual.Opacity.prototype.update */
+ update: function (position) {
+ MochiKit.Style.setOpacity(this.element, position);
+ }
+});
+
+/** @id MochiKit.Visual.Opacity.prototype.Move */
+MochiKit.Visual.Move = function (element, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, options);
+ }
+ this.__init__(element, options);
+};
+
+MochiKit.Visual.Move.prototype = new MochiKit.Visual.Base();
+
+MochiKit.Base.update(MochiKit.Visual.Move.prototype, {
+ /***
+
+ Move an element between its current position to a defined position
+
+ @param options: 'x' and 'y' for final positions, default to 0, 0.
+
+ ***/
+ __init__: function (element, /* optional */options) {
+ this.element = MochiKit.DOM.getElement(element);
+ options = MochiKit.Base.update({
+ x: 0,
+ y: 0,
+ mode: 'relative'
+ }, options || {});
+ this.start(options);
+ },
+
+ /** @id MochiKit.Visual.Move.prototype.setup */
+ setup: function () {
+ // Bug in Opera: Opera returns the 'real' position of a static element
+ // or relative element that does not have top/left explicitly set.
+ // ==> Always set top and left for position relative elements in your
+ // stylesheets (to 0 if you do not need them)
+ MochiKit.DOM.makePositioned(this.element);
+
+ var s = this.element.style;
+ var originalVisibility = s.visibility;
+ var originalDisplay = s.display;
+ if (originalDisplay == 'none') {
+ s.visibility = 'hidden';
+ s.display = '';
+ }
+
+ this.originalLeft = parseFloat(MochiKit.Style.getStyle(this.element, 'left') || '0');
+ this.originalTop = parseFloat(MochiKit.Style.getStyle(this.element, 'top') || '0');
+
+ if (this.options.mode == 'absolute') {
+ // absolute movement, so we need to calc deltaX and deltaY
+ this.options.x -= this.originalLeft;
+ this.options.y -= this.originalTop;
+ }
+ if (originalDisplay == 'none') {
+ s.visibility = originalVisibility;
+ s.display = originalDisplay;
+ }
+ },
+
+ /** @id MochiKit.Visual.Move.prototype.update */
+ update: function (position) {
+ MochiKit.Style.setStyle(this.element, {
+ left: Math.round(this.options.x * position + this.originalLeft) + 'px',
+ top: Math.round(this.options.y * position + this.originalTop) + 'px'
+ });
+ }
+});
+
+/** @id MochiKit.Visual.Scale */
+MochiKit.Visual.Scale = function (element, percent, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, percent, options);
+ }
+ this.__init__(element, percent, options);
+};
+
+MochiKit.Visual.Scale.prototype = new MochiKit.Visual.Base();
+
+MochiKit.Base.update(MochiKit.Visual.Scale.prototype, {
+ /***
+
+ Change the size of an element.
+
+ @param percent: final_size = percent*original_size
+
+ @param options: several options changing scale behaviour
+
+ ***/
+ __init__: function (element, percent, /* optional */options) {
+ this.element = MochiKit.DOM.getElement(element)
+ options = MochiKit.Base.update({
+ scaleX: true,
+ scaleY: true,
+ scaleContent: true,
+ scaleFromCenter: false,
+ scaleMode: 'box', // 'box' or 'contents' or {} with provided values
+ scaleFrom: 100.0,
+ scaleTo: percent
+ }, options || {});
+ this.start(options);
+ },
+
+ /** @id MochiKit.Visual.Scale.prototype.setup */
+ setup: function () {
+ this.restoreAfterFinish = this.options.restoreAfterFinish || false;
+ this.elementPositioning = MochiKit.Style.getStyle(this.element,
+ 'position');
+
+ var ma = MochiKit.Base.map;
+ var b = MochiKit.Base.bind;
+ this.originalStyle = {};
+ ma(b(function (k) {
+ this.originalStyle[k] = this.element.style[k];
+ }, this), ['top', 'left', 'width', 'height', 'fontSize']);
+
+ this.originalTop = this.element.offsetTop;
+ this.originalLeft = this.element.offsetLeft;
+
+ var fontSize = MochiKit.Style.getStyle(this.element,
+ 'font-size') || '100%';
+ ma(b(function (fontSizeType) {
+ if (fontSize.indexOf(fontSizeType) > 0) {
+ this.fontSize = parseFloat(fontSize);
+ this.fontSizeType = fontSizeType;
+ }
+ }, this), ['em', 'px', '%']);
+
+ this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
+
+ if (/^content/.test(this.options.scaleMode)) {
+ this.dims = [this.element.scrollHeight, this.element.scrollWidth];
+ } else if (this.options.scaleMode == 'box') {
+ this.dims = [this.element.offsetHeight, this.element.offsetWidth];
+ } else {
+ this.dims = [this.options.scaleMode.originalHeight,
+ this.options.scaleMode.originalWidth];
+ }
+ },
+
+ /** @id MochiKit.Visual.Scale.prototype.update */
+ update: function (position) {
+ var currentScale = (this.options.scaleFrom/100.0) +
+ (this.factor * position);
+ if (this.options.scaleContent && this.fontSize) {
+ MochiKit.Style.setStyle(this.element, {
+ fontSize: this.fontSize * currentScale + this.fontSizeType
+ });
+ }
+ this.setDimensions(this.dims[0] * currentScale,
+ this.dims[1] * currentScale);
+ },
+
+ /** @id MochiKit.Visual.Scale.prototype.finish */
+ finish: function () {
+ if (this.restoreAfterFinish) {
+ MochiKit.Style.setStyle(this.element, this.originalStyle);
+ }
+ },
+
+ /** @id MochiKit.Visual.Scale.prototype.setDimensions */
+ setDimensions: function (height, width) {
+ var d = {};
+ var r = Math.round;
+ if (/MSIE/.test(navigator.userAgent)) {
+ r = Math.ceil;
+ }
+ if (this.options.scaleX) {
+ d.width = r(width) + 'px';
+ }
+ if (this.options.scaleY) {
+ d.height = r(height) + 'px';
+ }
+ if (this.options.scaleFromCenter) {
+ var topd = (height - this.dims[0])/2;
+ var leftd = (width - this.dims[1])/2;
+ if (this.elementPositioning == 'absolute') {
+ if (this.options.scaleY) {
+ d.top = this.originalTop - topd + 'px';
+ }
+ if (this.options.scaleX) {
+ d.left = this.originalLeft - leftd + 'px';
+ }
+ } else {
+ if (this.options.scaleY) {
+ d.top = -topd + 'px';
+ }
+ if (this.options.scaleX) {
+ d.left = -leftd + 'px';
+ }
+ }
+ }
+ MochiKit.Style.setStyle(this.element, d);
+ }
+});
+
+/** @id MochiKit.Visual.Highlight */
+MochiKit.Visual.Highlight = function (element, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, options);
+ }
+ this.__init__(element, options);
+};
+
+MochiKit.Visual.Highlight.prototype = new MochiKit.Visual.Base();
+
+MochiKit.Base.update(MochiKit.Visual.Highlight.prototype, {
+ /***
+
+ Highlight an item of the page.
+
+ @param options: 'startcolor' for choosing highlighting color, default
+ to '#ffff99'.
+
+ ***/
+ __init__: function (element, /* optional */options) {
+ this.element = MochiKit.DOM.getElement(element);
+ options = MochiKit.Base.update({
+ startcolor: '#ffff99'
+ }, options || {});
+ this.start(options);
+ },
+
+ /** @id MochiKit.Visual.Highlight.prototype.setup */
+ setup: function () {
+ var b = MochiKit.Base;
+ var s = MochiKit.Style;
+ // Prevent executing on elements not in the layout flow
+ if (s.getStyle(this.element, 'display') == 'none') {
+ this.cancel();
+ return;
+ }
+ // Disable background image during the effect
+ this.oldStyle = {
+ backgroundImage: s.getStyle(this.element, 'background-image')
+ };
+ s.setStyle(this.element, {
+ backgroundImage: 'none'
+ });
+
+ if (!this.options.endcolor) {
+ this.options.endcolor =
+ MochiKit.Color.Color.fromBackground(this.element).toHexString();
+ }
+ if (b.isUndefinedOrNull(this.options.restorecolor)) {
+ this.options.restorecolor = s.getStyle(this.element,
+ 'background-color');
+ }
+ // init color calculations
+ this._base = b.map(b.bind(function (i) {
+ return parseInt(
+ this.options.startcolor.slice(i*2 + 1, i*2 + 3), 16);
+ }, this), [0, 1, 2]);
+ this._delta = b.map(b.bind(function (i) {
+ return parseInt(this.options.endcolor.slice(i*2 + 1, i*2 + 3), 16)
+ - this._base[i];
+ }, this), [0, 1, 2]);
+ },
+
+ /** @id MochiKit.Visual.Highlight.prototype.update */
+ update: function (position) {
+ var m = '#';
+ MochiKit.Base.map(MochiKit.Base.bind(function (i) {
+ m += MochiKit.Color.toColorPart(Math.round(this._base[i] +
+ this._delta[i]*position));
+ }, this), [0, 1, 2]);
+ MochiKit.Style.setStyle(this.element, {
+ backgroundColor: m
+ });
+ },
+
+ /** @id MochiKit.Visual.Highlight.prototype.finish */
+ finish: function () {
+ MochiKit.Style.setStyle(this.element,
+ MochiKit.Base.update(this.oldStyle, {
+ backgroundColor: this.options.restorecolor
+ }));
+ }
+});
+
+/** @id MochiKit.Visual.ScrollTo */
+MochiKit.Visual.ScrollTo = function (element, options) {
+ var cls = arguments.callee;
+ if (!(this instanceof cls)) {
+ return new cls(element, options);
+ }
+ this.__init__(element, options);
+};
+
+MochiKit.Visual.ScrollTo.prototype = new MochiKit.Visual.Base();
+
+MochiKit.Base.update(MochiKit.Visual.ScrollTo.prototype, {
+ /***
+
+ Scroll to an element in the page.
+
+ ***/
+ __init__: function (element, /* optional */options) {
+ this.element = MochiKit.DOM.getElement(element);
+ this.start(options || {});
+ },
+
+ /** @id MochiKit.Visual.ScrollTo.prototype.setup */
+ setup: function () {
+ var p = MochiKit.Position;
+ p.prepare();
+ var offsets = p.cumulativeOffset(this.element);
+ if (this.options.offset) {
+ offsets.y += this.options.offset;
+ }
+ var max;
+ if (window.innerHeight) {
+ max = window.innerHeight - window.height;
+ } else if (document.documentElement &&
+ document.documentElement.clientHeight) {
+ max = document.documentElement.clientHeight -
+ document.body.scrollHeight;
+ } else if (document.body) {
+ max = document.body.clientHeight - document.body.scrollHeight;
+ }
+ this.scrollStart = p.windowOffset.y;
+ this.delta = (offsets.y > max ? max : offsets.y) - this.scrollStart;
+ },
+
+ /** @id MochiKit.Visual.ScrollTo.prototype.update */
+ update: function (position) {
+ var p = MochiKit.Position;
+ p.prepare();
+ window.scrollTo(p.windowOffset.x, this.scrollStart + (position * this.delta));
+ }
+});
+
+/***
+
+Combination effects.
+
+***/
+
+/** @id MochiKit.Visual.fade */
+MochiKit.Visual.fade = function (element, /* optional */ options) {
+ /***
+
+ Fade a given element: change its opacity and hide it in the end.
+
+ @param options: 'to' and 'from' to change opacity.
+
+ ***/
+ var s = MochiKit.Style;
+ var oldOpacity = MochiKit.DOM.getElement(element).style.opacity || '';
+ options = MochiKit.Base.update({
+ from: s.getOpacity(element) || 1.0,
+ to: 0.0,
+ afterFinishInternal: function (effect) {
+ if (effect.options.to !== 0) {
+ return;
+ }
+ s.hideElement(effect.element);
+ s.setStyle(effect.element, {opacity: oldOpacity});
+ }
+ }, options || {});
+ return new MochiKit.Visual.Opacity(element, options);
+};
+
+/** @id MochiKit.Visual.appear */
+MochiKit.Visual.appear = function (element, /* optional */ options) {
+ /***
+
+ Make an element appear.
+
+ @param options: 'to' and 'from' to change opacity.
+
+ ***/
+ var s = MochiKit.Style;
+ var v = MochiKit.Visual;
+ options = MochiKit.Base.update({
+ from: (s.getStyle(element, 'display') == 'none' ? 0.0 :
+ s.getOpacity(element) || 0.0),
+ to: 1.0,
+ // force Safari to render floated elements properly
+ afterFinishInternal: function (effect) {
+ v.forceRerendering(effect.element);
+ },
+ beforeSetupInternal: function (effect) {
+ s.setOpacity(effect.element, effect.options.from);
+ s.showElement(effect.element);
+ }
+ }, options || {});
+ return new v.Opacity(element, options);
+};
+
+/** @id MochiKit.Visual.puff */
+MochiKit.Visual.puff = function (element, /* optional */ options) {
+ /***
+
+ 'Puff' an element: grow it to double size, fading it and make it hidden.
+
+ ***/
+ var s = MochiKit.Style;
+ var v = MochiKit.Visual;
+ element = MochiKit.DOM.getElement(element);
+ var oldStyle = {
+ opacity: element.style.opacity || '',
+ position: s.getStyle(element, 'position'),
+ top: element.style.top,
+ left: element.style.left,
+ width: element.style.width,
+ height: element.style.height
+ };
+ options = MochiKit.Base.update({
+ beforeSetupInternal: function (effect) {
+ MochiKit.Position.absolutize(effect.effects[0].element)
+ },
+ afterFinishInternal: function (effect) {
+ s.hideElement(effect.effects[0].element);
+ s.setStyle(effect.effects[0].element, oldStyle);
+ }
+ }, options || {});
+ return new v.Parallel(
+ [new v.Scale(element, 200,
+ {sync: true, scaleFromCenter: true,
+ scaleContent: true, restoreAfterFinish: true}),
+ new v.Opacity(element, {sync: true, to: 0.0 })],
+ options);
+};
+
+/** @id MochiKit.Visual.blindUp */
+MochiKit.Visual.blindUp = function (element, /* optional */ options) {
+ /***
+
+ Blind an element up: change its vertical size to 0.
+
+ ***/
+ var d = MochiKit.DOM;
+ element = d.getElement(element);
+ var elemClip = d.makeClipping(element);
+ options = MochiKit.Base.update({
+ scaleContent: false,
+ scaleX: false,
+ restoreAfterFinish: true,
+ afterFinishInternal: function (effect) {
+ MochiKit.Style.hideElement(effect.element);
+ d.undoClipping(effect.element, elemClip);
+ }
+ }, options || {});
+
+ return new MochiKit.Visual.Scale(element, 0, options);
+};
+
+/** @id MochiKit.Visual.blindDown */
+MochiKit.Visual.blindDown = function (element, /* optional */ options) {
+ /***
+
+ Blind an element down: restore its vertical size.
+
+ ***/
+ var d = MochiKit.DOM;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ var elementDimensions = s.getElementDimensions(element);
+ var elemClip;
+ options = MochiKit.Base.update({
+ scaleContent: false,
+ scaleX: false,
+ scaleFrom: 0,
+ scaleMode: {originalHeight: elementDimensions.h,
+ originalWidth: elementDimensions.w},
+ restoreAfterFinish: true,
+ afterSetupInternal: function (effect) {
+ elemClip = d.makeClipping(effect.element);
+ s.setStyle(effect.element, {height: '0px'});
+ s.showElement(effect.element);
+ },
+ afterFinishInternal: function (effect) {
+ d.undoClipping(effect.element, elemClip);
+ }
+ }, options || {});
+ return new MochiKit.Visual.Scale(element, 100, options);
+};
+
+/** @id MochiKit.Visual.switchOff */
+MochiKit.Visual.switchOff = function (element, /* optional */ options) {
+ /***
+
+ Apply a switch-off-like effect.
+
+ ***/
+ var d = MochiKit.DOM;
+ element = d.getElement(element);
+ var oldOpacity = element.style.opacity || '';
+ var elemClip;
+ var options = MochiKit.Base.update({
+ duration: 0.3,
+ scaleFromCenter: true,
+ scaleX: false,
+ scaleContent: false,
+ restoreAfterFinish: true,
+ beforeSetupInternal: function (effect) {
+ d.makePositioned(effect.element);
+ elemClip = d.makeClipping(effect.element);
+ },
+ afterFinishInternal: function (effect) {
+ MochiKit.Style.hideElement(effect.element);
+ d.undoClipping(effect.element, elemClip);
+ d.undoPositioned(effect.element);
+ MochiKit.Style.setStyle(effect.element, {opacity: oldOpacity});
+ }
+ }, options || {});
+ var v = MochiKit.Visual;
+ return new v.appear(element, {
+ duration: 0.4,
+ from: 0,
+ transition: v.Transitions.flicker,
+ afterFinishInternal: function (effect) {
+ new v.Scale(effect.element, 1, options)
+ }
+ });
+};
+
+/** @id MochiKit.Visual.dropOut */
+MochiKit.Visual.dropOut = function (element, /* optional */ options) {
+ /***
+
+ Make an element fall and disappear.
+
+ ***/
+ var d = MochiKit.DOM;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ var oldStyle = {
+ top: s.getStyle(element, 'top'),
+ left: s.getStyle(element, 'left'),
+ opacity: element.style.opacity || ''
+ };
+
+ options = MochiKit.Base.update({
+ duration: 0.5,
+ beforeSetupInternal: function (effect) {
+ d.makePositioned(effect.effects[0].element);
+ },
+ afterFinishInternal: function (effect) {
+ s.hideElement(effect.effects[0].element);
+ d.undoPositioned(effect.effects[0].element);
+ s.setStyle(effect.effects[0].element, oldStyle);
+ }
+ }, options || {});
+ var v = MochiKit.Visual;
+ return new v.Parallel(
+ [new v.Move(element, {x: 0, y: 100, sync: true}),
+ new v.Opacity(element, {sync: true, to: 0.0})],
+ options);
+};
+
+/** @id MochiKit.Visual.shake */
+MochiKit.Visual.shake = function (element, /* optional */ options) {
+ /***
+
+ Move an element from left to right several times.
+
+ ***/
+ var d = MochiKit.DOM;
+ var v = MochiKit.Visual;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ options = MochiKit.Base.update({
+ x: -20,
+ y: 0,
+ duration: 0.05,
+ afterFinishInternal: function (effect) {
+ d.undoPositioned(effect.element);
+ s.setStyle(effect.element, oldStyle);
+ }
+ }, options || {});
+ var oldStyle = {
+ top: s.getStyle(element, 'top'),
+ left: s.getStyle(element, 'left') };
+ return new v.Move(element,
+ {x: 20, y: 0, duration: 0.05, afterFinishInternal: function (effect) {
+ new v.Move(effect.element,
+ {x: -40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
+ new v.Move(effect.element,
+ {x: 40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
+ new v.Move(effect.element,
+ {x: -40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
+ new v.Move(effect.element,
+ {x: 40, y: 0, duration: 0.1, afterFinishInternal: function (effect) {
+ new v.Move(effect.element, options
+ ) }}) }}) }}) }}) }});
+};
+
+/** @id MochiKit.Visual.slideDown */
+MochiKit.Visual.slideDown = function (element, /* optional */ options) {
+ /***
+
+ Slide an element down.
+ It needs to have the content of the element wrapped in a container
+ element with fixed height.
+
+ ***/
+ var d = MochiKit.DOM;
+ var b = MochiKit.Base;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ if (!element.firstChild) {
+ throw "MochiKit.Visual.slideDown must be used on a element with a child";
+ }
+ d.removeEmptyTextNodes(element);
+ var oldInnerBottom = s.getStyle(element.firstChild, 'bottom') || 0;
+ var elementDimensions = s.getElementDimensions(element);
+ var elemClip;
+ options = b.update({
+ scaleContent: false,
+ scaleX: false,
+ scaleFrom: 0,
+ scaleMode: {originalHeight: elementDimensions.h,
+ originalWidth: elementDimensions.w},
+ restoreAfterFinish: true,
+ afterSetupInternal: function (effect) {
+ d.makePositioned(effect.element);
+ d.makePositioned(effect.element.firstChild);
+ if (/Opera/.test(navigator.userAgent)) {
+ s.setStyle(effect.element, {top: ''});
+ }
+ elemClip = d.makeClipping(effect.element);
+ s.setStyle(effect.element, {height: '0px'});
+ s.showElement(effect.element);
+ },
+ afterUpdateInternal: function (effect) {
+ s.setStyle(effect.element.firstChild,
+ {bottom: (effect.dims[0] - effect.element.clientHeight) + 'px'})
+ },
+ afterFinishInternal: function (effect) {
+ d.undoClipping(effect.element, elemClip);
+ // IE will crash if child is undoPositioned first
+ if (/MSIE/.test(navigator.userAgent)) {
+ d.undoPositioned(effect.element);
+ d.undoPositioned(effect.element.firstChild);
+ } else {
+ d.undoPositioned(effect.element.firstChild);
+ d.undoPositioned(effect.element);
+ }
+ s.setStyle(effect.element.firstChild,
+ {bottom: oldInnerBottom});
+ }
+ }, options || {});
+
+ return new MochiKit.Visual.Scale(element, 100, options);
+};
+
+/** @id MochiKit.Visual.slideUp */
+MochiKit.Visual.slideUp = function (element, /* optional */ options) {
+ /***
+
+ Slide an element up.
+ It needs to have the content of the element wrapped in a container
+ element with fixed height.
+
+ ***/
+ var d = MochiKit.DOM;
+ var b = MochiKit.Base;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ if (!element.firstChild) {
+ throw "MochiKit.Visual.slideUp must be used on a element with a child";
+ }
+ d.removeEmptyTextNodes(element);
+ var oldInnerBottom = s.getStyle(element.firstChild, 'bottom');
+ var elemClip;
+ options = b.update({
+ scaleContent: false,
+ scaleX: false,
+ scaleMode: 'box',
+ scaleFrom: 100,
+ restoreAfterFinish: true,
+ beforeStartInternal: function (effect) {
+ d.makePositioned(effect.element);
+ d.makePositioned(effect.element.firstChild);
+ if (/Opera/.test(navigator.userAgent)) {
+ s.setStyle(effect.element, {top: ''});
+ }
+ elemClip = d.makeClipping(effect.element);
+ s.showElement(effect.element);
+ },
+ afterUpdateInternal: function (effect) {
+ s.setStyle(effect.element.firstChild,
+ {bottom: (effect.dims[0] - effect.element.clientHeight) + 'px'});
+ },
+ afterFinishInternal: function (effect) {
+ s.hideElement(effect.element);
+ d.undoClipping(effect.element, elemClip);
+ d.undoPositioned(effect.element.firstChild);
+ d.undoPositioned(effect.element);
+ s.setStyle(effect.element.firstChild, {bottom: oldInnerBottom});
+ }
+ }, options || {});
+ return new MochiKit.Visual.Scale(element, 0, options);
+};
+
+// Bug in opera makes the TD containing this element expand for a instance
+// after finish
+/** @id MochiKit.Visual.squish */
+MochiKit.Visual.squish = function (element, /* optional */ options) {
+ /***
+
+ Reduce an element and make it disappear.
+
+ ***/
+ var d = MochiKit.DOM;
+ var b = MochiKit.Base;
+ var elemClip;
+ options = b.update({
+ restoreAfterFinish: true,
+ beforeSetupInternal: function (effect) {
+ elemClip = d.makeClipping(effect.element);
+ },
+ afterFinishInternal: function (effect) {
+ MochiKit.Style.hideElement(effect.element);
+ d.undoClipping(effect.element, elemClip);
+ }
+ }, options || {});
+
+ return new MochiKit.Visual.Scale(element, /Opera/.test(navigator.userAgent) ? 1 : 0, options);
+};
+
+/** @id MochiKit.Visual.grow */
+MochiKit.Visual.grow = function (element, /* optional */ options) {
+ /***
+
+ Grow an element to its original size. Make it zero-sized before
+ if necessary.
+
+ ***/
+ var d = MochiKit.DOM;
+ var v = MochiKit.Visual;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ options = MochiKit.Base.update({
+ direction: 'center',
+ moveTransition: v.Transitions.sinoidal,
+ scaleTransition: v.Transitions.sinoidal,
+ opacityTransition: v.Transitions.full
+ }, options || {});
+ var oldStyle = {
+ top: element.style.top,
+ left: element.style.left,
+ height: element.style.height,
+ width: element.style.width,
+ opacity: element.style.opacity || ''
+ };
+
+ var dims = s.getElementDimensions(element);
+ var initialMoveX, initialMoveY;
+ var moveX, moveY;
+
+ switch (options.direction) {
+ case 'top-left':
+ initialMoveX = initialMoveY = moveX = moveY = 0;
+ break;
+ case 'top-right':
+ initialMoveX = dims.w;
+ initialMoveY = moveY = 0;
+ moveX = -dims.w;
+ break;
+ case 'bottom-left':
+ initialMoveX = moveX = 0;
+ initialMoveY = dims.h;
+ moveY = -dims.h;
+ break;
+ case 'bottom-right':
+ initialMoveX = dims.w;
+ initialMoveY = dims.h;
+ moveX = -dims.w;
+ moveY = -dims.h;
+ break;
+ case 'center':
+ initialMoveX = dims.w / 2;
+ initialMoveY = dims.h / 2;
+ moveX = -dims.w / 2;
+ moveY = -dims.h / 2;
+ break;
+ }
+
+ var optionsParallel = MochiKit.Base.update({
+ beforeSetupInternal: function (effect) {
+ s.setStyle(effect.effects[0].element, {height: '0px'});
+ s.showElement(effect.effects[0].element);
+ },
+ afterFinishInternal: function (effect) {
+ d.undoClipping(effect.effects[0].element);
+ d.undoPositioned(effect.effects[0].element);
+ s.setStyle(effect.effects[0].element, oldStyle);
+ }
+ }, options || {});
+
+ return new v.Move(element, {
+ x: initialMoveX,
+ y: initialMoveY,
+ duration: 0.01,
+ beforeSetupInternal: function (effect) {
+ s.hideElement(effect.element);
+ d.makeClipping(effect.element);
+ d.makePositioned(effect.element);
+ },
+ afterFinishInternal: function (effect) {
+ new v.Parallel(
+ [new v.Opacity(effect.element, {
+ sync: true, to: 1.0, from: 0.0,
+ transition: options.opacityTransition
+ }),
+ new v.Move(effect.element, {
+ x: moveX, y: moveY, sync: true,
+ transition: options.moveTransition
+ }),
+ new v.Scale(effect.element, 100, {
+ scaleMode: {originalHeight: dims.h,
+ originalWidth: dims.w},
+ sync: true,
+ scaleFrom: /Opera/.test(navigator.userAgent) ? 1 : 0,
+ transition: options.scaleTransition,
+ restoreAfterFinish: true
+ })
+ ], optionsParallel
+ );
+ }
+ });
+};
+
+/** @id MochiKit.Visual.shrink */
+MochiKit.Visual.shrink = function (element, /* optional */ options) {
+ /***
+
+ Shrink an element and make it disappear.
+
+ ***/
+ var d = MochiKit.DOM;
+ var v = MochiKit.Visual;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ options = MochiKit.Base.update({
+ direction: 'center',
+ moveTransition: v.Transitions.sinoidal,
+ scaleTransition: v.Transitions.sinoidal,
+ opacityTransition: v.Transitions.none
+ }, options || {});
+ var oldStyle = {
+ top: element.style.top,
+ left: element.style.left,
+ height: element.style.height,
+ width: element.style.width,
+ opacity: element.style.opacity || ''
+ };
+
+ var dims = s.getElementDimensions(element);
+ var moveX, moveY;
+
+ switch (options.direction) {
+ case 'top-left':
+ moveX = moveY = 0;
+ break;
+ case 'top-right':
+ moveX = dims.w;
+ moveY = 0;
+ break;
+ case 'bottom-left':
+ moveX = 0;
+ moveY = dims.h;
+ break;
+ case 'bottom-right':
+ moveX = dims.w;
+ moveY = dims.h;
+ break;
+ case 'center':
+ moveX = dims.w / 2;
+ moveY = dims.h / 2;
+ break;
+ }
+ var elemClip;
+
+ var optionsParallel = MochiKit.Base.update({
+ beforeStartInternal: function (effect) {
+ elemClip = d.makePositioned(effect.effects[0].element);
+ d.makeClipping(effect.effects[0].element);
+ },
+ afterFinishInternal: function (effect) {
+ s.hideElement(effect.effects[0].element);
+ d.undoClipping(effect.effects[0].element, elemClip);
+ d.undoPositioned(effect.effects[0].element);
+ s.setStyle(effect.effects[0].element, oldStyle);
+ }
+ }, options || {});
+
+ return new v.Parallel(
+ [new v.Opacity(element, {
+ sync: true, to: 0.0, from: 1.0,
+ transition: options.opacityTransition
+ }),
+ new v.Scale(element, /Opera/.test(navigator.userAgent) ? 1 : 0, {
+ sync: true, transition: options.scaleTransition,
+ restoreAfterFinish: true
+ }),
+ new v.Move(element, {
+ x: moveX, y: moveY, sync: true, transition: options.moveTransition
+ })
+ ], optionsParallel
+ );
+};
+
+/** @id MochiKit.Visual.pulsate */
+MochiKit.Visual.pulsate = function (element, /* optional */ options) {
+ /***
+
+ Pulse an element between appear/fade.
+
+ ***/
+ var d = MochiKit.DOM;
+ var v = MochiKit.Visual;
+ var b = MochiKit.Base;
+ var oldOpacity = d.getElement(element).style.opacity || '';
+ options = b.update({
+ duration: 3.0,
+ from: 0,
+ afterFinishInternal: function (effect) {
+ MochiKit.Style.setStyle(effect.element, {opacity: oldOpacity});
+ }
+ }, options || {});
+ var transition = options.transition || v.Transitions.sinoidal;
+ var reverser = b.bind(function (pos) {
+ return transition(1 - v.Transitions.pulse(pos));
+ }, transition);
+ b.bind(reverser, transition);
+ return new v.Opacity(element, b.update({
+ transition: reverser}, options));
+};
+
+/** @id MochiKit.Visual.fold */
+MochiKit.Visual.fold = function (element, /* optional */ options) {
+ /***
+
+ Fold an element, first vertically, then horizontally.
+
+ ***/
+ var d = MochiKit.DOM;
+ var v = MochiKit.Visual;
+ var s = MochiKit.Style;
+ element = d.getElement(element);
+ var oldStyle = {
+ top: element.style.top,
+ left: element.style.left,
+ width: element.style.width,
+ height: element.style.height
+ };
+ var elemClip = d.makeClipping(element);
+ options = MochiKit.Base.update({
+ scaleContent: false,
+ scaleX: false,
+ afterFinishInternal: function (effect) {
+ new v.Scale(element, 1, {
+ scaleContent: false,
+ scaleY: false,
+ afterFinishInternal: function (effect) {
+ s.hideElement(effect.element);
+ d.undoClipping(effect.element, elemClip);
+ s.setStyle(effect.element, oldStyle);
+ }
+ });
+ }
+ }, options || {});
+ return new v.Scale(element, 5, options);
+};
+
+
// Compatibility with MochiKit 1.0
MochiKit.Visual.Color = MochiKit.Color.Color;
MochiKit.Visual.getElementsComputedStyle = MochiKit.DOM.computedStyle;
/* end of Rico adaptation */
-MochiKit.Visual.__new__ = function () {
+MochiKit.Visual.__new__ = function () {
var m = MochiKit.Base;
m.nameFunctions(this);
@@ -392,10 +1818,37 @@ MochiKit.Visual.__new__ = function () {
MochiKit.Visual.EXPORT = [
"roundElement",
- "roundClass"
+ "roundClass",
+ "tagifyText",
+ "multiple",
+ "toggle",
+ "Parallel",
+ "Opacity",
+ "Move",
+ "Scale",
+ "Highlight",
+ "ScrollTo",
+ "fade",
+ "appear",
+ "puff",
+ "blindUp",
+ "blindDown",
+ "switchOff",
+ "dropOut",
+ "shake",
+ "slideDown",
+ "slideUp",
+ "squish",
+ "grow",
+ "shrink",
+ "pulsate",
+ "fold"
];
-MochiKit.Visual.EXPORT_OK = [];
+MochiKit.Visual.EXPORT_OK = [
+ "Base",
+ "PAIRS"
+];
MochiKit.Visual.__new__();
diff --git a/thirdpartyjs/MochiKit/__package__.js b/thirdpartyjs/MochiKit/__package__.js
index 2f5be0d..8d644b1 100644
--- a/thirdpartyjs/MochiKit/__package__.js
+++ b/thirdpartyjs/MochiKit/__package__.js
@@ -1,2 +1,18 @@
-dojo.hostenv.conditionalLoadModule({"common": ["MochiKit.MochiKit"]});
-dojo.hostenv.moduleLoaded("MochiKit.*");
+dojo.kwCompoundRequire({
+ "common": [
+ "MochiKit.Base",
+ "MochiKit.Iter",
+ "MochiKit.Logging",
+ "MochiKit.DateTime",
+ "MochiKit.Format",
+ "MochiKit.Async",
+ "MochiKit.DOM",
+ "MochiKit.Style",
+ "MochiKit.LoggingPane",
+ "MochiKit.Color",
+ "MochiKit.Signal",
+ "MochiKit.Position",
+ "MochiKit.Visual"
+ ]
+});
+dojo.provide("MochiKit.*");