/* Prototype JavaScript framework, version 1.6.0.3
 * (c) 2005-2008 Sam Stephenson
 *
 * Prototype is freely distributable under the terms of an MIT-style license.
 * For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var Prototype = {
 Version: '1.6.0.3',

 Browser: {
 IE: !!(window.attachEvent &&
 navigator.userAgent.indexOf('Opera') === -1),
 Opera: navigator.userAgent.indexOf('Opera') > -1,
 WebKit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
 Gecko: navigator.userAgent.indexOf('Gecko') > -1 &&
 navigator.userAgent.indexOf('KHTML') === -1,
 MobileSafari: !!navigator.userAgent.match(/Apple.*Mobile.*Safari/)
 },

 BrowserFeatures: {
 XPath: !!document.evaluate,
 SelectorsAPI: !!document.querySelector,
 ElementExtensions: !!window.HTMLElement,
 SpecificElementExtensions:
 document.createElement('div')['__proto__'] &&
 document.createElement('div')['__proto__'] !==
 document.createElement('form')['__proto__']
 },

 ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
 JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

 emptyFunction: function() { },
 K: function(x) { return x }
};

if (Prototype.Browser.MobileSafari)
 Prototype.BrowserFeatures.SpecificElementExtensions = false;


/* Based on Alex Arnell's inheritance implementation. */
var Class = {
 create: function() {
 var parent = null, properties = $A(arguments);
 if (Object.isFunction(properties[0]))
 parent = properties.shift();

 function klass() {
 this.initialize.apply(this, arguments);
 }

 Object.extend(klass, Class.Methods);
 klass.superclass = parent;
 klass.subclasses = [];

 if (parent) {
 var subclass = function() { };
 subclass.prototype = parent.prototype;
 klass.prototype = new subclass;
 parent.subclasses.push(klass);
 }

 for (var i = 0; i < properties.length; i++)
 klass.addMethods(properties[i]);

 if (!klass.prototype.initialize)
 klass.prototype.initialize = Prototype.emptyFunction;

 klass.prototype.constructor = klass;

 return klass;
 }
};

Class.Methods = {
 addMethods: function(source) {
 var ancestor = this.superclass && this.superclass.prototype;
 var properties = Object.keys(source);

 if (!Object.keys({ toString: true }).length)
 properties.push("toString", "valueOf");

 for (var i = 0, length = properties.length; i < length; i++) {
 var property = properties[i], value = source[property];
 if (ancestor && Object.isFunction(value) &&
 value.argumentNames().first() == "$super") {
 var method = value;
 value = (function(m) {
 return function() { return ancestor[m].apply(this, arguments) };
 })(property).wrap(method);

 value.valueOf = method.valueOf.bind(method);
 value.toString = method.toString.bind(method);
 }
 this.prototype[property] = value;
 }

 return this;
 }
};

var Abstract = { };

Object.extend = function(destination, source) {
 for (var property in source)
 destination[property] = source[property];
 return destination;
};

Object.extend(Object, {
 inspect: function(object) {
 try {
 if (Object.isUndefined(object)) return 'undefined';
 if (object === null) return 'null';
 return object.inspect ? object.inspect() : String(object);
 } catch (e) {
 if (e instanceof RangeError) return '...';
 throw e;
 }
 },

 toJSON: function(object) {
 var type = typeof object;
 switch (type) {
 case 'undefined':
 case 'function':
 case 'unknown': return;
 case 'boolean': return object.toString();
 }

 if (object === null) return 'null';
 if (object.toJSON) return object.toJSON();
 if (Object.isElement(object)) return;

 var results = [];
 for (var property in object) {
 var value = Object.toJSON(object[property]);
 if (!Object.isUndefined(value))
 results.push(property.toJSON() + ': ' + value);
 }

 return '{' + results.join(', ') + '}';
 },

 toQueryString: function(object) {
 return $H(object).toQueryString();
 },

 toHTML: function(object) {
 return object && object.toHTML ? object.toHTML() : String.interpret(object);
 },

 keys: function(object) {
 var keys = [];
 for (var property in object)
 keys.push(property);
 return keys;
 },

 values: function(object) {
 var values = [];
 for (var property in object)
 values.push(object[property]);
 return values;
 },

 clone: function(object) {
 return Object.extend({ }, object);
 },

 isElement: function(object) {
 return !!(object && object.nodeType == 1);
 },

 isArray: function(object) {
 return object != null && typeof object == "object" &&
 'splice' in object && 'join' in object;
 },

 isHash: function(object) {
 return object instanceof Hash;
 },

 isFunction: function(object) {
 return typeof object == "function";
 },

 isString: function(object) {
 return typeof object == "string";
 },

 isNumber: function(object) {
 return typeof object == "number";
 },

 isUndefined: function(object) {
 return typeof object == "undefined";
 }
});

Object.extend(Function.prototype, {
 argumentNames: function() {
 var names = this.toString().match(/^[\s\(]*function[^(]*\(([^\)]*)\)/)[1]
 .replace(/\s+/g, '').split(',');
 return names.length == 1 && !names[0] ? [] : names;
 },

 bind: function() {
 if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
 var __method = this, args = $A(arguments), object = args.shift();
 return function() {
 return __method.apply(object, args.concat($A(arguments)));
 }
 },

 bindAsEventListener: function() {
 var __method = this, args = $A(arguments), object = args.shift();
 return function(event) {
 return __method.apply(object, [event || window.event].concat(args));
 }
 },

 curry: function() {
 if (!arguments.length) return this;
 var __method = this, args = $A(arguments);
 return function() {
 return __method.apply(this, args.concat($A(arguments)));
 }
 },

 delay: function() {
 var __method = this, args = $A(arguments), timeout = args.shift() * 1000;
 return window.setTimeout(function() {
 return __method.apply(__method, args);
 }, timeout);
 },

 defer: function() {
 var args = [0.01].concat($A(arguments));
 return this.delay.apply(this, args);
 },

 wrap: function(wrapper) {
 var __method = this;
 return function() {
 return wrapper.apply(this, [__method.bind(this)].concat($A(arguments)));
 }
 },

 methodize: function() {
 if (this._methodized) return this._methodized;
 var __method = this;
 return this._methodized = function() {
 return __method.apply(null, [this].concat($A(arguments)));
 };
 }
});

Date.prototype.toJSON = function() {
 return '"' + this.getUTCFullYear() + '-' +
 (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
 this.getUTCDate().toPaddedString(2) + 'T' +
 this.getUTCHours().toPaddedString(2) + ':' +
 this.getUTCMinutes().toPaddedString(2) + ':' +
 this.getUTCSeconds().toPaddedString(2) + 'Z"';
};

var Try = {
 these: function() {
 var returnValue;

 for (var i = 0, length = arguments.length; i < length; i++) {
 var lambda = arguments[i];
 try {
 returnValue = lambda();
 break;
 } catch (e) { }
 }

 return returnValue;
 }
};

RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
 return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};

/*--------------------------------------------------------------------------*/

var PeriodicalExecuter = Class.create({
 initialize: function(callback, frequency) {
 this.callback = callback;
 this.frequency = frequency;
 this.currentlyExecuting = false;

 this.registerCallback();
 },

 registerCallback: function() {
 this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
 },

 execute: function() {
 this.callback(this);
 },

 stop: function() {
 if (!this.timer) return;
 clearInterval(this.timer);
 this.timer = null;
 },

 onTimerEvent: function() {
 if (!this.currentlyExecuting) {
 try {
 this.currentlyExecuting = true;
 this.execute();
 } finally {
 this.currentlyExecuting = false;
 }
 }
 }
});
Object.extend(String, {
 interpret: function(value) {
 return value == null ? '' : String(value);
 },
 specialChar: {
 '\b': '\\b',
 '\t': '\\t',
 '\n': '\\n',
 '\f': '\\f',
 '\r': '\\r',
 '\\': '\\\\'
 }
});

Object.extend(String.prototype, {
 gsub: function(pattern, replacement) {
 var result = '', source = this, match;
 replacement = arguments.callee.prepareReplacement(replacement);

 while (source.length > 0) {
 if (match = source.match(pattern)) {
 result += source.slice(0, match.index);
 result += String.interpret(replacement(match));
 source = source.slice(match.index + match[0].length);
 } else {
 result += source, source = '';
 }
 }
 return result;
 },

 sub: function(pattern, replacement, count) {
 replacement = this.gsub.prepareReplacement(replacement);
 count = Object.isUndefined(count) ? 1 : count;

 return this.gsub(pattern, function(match) {
 if (--count < 0) return match[0];
 return replacement(match);
 });
 },

 scan: function(pattern, iterator) {
 this.gsub(pattern, iterator);
 return String(this);
 },

 truncate: function(length, truncation) {
 length = length || 30;
 truncation = Object.isUndefined(truncation) ? '...' : truncation;
 return this.length > length ?
 this.slice(0, length - truncation.length) + truncation : String(this);
 },

 strip: function() {
 return this.replace(/^\s+/, '').replace(/\s+$/, '');
 },

 stripTags: function() {
 return this.replace(/<\/?[^>]+>/gi, '');
 },

 stripScripts: function() {
 return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
 },

 extractScripts: function() {
 var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
 var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
 return (this.match(matchAll) || []).map(function(scriptTag) {
 return (scriptTag.match(matchOne) || ['', ''])[1];
 });
 },

 evalScripts: function() {
 return this.extractScripts().map(function(script) { return eval(script) });
 },

 escapeHTML: function() {
 var self = arguments.callee;
 self.text.data = this;
 return self.div.innerHTML;
 },

 unescapeHTML: function() {
 var div = new Element('div');
 div.innerHTML = this.stripTags();
 return div.childNodes[0] ? (div.childNodes.length > 1 ?
 $A(div.childNodes).inject('', function(memo, node) { return memo+node.nodeValue }) :
 div.childNodes[0].nodeValue) : '';
 },

 toQueryParams: function(separator) {
 var match = this.strip().match(/([^?#]*)(#.*)?$/);
 if (!match) return { };

 return match[1].split(separator || '&').inject({ }, function(hash, pair) {
 if ((pair = pair.split('='))[0]) {
 var key = decodeURIComponent(pair.shift());
 var value = pair.length > 1 ? pair.join('=') : pair[0];
 if (value != undefined) value = decodeURIComponent(value);

 if (key in hash) {
 if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
 hash[key].push(value);
 }
 else hash[key] = value;
 }
 return hash;
 });
 },

 toArray: function() {
 return this.split('');
 },

 succ: function() {
 return this.slice(0, this.length - 1) +
 String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
 },

 times: function(count) {
 return count < 1 ? '' : new Array(count + 1).join(this);
 },

 camelize: function() {
 var parts = this.split('-'), len = parts.length;
 if (len == 1) return parts[0];

 var camelized = this.charAt(0) == '-'
 ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
 : parts[0];

 for (var i = 1; i < len; i++)
 camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

 return camelized;
 },

 capitalize: function() {
 return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
 },

 underscore: function() {
 return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/([a-z\d])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
 },

 dasherize: function() {
 return this.gsub(/_/,'-');
 },

 inspect: function(useDoubleQuotes) {
 var escapedString = this.gsub(/[\x00-\x1f\\]/, function(match) {
 var character = String.specialChar[match[0]];
 return character ? character : '\\u00' + match[0].charCodeAt().toPaddedString(2, 16);
 });
 if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
 return "'" + escapedString.replace(/'/g, '\\\'') + "'";
 },

 toJSON: function() {
 return this.inspect(true);
 },

 unfilterJSON: function(filter) {
 return this.sub(filter || Prototype.JSONFilter, '#{1}');
 },

 isJSON: function() {
 var str = this;
 if (str.blank()) return false;
 str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
 return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
 },

 evalJSON: function(sanitize) {
 var json = this.unfilterJSON();
 try {
 if (!sanitize || json.isJSON()) return eval('(' + json + ')');
 } catch (e) { }
 throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
 },

 include: function(pattern) {
 return this.indexOf(pattern) > -1;
 },

 startsWith: function(pattern) {
 return this.indexOf(pattern) === 0;
 },

 endsWith: function(pattern) {
 var d = this.length - pattern.length;
 return d >= 0 && this.lastIndexOf(pattern) === d;
 },

 empty: function() {
 return this == '';
 },

 blank: function() {
 return /^\s*$/.test(this);
 },

 interpolate: function(object, pattern) {
 return new Template(this, pattern).evaluate(object);
 }
});

if (Prototype.Browser.WebKit || Prototype.Browser.IE) Object.extend(String.prototype, {
 escapeHTML: function() {
 return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
 },
 unescapeHTML: function() {
 return this.stripTags().replace(/&amp;/g,'&').replace(/&lt;/g,'<').replace(/&gt;/g,'>');
 }
});

String.prototype.gsub.prepareReplacement = function(replacement) {
 if (Object.isFunction(replacement)) return replacement;
 var template = new Template(replacement);
 return function(match) { return template.evaluate(match) };
};

String.prototype.parseQuery = String.prototype.toQueryParams;

Object.extend(String.prototype.escapeHTML, {
 div: document.createElement('div'),
 text: document.createTextNode('')
});

String.prototype.escapeHTML.div.appendChild(String.prototype.escapeHTML.text);

var Template = Class.create({
 initialize: function(template, pattern) {
 this.template = template.toString();
 this.pattern = pattern || Template.Pattern;
 },

 evaluate: function(object) {
 if (Object.isFunction(object.toTemplateReplacements))
 object = object.toTemplateReplacements();

 return this.template.gsub(this.pattern, function(match) {
 if (object == null) return '';

 var before = match[1] || '';
 if (before == '\\') return match[2];

 var ctx = object, expr = match[3];
 var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
 match = pattern.exec(expr);
 if (match == null) return before;

 while (match != null) {
 var comp = match[1].startsWith('[') ? match[2].gsub('\\\\]', ']') : match[1];
 ctx = ctx[comp];
 if (null == ctx || '' == match[3]) break;
 expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
 match = pattern.exec(expr);
 }

 return before + String.interpret(ctx);
 });
 }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

var Enumerable = {
 each: function(iterator, context) {
 var index = 0;
 try {
 this._each(function(value) {
 iterator.call(context, value, index++);
 });
 } catch (e) {
 if (e != $break) throw e;
 }
 return this;
 },

 eachSlice: function(number, iterator, context) {
 var index = -number, slices = [], array = this.toArray();
 if (number < 1) return array;
 while ((index += number) < array.length)
 slices.push(array.slice(index, index+number));
 return slices.collect(iterator, context);
 },

 all: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result = true;
 this.each(function(value, index) {
 result = result && !!iterator.call(context, value, index);
 if (!result) throw $break;
 });
 return result;
 },

 any: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result = false;
 this.each(function(value, index) {
 if (result = !!iterator.call(context, value, index))
 throw $break;
 });
 return result;
 },

 collect: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var results = [];
 this.each(function(value, index) {
 results.push(iterator.call(context, value, index));
 });
 return results;
 },

 detect: function(iterator, context) {
 var result;
 this.each(function(value, index) {
 if (iterator.call(context, value, index)) {
 result = value;
 throw $break;
 }
 });
 return result;
 },

 findAll: function(iterator, context) {
 var results = [];
 this.each(function(value, index) {
 if (iterator.call(context, value, index))
 results.push(value);
 });
 return results;
 },

 grep: function(filter, iterator, context) {
 iterator = iterator || Prototype.K;
 var results = [];

 if (Object.isString(filter))
 filter = new RegExp(filter);

 this.each(function(value, index) {
 if (filter.match(value))
 results.push(iterator.call(context, value, index));
 });
 return results;
 },

 include: function(object) {
 if (Object.isFunction(this.indexOf))
 if (this.indexOf(object) != -1) return true;

 var found = false;
 this.each(function(value) {
 if (value == object) {
 found = true;
 throw $break;
 }
 });
 return found;
 },

 inGroupsOf: function(number, fillWith) {
 fillWith = Object.isUndefined(fillWith) ? null : fillWith;
 return this.eachSlice(number, function(slice) {
 while(slice.length < number) slice.push(fillWith);
 return slice;
 });
 },

 inject: function(memo, iterator, context) {
 this.each(function(value, index) {
 memo = iterator.call(context, memo, value, index);
 });
 return memo;
 },

 invoke: function(method) {
 var args = $A(arguments).slice(1);
 return this.map(function(value) {
 return value[method].apply(value, args);
 });
 },

 max: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result;
 this.each(function(value, index) {
 value = iterator.call(context, value, index);
 if (result == null || value >= result)
 result = value;
 });
 return result;
 },

 min: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var result;
 this.each(function(value, index) {
 value = iterator.call(context, value, index);
 if (result == null || value < result)
 result = value;
 });
 return result;
 },

 partition: function(iterator, context) {
 iterator = iterator || Prototype.K;
 var trues = [], falses = [];
 this.each(function(value, index) {
 (iterator.call(context, value, index) ?
 trues : falses).push(value);
 });
 return [trues, falses];
 },

 pluck: function(property) {
 var results = [];
 this.each(function(value) {
 results.push(value[property]);
 });
 return results;
 },

 reject: function(iterator, context) {
 var results = [];
 this.each(function(value, index) {
 if (!iterator.call(context, value, index))
 results.push(value);
 });
 return results;
 },

 sortBy: function(iterator, context) {
 return this.map(function(value, index) {
 return {
 value: value,
 criteria: iterator.call(context, value, index)
 };
 }).sort(function(left, right) {
 var a = left.criteria, b = right.criteria;
 return a < b ? -1 : a > b ? 1 : 0;
 }).pluck('value');
 },

 toArray: function() {
 return this.map();
 },

 zip: function() {
 var iterator = Prototype.K, args = $A(arguments);
 if (Object.isFunction(args.last()))
 iterator = args.pop();

 var collections = [this].concat(args).map($A);
 return this.map(function(value, index) {
 return iterator(collections.pluck(index));
 });
 },

 size: function() {
 return this.toArray().length;
 },

 inspect: function() {
 return '#<Enumerable:' + this.toArray().inspect() + '>';
 }
};

Object.extend(Enumerable, {
 map: Enumerable.collect,
 find: Enumerable.detect,
 select: Enumerable.findAll,
 filter: Enumerable.findAll,
 member: Enumerable.include,
 entries: Enumerable.toArray,
 every: Enumerable.all,
 some: Enumerable.any
});
function $A(iterable) {
 if (!iterable) return [];
 if (iterable.toArray) return iterable.toArray();
 var length = iterable.length || 0, results = new Array(length);
 while (length--) results[length] = iterable[length];
 return results;
}

if (Prototype.Browser.WebKit) {
 $A = function(iterable) {
 if (!iterable) return [];
 // In Safari, only use the `toArray` method if it's not a NodeList.
 // A NodeList is a function, has an function `item` property, and a numeric
 // `length` property. Adapted from Google Doctype.
 if (!(typeof iterable === 'function' && typeof iterable.length ===
 'number' && typeof iterable.item === 'function') && iterable.toArray)
 return iterable.toArray();
 var length = iterable.length || 0, results = new Array(length);
 while (length--) results[length] = iterable[length];
 return results;
 };
}

Array.from = $A;

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse) Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
 _each: function(iterator) {
 for (var i = 0, length = this.length; i < length; i++)
 iterator(this[i]);
 },

 clear: function() {
 this.length = 0;
 return this;
 },

 first: function() {
 return this[0];
 },

 last: function() {
 return this[this.length - 1];
 },

 compact: function() {
 return this.select(function(value) {
 return value != null;
 });
 },

 flatten: function() {
 return this.inject([], function(array, value) {
 return array.concat(Object.isArray(value) ?
 value.flatten() : [value]);
 });
 },

 without: function() {
 var values = $A(arguments);
 return this.select(function(value) {
 return !values.include(value);
 });
 },

 reverse: function(inline) {
 return (inline !== false ? this : this.toArray())._reverse();
 },

 reduce: function() {
 return this.length > 1 ? this : this[0];
 },

 uniq: function(sorted) {
 return this.inject([], function(array, value, index) {
 if (0 == index || (sorted ? array.last() != value : !array.include(value)))
 array.push(value);
 return array;
 });
 },

 intersect: function(array) {
 return this.uniq().findAll(function(item) {
 return array.detect(function(value) { return item === value });
 });
 },

 clone: function() {
 return [].concat(this);
 },

 size: function() {
 return this.length;
 },

 inspect: function() {
 return '[' + this.map(Object.inspect).join(', ') + ']';
 },

 toJSON: function() {
 var results = [];
 this.each(function(object) {
 var value = Object.toJSON(object);
 if (!Object.isUndefined(value)) results.push(value);
 });
 return '[' + results.join(', ') + ']';
 }
});

// use native browser JS 1.6 implementation if available
if (Object.isFunction(Array.prototype.forEach))
 Array.prototype._each = Array.prototype.forEach;

if (!Array.prototype.indexOf) Array.prototype.indexOf = function(item, i) {
 i || (i = 0);
 var length = this.length;
 if (i < 0) i = length + i;
 for (; i < length; i++)
 if (this[i] === item) return i;
 return -1;
};

if (!Array.prototype.lastIndexOf) Array.prototype.lastIndexOf = function(item, i) {
 i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
 var n = this.slice(0, i).reverse().indexOf(item);
 return (n < 0) ? n : i - n - 1;
};

Array.prototype.toArray = Array.prototype.clone;

function $w(string) {
 if (!Object.isString(string)) return [];
 string = string.strip();
 return string ? string.split(/\s+/) : [];
}

if (Prototype.Browser.Opera){
 Array.prototype.concat = function() {
 var array = [];
 for (var i = 0, length = this.length; i < length; i++) array.push(this[i]);
 for (var i = 0, length = arguments.length; i < length; i++) {
 if (Object.isArray(arguments[i])) {
 for (var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++)
 array.push(arguments[i][j]);
 } else {
 array.push(arguments[i]);
 }
 }
 return array;
 };
}
Object.extend(Number.prototype, {
 toColorPart: function() {
 return this.toPaddedString(2, 16);
 },

 succ: function() {
 return this + 1;
 },

 times: function(iterator, context) {
 $R(0, this, true).each(iterator, context);
 return this;
 },

 toPaddedString: function(length, radix) {
 var string = this.toString(radix || 10);
 return '0'.times(length - string.length) + string;
 },

 toJSON: function() {
 return isFinite(this) ? this.toString() : 'null';
 }
});

$w('abs round ceil floor').each(function(method){
 Number.prototype[method] = Math[method].methodize();
});
function $H(object) {
 return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {

 function toQueryPair(key, value) {
 if (Object.isUndefined(value)) return key;
 return key + '=' + encodeURIComponent(String.interpret(value));
 }

 return {
 initialize: function(object) {
 this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
 },

 _each: function(iterator) {
 for (var key in this._object) {
 var value = this._object[key], pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
 }
 },

 set: function(key, value) {
 return this._object[key] = value;
 },

 get: function(key) {
 // simulating poorly supported hasOwnProperty
 if (this._object[key] !== Object.prototype[key])
 return this._object[key];
 },

 unset: function(key) {
 var value = this._object[key];
 delete this._object[key];
 return value;
 },

 toObject: function() {
 return Object.clone(this._object);
 },

 keys: function() {
 return this.pluck('key');
 },

 values: function() {
 return this.pluck('value');
 },

 index: function(value) {
 var match = this.detect(function(pair) {
 return pair.value === value;
 });
 return match && match.key;
 },

 merge: function(object) {
 return this.clone().update(object);
 },

 update: function(object) {
 return new Hash(object).inject(this, function(result, pair) {
 result.set(pair.key, pair.value);
 return result;
 });
 },

 toQueryString: function() {
 return this.inject([], function(results, pair) {
 var key = encodeURIComponent(pair.key), values = pair.value;

 if (values && typeof values == 'object') {
 if (Object.isArray(values))
 return results.concat(values.map(toQueryPair.curry(key)));
 } else results.push(toQueryPair(key, values));
 return results;
 }).join('&');
 },

 inspect: function() {
 return '#<Hash:{' + this.map(function(pair) {
 return pair.map(Object.inspect).join(': ');
 }).join(', ') + '}>';
 },

 toJSON: function() {
 return Object.toJSON(this.toObject());
 },

 clone: function() {
 return new Hash(this);
 }
 }
})());

Hash.prototype.toTemplateReplacements = Hash.prototype.toObject;
Hash.from = $H;
var ObjectRange = Class.create(Enumerable, {
 initialize: function(start, end, exclusive) {
 this.start = start;
 this.end = end;
 this.exclusive = exclusive;
 },

 _each: function(iterator) {
 var value = this.start;
 while (this.include(value)) {
 iterator(value);
 value = value.succ();
 }
 },

 include: function(value) {
 if (value < this.start)
 return false;
 if (this.exclusive)
 return value < this.end;
 return value <= this.end;
 }
});

var $R = function(start, end, exclusive) {
 return new ObjectRange(start, end, exclusive);
};

var Ajax = {
 getTransport: function() {
 return Try.these(
 function() {return new XMLHttpRequest()},
 function() {return new ActiveXObject('Msxml2.XMLHTTP')},
 function() {return new ActiveXObject('Microsoft.XMLHTTP')}
 ) || false;
 },

 activeRequestCount: 0
};

Ajax.Responders = {
 responders: [],

 _each: function(iterator) {
 this.responders._each(iterator);
 },

 register: function(responder) {
 if (!this.include(responder))
 this.responders.push(responder);
 },

 unregister: function(responder) {
 this.responders = this.responders.without(responder);
 },

 dispatch: function(callback, request, transport, json) {
 this.each(function(responder) {
 if (Object.isFunction(responder[callback])) {
 try {
 responder[callback].apply(responder, [request, transport, json]);
 } catch (e) { }
 }
 });
 }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
 onCreate: function() { Ajax.activeRequestCount++ },
 onComplete: function() { Ajax.activeRequestCount-- }
});

Ajax.Base = Class.create({
 initialize: function(options) {
 this.options = {
 method: 'post',
 asynchronous: true,
 contentType: 'application/x-www-form-urlencoded',
 encoding: 'UTF-8',
 parameters: '',
 evalJSON: true,
 evalJS: true
 };
 Object.extend(this.options, options || { });

 this.options.method = this.options.method.toLowerCase();

 if (Object.isString(this.options.parameters))
 this.options.parameters = this.options.parameters.toQueryParams();
 else if (Object.isHash(this.options.parameters))
 this.options.parameters = this.options.parameters.toObject();
 }
});

Ajax.Request = Class.create(Ajax.Base, {
 _complete: false,

 initialize: function($super, url, options) {
 $super(options);
 this.transport = Ajax.getTransport();
 this.request(url);
 },

 request: function(url) {
 this.url = url;
 this.method = this.options.method;
 var params = Object.clone(this.options.parameters);

 if (!['get', 'post'].include(this.method)) {
 // simulate other verbs over post
 params['_method'] = this.method;
 this.method = 'post';
 }

 this.parameters = params;

 if (params = Object.toQueryString(params)) {
 // when GET, append parameters to URL
 if (this.method == 'get')
 this.url += (this.url.include('?') ? '&' : '?') + params;
 else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
 params += '&_=';
 }

 try {
 var response = new Ajax.Response(this);
 if (this.options.onCreate) this.options.onCreate(response);
 Ajax.Responders.dispatch('onCreate', this, response);

 this.transport.open(this.method.toUpperCase(), this.url,
 this.options.asynchronous);

 if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);

 this.transport.onreadystatechange = this.onStateChange.bind(this);
 this.setRequestHeaders();

 this.body = this.method == 'post' ? (this.options.postBody || params) : null;
 this.transport.send(this.body);

 /* Force Firefox to handle ready state 4 for synchronous requests */
 if (!this.options.asynchronous && this.transport.overrideMimeType)
 this.onStateChange();

 }
 catch (e) {
 this.dispatchException(e);
 }
 },

 onStateChange: function() {
 var readyState = this.transport.readyState;
 if (readyState > 1 && !((readyState == 4) && this._complete))
 this.respondToReadyState(this.transport.readyState);
 },

 setRequestHeaders: function() {
 var headers = {
 'X-Requested-With': 'XMLHttpRequest',
 'X-Prototype-Version': Prototype.Version,
 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
 };

 if (this.method == 'post') {
 headers['Content-type'] = this.options.contentType +
 (this.options.encoding ? '; charset=' + this.options.encoding : '');

 /* Force "Connection: close" for older Mozilla browsers to work
 * around a bug where XMLHttpRequest sends an incorrect
 * Content-length header. See Mozilla Bugzilla #246651.
 */
 if (this.transport.overrideMimeType &&
 (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
 headers['Connection'] = 'close';
 }

 // user-defined headers
 if (typeof this.options.requestHeaders == 'object') {
 var extras = this.options.requestHeaders;

 if (Object.isFunction(extras.push))
 for (var i = 0, length = extras.length; i < length; i += 2)
 headers[extras[i]] = extras[i+1];
 else
 $H(extras).each(function(pair) { headers[pair.key] = pair.value });
 }

 for (var name in headers)
 this.transport.setRequestHeader(name, headers[name]);
 },

 success: function() {
 var status = this.getStatus();
 return !status || (status >= 200 && status < 300);
 },

 getStatus: function() {
 try {
 return this.transport.status || 0;
 } catch (e) { return 0 }
 },

 respondToReadyState: function(readyState) {
 var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);

 if (state == 'Complete') {
 try {
 this._complete = true;
 (this.options['on' + response.status]
 || this.options['on' + (this.success() ? 'Success' : 'Failure')]
 || Prototype.emptyFunction)(response, response.headerJSON);
 } catch (e) {
 this.dispatchException(e);
 }

 var contentType = response.getHeader('Content-type');
 if (this.options.evalJS == 'force'
 || (this.options.evalJS && this.isSameOrigin() && contentType
 && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
 this.evalResponse();
 }

 try {
 (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
 Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
 } catch (e) {
 this.dispatchException(e);
 }

 if (state == 'Complete') {
 // avoid memory leak in MSIE: clean up
 this.transport.onreadystatechange = Prototype.emptyFunction;
 }
 },

 isSameOrigin: function() {
 var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
 return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
 protocol: location.protocol,
 domain: document.domain,
 port: location.port ? ':' + location.port : ''
 }));
 },

 getHeader: function(name) {
 try {
 return this.transport.getResponseHeader(name) || null;
 } catch (e) { return null }
 },

 evalResponse: function() {
 try {
 return eval((this.transport.responseText || '').unfilterJSON());
 } catch (e) {
 this.dispatchException(e);
 }
 },

 dispatchException: function(exception) {
 (this.options.onException || Prototype.emptyFunction)(this, exception);
 Ajax.Responders.dispatch('onException', this, exception);
 }
});

Ajax.Request.Events =
 ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Response = Class.create({
 initialize: function(request){
 this.request = request;
 var transport = this.transport = request.transport,
 readyState = this.readyState = transport.readyState;

 if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
 this.status = this.getStatus();
 this.statusText = this.getStatusText();
 this.responseText = String.interpret(transport.responseText);
 this.headerJSON = this._getHeaderJSON();
 }

 if(readyState == 4) {
 var xml = transport.responseXML;
 this.responseXML = Object.isUndefined(xml) ? null : xml;
 this.responseJSON = this._getResponseJSON();
 }
 },

 status: 0,
 statusText: '',

 getStatus: Ajax.Request.prototype.getStatus,

 getStatusText: function() {
 try {
 return this.transport.statusText || '';
 } catch (e) { return '' }
 },

 getHeader: Ajax.Request.prototype.getHeader,

 getAllHeaders: function() {
 try {
 return this.getAllResponseHeaders();
 } catch (e) { return null }
 },

 getResponseHeader: function(name) {
 return this.transport.getResponseHeader(name);
 },

 getAllResponseHeaders: function() {
 return this.transport.getAllResponseHeaders();
 },

 _getHeaderJSON: function() {
 var json = this.getHeader('X-JSON');
 if (!json) return null;
 json = decodeURIComponent(escape(json));
 try {
 return json.evalJSON(this.request.options.sanitizeJSON ||
 !this.request.isSameOrigin());
 } catch (e) {
 this.request.dispatchException(e);
 }
 },

 _getResponseJSON: function() {
 var options = this.request.options;
 if (!options.evalJSON || (options.evalJSON != 'force' &&
 !(this.getHeader('Content-type') || '').include('application/json')) ||
 this.responseText.blank())
 return null;
 try {
 return this.responseText.evalJSON(options.sanitizeJSON ||
 !this.request.isSameOrigin());
 } catch (e) {
 this.request.dispatchException(e);
 }
 }
});

Ajax.Updater = Class.create(Ajax.Request, {
 initialize: function($super, container, url, options) {
 this.container = {
 success: (container.success || container),
 failure: (container.failure || (container.success ? null : container))
 };

 options = Object.clone(options);
 var onComplete = options.onComplete;
 options.onComplete = (function(response, json) {
 this.updateContent(response.responseText);
 if (Object.isFunction(onComplete)) onComplete(response, json);
 }).bind(this);

 $super(url, options);
 },

 updateContent: function(responseText) {
 var receiver = this.container[this.success() ? 'success' : 'failure'],
 options = this.options;

 if (!options.evalScripts) responseText = responseText.stripScripts();

 if (receiver = $(receiver)) {
 if (options.insertion) {
 if (Object.isString(options.insertion)) {
 var insertion = { }; insertion[options.insertion] = responseText;
 receiver.insert(insertion);
 }
 else options.insertion(receiver, responseText);
 }
 else receiver.update(responseText);
 }
 }
});

Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
 initialize: function($super, container, url, options) {
 $super(options);
 this.onComplete = this.options.onComplete;

 this.frequency = (this.options.frequency || 2);
 this.decay = (this.options.decay || 1);

 this.updater = { };
 this.container = container;
 this.url = url;

 this.start();
 },

 start: function() {
 this.options.onComplete = this.updateComplete.bind(this);
 this.onTimerEvent();
 },

 stop: function() {
 this.updater.options.onComplete = undefined;
 clearTimeout(this.timer);
 (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
 },

 updateComplete: function(response) {
 if (this.options.decay) {
 this.decay = (response.responseText == this.lastText ?
 this.decay * this.options.decay : 1);

 this.lastText = response.responseText;
 }
 this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
 },

 onTimerEvent: function() {
 this.updater = new Ajax.Updater(this.container, this.url, this.options);
 }
});
function $(element) {
 if (arguments.length > 1) {
 for (var i = 0, elements = [], length = arguments.length; i < length; i++)
 elements.push($(arguments[i]));
 return elements;
 }
 if (Object.isString(element))
 element = document.getElementById(element);
 return Element.extend(element);
}

if (Prototype.BrowserFeatures.XPath) {
 document._getElementsByXPath = function(expression, parentElement) {
 var results = [];
 var query = document.evaluate(expression, $(parentElement) || document,
 null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
 for (var i = 0, length = query.snapshotLength; i < length; i++)
 results.push(Element.extend(query.snapshotItem(i)));
 return results;
 };
}

/*--------------------------------------------------------------------------*/

if (!window.Node) var Node = { };

if (!Node.ELEMENT_NODE) {
 // DOM level 2 ECMAScript Language Binding
 Object.extend(Node, {
 ELEMENT_NODE: 1,
 ATTRIBUTE_NODE: 2,
 TEXT_NODE: 3,
 CDATA_SECTION_NODE: 4,
 ENTITY_REFERENCE_NODE: 5,
 ENTITY_NODE: 6,
 PROCESSING_INSTRUCTION_NODE: 7,
 COMMENT_NODE: 8,
 DOCUMENT_NODE: 9,
 DOCUMENT_TYPE_NODE: 10,
 DOCUMENT_FRAGMENT_NODE: 11,
 NOTATION_NODE: 12
 });
}

(function() {
 var element = this.Element;
 this.Element = function(tagName, attributes) {
 attributes = attributes || { };
 tagName = tagName.toLowerCase();
 var cache = Element.cache;
 if (Prototype.Browser.IE && attributes.name) {
 tagName = '<' + tagName + ' name="' + attributes.name + '">';
 delete attributes.name;
 return Element.writeAttribute(document.createElement(tagName), attributes);
 }
 if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
 return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
 };
 Object.extend(this.Element, element || { });
 if (element) this.Element.prototype = element.prototype;
}).call(window);

Element.cache = { };

Element.Methods = {
 visible: function(element) {
 return $(element).style.display != 'none';
 },

 toggle: function(element) {
 element = $(element);
 Element[Element.visible(element) ? 'hide' : 'show'](element);
 return element;
 },

 hide: function(element) {
 element = $(element);
 element.style.display = 'none';
 return element;
 },

 show: function(element) {
 element = $(element);
 element.style.display = '';
 return element;
 },

 remove: function(element) {
 element = $(element);
 element.parentNode.removeChild(element);
 return element;
 },

 update: function(element, content) {
 element = $(element);
 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) return element.update().insert(content);
 content = Object.toHTML(content);
 element.innerHTML = content.stripScripts();
 content.evalScripts.bind(content).defer();
 return element;
 },

 replace: function(element, content) {
 element = $(element);
 if (content && content.toElement) content = content.toElement();
 else if (!Object.isElement(content)) {
 content = Object.toHTML(content);
 var range = element.ownerDocument.createRange();
 range.selectNode(element);
 content.evalScripts.bind(content).defer();
 content = range.createContextualFragment(content.stripScripts());
 }
 element.parentNode.replaceChild(content, element);
 return element;
 },

 insert: function(element, insertions) {
 element = $(element);

 if (Object.isString(insertions) || Object.isNumber(insertions) ||
 Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
 insertions = {bottom:insertions};

 var content, insert, tagName, childNodes;

 for (var position in insertions) {
 content = insertions[position];
 position = position.toLowerCase();
 insert = Element._insertionTranslations[position];

 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) {
 insert(element, content);
 continue;
 }

 content = Object.toHTML(content);

 tagName = ((position == 'before' || position == 'after')
 ? element.parentNode : element).tagName.toUpperCase();

 childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());

 if (position == 'top' || position == 'after') childNodes.reverse();
 childNodes.each(insert.curry(element));

 content.evalScripts.bind(content).defer();
 }

 return element;
 },

 wrap: function(element, wrapper, attributes) {
 element = $(element);
 if (Object.isElement(wrapper))
 $(wrapper).writeAttribute(attributes || { });
 else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
 else wrapper = new Element('div', wrapper);
 if (element.parentNode)
 element.parentNode.replaceChild(wrapper, element);
 wrapper.appendChild(element);
 return wrapper;
 },

 inspect: function(element) {
 element = $(element);
 var result = '<' + element.tagName.toLowerCase();
 $H({'id': 'id', 'className': 'class'}).each(function(pair) {
 var property = pair.first(), attribute = pair.last();
 var value = (element[property] || '').toString();
 if (value) result += ' ' + attribute + '=' + value.inspect(true);
 });
 return result + '>';
 },

 recursivelyCollect: function(element, property) {
 element = $(element);
 var elements = [];
 while (element = element[property])
 if (element.nodeType == 1)
 elements.push(Element.extend(element));
 return elements;
 },

 ancestors: function(element) {
 return $(element).recursivelyCollect('parentNode');
 },

 descendants: function(element) {
 return $(element).select("*");
 },

 firstDescendant: function(element) {
 element = $(element).firstChild;
 while (element && element.nodeType != 1) element = element.nextSibling;
 return $(element);
 },

 immediateDescendants: function(element) {
 if (!(element = $(element).firstChild)) return [];
 while (element && element.nodeType != 1) element = element.nextSibling;
 if (element) return [element].concat($(element).nextSiblings());
 return [];
 },

 previousSiblings: function(element) {
 return $(element).recursivelyCollect('previousSibling');
 },

 nextSiblings: function(element) {
 return $(element).recursivelyCollect('nextSibling');
 },

 siblings: function(element) {
 element = $(element);
 return element.previousSiblings().reverse().concat(element.nextSiblings());
 },

 match: function(element, selector) {
 if (Object.isString(selector))
 selector = new Selector(selector);
 return selector.match($(element));
 },

 up: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(element.parentNode);
 var ancestors = element.ancestors();
 return Object.isNumber(expression) ? ancestors[expression] :
 Selector.findElement(ancestors, expression, index);
 },

 down: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return element.firstDescendant();
 return Object.isNumber(expression) ? element.descendants()[expression] :
 Element.select(element, expression)[index || 0];
 },

 previous: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
 var previousSiblings = element.previousSiblings();
 return Object.isNumber(expression) ? previousSiblings[expression] :
 Selector.findElement(previousSiblings, expression, index);
 },

 next: function(element, expression, index) {
 element = $(element);
 if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
 var nextSiblings = element.nextSiblings();
 return Object.isNumber(expression) ? nextSiblings[expression] :
 Selector.findElement(nextSiblings, expression, index);
 },

 select: function() {
 var args = $A(arguments), element = $(args.shift());
 return Selector.findChildElements(element, args);
 },

 adjacent: function() {
 var args = $A(arguments), element = $(args.shift());
 return Selector.findChildElements(element.parentNode, args).without(element);
 },

 identify: function(element) {
 element = $(element);
 var id = element.readAttribute('id'), self = arguments.callee;
 if (id) return id;
 do { id = 'anonymous_element_' + self.counter++ } while ($(id));
 element.writeAttribute('id', id);
 return id;
 },

 readAttribute: function(element, name) {
 element = $(element);
 if (Prototype.Browser.IE) {
 var t = Element._attributeTranslations.read;
 if (t.values[name]) return t.values[name](element, name);
 if (t.names[name]) name = t.names[name];
 if (name.include(':')) {
 return (!element.attributes || !element.attributes[name]) ? null :
 element.attributes[name].value;
 }
 }
 return element.getAttribute(name);
 },

 writeAttribute: function(element, name, value) {
 element = $(element);
 var attributes = { }, t = Element._attributeTranslations.write;

 if (typeof name == 'object') attributes = name;
 else attributes[name] = Object.isUndefined(value) ? true : value;

 for (var attr in attributes) {
 name = t.names[attr] || attr;
 value = attributes[attr];
 if (t.values[attr]) name = t.values[attr](element, value);
 if (value === false || value === null)
 element.removeAttribute(name);
 else if (value === true)
 element.setAttribute(name, name);
 else element.setAttribute(name, value);
 }
 return element;
 },

 getHeight: function(element) {
 return $(element).getDimensions().height;
 },

 getWidth: function(element) {
 return $(element).getDimensions().width;
 },

 classNames: function(element) {
 return new Element.ClassNames(element);
 },

 hasClassName: function(element, className) {
 if (!(element = $(element))) return;
 var elementClassName = element.className;
 return (elementClassName.length > 0 && (elementClassName == className ||
 new RegExp("(^|\\s)" + className + "(\\s|$)").test(elementClassName)));
 },

 addClassName: function(element, className) {
 if (!(element = $(element))) return;
 if (!element.hasClassName(className))
 element.className += (element.className ? ' ' : '') + className;
 return element;
 },

 removeClassName: function(element, className) {
 if (!(element = $(element))) return;
 element.className = element.className.replace(
 new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
 return element;
 },

 toggleClassName: function(element, className) {
 if (!(element = $(element))) return;
 return element[element.hasClassName(className) ?
 'removeClassName' : 'addClassName'](className);
 },

 // removes whitespace-only text node children
 cleanWhitespace: function(element) {
 element = $(element);
 var node = element.firstChild;
 while (node) {
 var nextNode = node.nextSibling;
 if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
 element.removeChild(node);
 node = nextNode;
 }
 return element;
 },

 empty: function(element) {
 return $(element).innerHTML.blank();
 },

 descendantOf: function(element, ancestor) {
 element = $(element), ancestor = $(ancestor);

 if (element.compareDocumentPosition)
 return (element.compareDocumentPosition(ancestor) & 8) === 8;

 if (ancestor.contains)
 return ancestor.contains(element) && ancestor !== element;

 while (element = element.parentNode)
 if (element == ancestor) return true;

 return false;
 },

 scrollTo: function(element) {
 element = $(element);
 var pos = element.cumulativeOffset();
 window.scrollTo(pos[0], pos[1]);
 return element;
 },

 getStyle: function(element, style) {
 element = $(element);
 style = style == 'float' ? 'cssFloat' : style.camelize();
 var value = element.style[style];
 if (!value || value == 'auto') {
 var css = document.defaultView.getComputedStyle(element, null);
 value = css ? css[style] : null;
 }
 if (style == 'opacity') return value ? parseFloat(value) : 1.0;
 return value == 'auto' ? null : value;
 },

 getOpacity: function(element) {
 return $(element).getStyle('opacity');
 },

 setStyle: function(element, styles) {
 element = $(element);
 var elementStyle = element.style, match;
 if (Object.isString(styles)) {
 element.style.cssText += ';' + styles;
 return styles.include('opacity') ?
 element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
 }
 for (var property in styles)
 if (property == 'opacity') element.setOpacity(styles[property]);
 else
 elementStyle[(property == 'float' || property == 'cssFloat') ?
 (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
 property] = styles[property];

 return element;
 },

 setOpacity: function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1 || value === '') ? '' :
 (value < 0.00001) ? 0 : value;
 return element;
 },

 getDimensions: function(element) {
 element = $(element);
 var display = element.getStyle('display');
 if (display != 'none' && display != null) // Safari bug
 return {width: element.offsetWidth, height: element.offsetHeight};

 // All *Width and *Height properties give 0 on elements with display none,
 // so enable the element temporarily
 var els = element.style;
 var originalVisibility = els.visibility;
 var originalPosition = els.position;
 var originalDisplay = els.display;
 els.visibility = 'hidden';
 els.position = 'absolute';
 els.display = 'block';
 var originalWidth = element.clientWidth;
 var originalHeight = element.clientHeight;
 els.display = originalDisplay;
 els.position = originalPosition;
 els.visibility = originalVisibility;
 return {width: originalWidth, height: originalHeight};
 },

 makePositioned: function(element) {
 element = $(element);
 var pos = Element.getStyle(element, 'position');
 if (pos == 'static' || !pos) {
 element._madePositioned = true;
 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 (Prototype.Browser.Opera) {
 element.style.top = 0;
 element.style.left = 0;
 }
 }
 return element;
 },

 undoPositioned: function(element) {
 element = $(element);
 if (element._madePositioned) {
 element._madePositioned = undefined;
 element.style.position =
 element.style.top =
 element.style.left =
 element.style.bottom =
 element.style.right = '';
 }
 return element;
 },

 makeClipping: function(element) {
 element = $(element);
 if (element._overflow) return element;
 element._overflow = Element.getStyle(element, 'overflow') || 'auto';
 if (element._overflow !== 'hidden')
 element.style.overflow = 'hidden';
 return element;
 },

 undoClipping: function(element) {
 element = $(element);
 if (!element._overflow) return element;
 element.style.overflow = element._overflow == 'auto' ? '' : element._overflow;
 element._overflow = null;
 return element;
 },

 cumulativeOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
 } while (element);
 return Element._returnOffset(valueL, valueT);
 },

 positionedOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
 if (element) {
 if (element.tagName.toUpperCase() == 'BODY') break;
 var p = Element.getStyle(element, 'position');
 if (p !== 'static') break;
 }
 } while (element);
 return Element._returnOffset(valueL, valueT);
 },

 absolutize: function(element) {
 element = $(element);
 if (element.getStyle('position') == 'absolute') return element;
 // Position.prepare(); // To be done manually by Scripty when it needs it.

 var offsets = element.positionedOffset();
 var top = offsets[1];
 var left = offsets[0];
 var width = element.clientWidth;
 var height = element.clientHeight;

 element._originalLeft = left - parseFloat(element.style.left || 0);
 element._originalTop = top - parseFloat(element.style.top || 0);
 element._originalWidth = element.style.width;
 element._originalHeight = element.style.height;

 element.style.position = 'absolute';
 element.style.top = top + 'px';
 element.style.left = left + 'px';
 element.style.width = width + 'px';
 element.style.height = height + 'px';
 return element;
 },

 relativize: function(element) {
 element = $(element);
 if (element.getStyle('position') == 'relative') return element;
 // Position.prepare(); // To be done manually by Scripty when it needs it.

 element.style.position = 'relative';
 var top = parseFloat(element.style.top || 0) - (element._originalTop || 0);
 var left = parseFloat(element.style.left || 0) - (element._originalLeft || 0);

 element.style.top = top + 'px';
 element.style.left = left + 'px';
 element.style.height = element._originalHeight;
 element.style.width = element._originalWidth;
 return element;
 },

 cumulativeScrollOffset: function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.scrollTop || 0;
 valueL += element.scrollLeft || 0;
 element = element.parentNode;
 } while (element);
 return Element._returnOffset(valueL, valueT);
 },

 getOffsetParent: function(element) {
 if (element.offsetParent) return $(element.offsetParent);
 if (element == document.body) return $(element);

 while ((element = element.parentNode) && element != document.body)
 if (Element.getStyle(element, 'position') != 'static')
 return $(element);

 return $(document.body);
 },

 viewportOffset: function(forElement) {
 var valueT = 0, valueL = 0;

 var element = forElement;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;

 // Safari fix
 if (element.offsetParent == document.body &&
 Element.getStyle(element, 'position') == 'absolute') break;

 } while (element = element.offsetParent);

 element = forElement;
 do {
 if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
 valueT -= element.scrollTop || 0;
 valueL -= element.scrollLeft || 0;
 }
 } while (element = element.parentNode);

 return Element._returnOffset(valueL, valueT);
 },

 clonePosition: function(element, source) {
 var options = Object.extend({
 setLeft: true,
 setTop: true,
 setWidth: true,
 setHeight: true,
 offsetTop: 0,
 offsetLeft: 0
 }, arguments[2] || { });

 // find page position of source
 source = $(source);
 var p = source.viewportOffset();

 // find coordinate system to use
 element = $(element);
 var delta = [0, 0];
 var parent = null;
 // delta [0,0] will do fine with position: fixed elements,
 // position:absolute needs offsetParent deltas
 if (Element.getStyle(element, 'position') == 'absolute') {
 parent = element.getOffsetParent();
 delta = parent.viewportOffset();
 }

 // correct by body offsets (fixes Safari)
 if (parent == document.body) {
 delta[0] -= document.body.offsetLeft;
 delta[1] -= document.body.offsetTop;
 }

 // set position
 if (options.setLeft) element.style.left = (p[0] - delta[0] + options.offsetLeft) + 'px';
 if (options.setTop) element.style.top = (p[1] - delta[1] + options.offsetTop) + 'px';
 if (options.setWidth) element.style.width = source.offsetWidth + 'px';
 if (options.setHeight) element.style.height = source.offsetHeight + 'px';
 return element;
 }
};

Element.Methods.identify.counter = 1;

Object.extend(Element.Methods, {
 getElementsBySelector: Element.Methods.select,
 childElements: Element.Methods.immediateDescendants
});

Element._attributeTranslations = {
 write: {
 names: {
 className: 'class',
 htmlFor: 'for'
 },
 values: { }
 }
};

if (Prototype.Browser.Opera) {
 Element.Methods.getStyle = Element.Methods.getStyle.wrap(
 function(proceed, element, style) {
 switch (style) {
 case 'left': case 'top': case 'right': case 'bottom':
 if (proceed(element, 'position') === 'static') return null;
 case 'height': case 'width':
 // returns '0px' for hidden elements; we want it to return null
 if (!Element.visible(element)) return null;

 // returns the border-box dimensions rather than the content-box
 // dimensions, so we subtract padding and borders from the value
 var dim = parseInt(proceed(element, style), 10);

 if (dim !== element['offset' + style.capitalize()])
 return dim + 'px';

 var properties;
 if (style === 'height') {
 properties = ['border-top-width', 'padding-top',
 'padding-bottom', 'border-bottom-width'];
 }
 else {
 properties = ['border-left-width', 'padding-left',
 'padding-right', 'border-right-width'];
 }
 return properties.inject(dim, function(memo, property) {
 var val = proceed(element, property);
 return val === null ? memo : memo - parseInt(val, 10);
 }) + 'px';
 default: return proceed(element, style);
 }
 }
 );

 Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
 function(proceed, element, attribute) {
 if (attribute === 'title') return element.title;
 return proceed(element, attribute);
 }
 );
}

else if (Prototype.Browser.IE) {
 // IE doesn't report offsets correctly for static elements, so we change them
 // to "relative" to get the values, then change them back.
 Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
 function(proceed, element) {
 element = $(element);
 // IE throws an error if element is not in document
 try { element.offsetParent }
 catch(e) { return $(document.body) }
 var position = element.getStyle('position');
 if (position !== 'static') return proceed(element);
 element.setStyle({ position: 'relative' });
 var value = proceed(element);
 element.setStyle({ position: position });
 return value;
 }
 );

 $w('positionedOffset viewportOffset').each(function(method) {
 Element.Methods[method] = Element.Methods[method].wrap(
 function(proceed, element) {
 element = $(element);
 try { element.offsetParent }
 catch(e) { return Element._returnOffset(0,0) }
 var position = element.getStyle('position');
 if (position !== 'static') return proceed(element);
 // Trigger hasLayout on the offset parent so that IE6 reports
 // accurate offsetTop and offsetLeft values for position: fixed.
 var offsetParent = element.getOffsetParent();
 if (offsetParent && offsetParent.getStyle('position') === 'fixed')
 offsetParent.setStyle({ zoom: 1 });
 element.setStyle({ position: 'relative' });
 var value = proceed(element);
 element.setStyle({ position: position });
 return value;
 }
 );
 });

 Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
 function(proceed, element) {
 try { element.offsetParent }
 catch(e) { return Element._returnOffset(0,0) }
 return proceed(element);
 }
 );

 Element.Methods.getStyle = function(element, style) {
 element = $(element);
 style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
 var value = element.style[style];
 if (!value && element.currentStyle) value = element.currentStyle[style];

 if (style == 'opacity') {
 if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
 if (value[1]) return parseFloat(value[1]) / 100;
 return 1.0;
 }

 if (value == 'auto') {
 if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
 return element['offset' + style.capitalize()] + 'px';
 return null;
 }
 return value;
 };

 Element.Methods.setOpacity = function(element, value) {
 function stripAlpha(filter){
 return filter.replace(/alpha\([^\)]*\)/gi,'');
 }
 element = $(element);
 var currentStyle = element.currentStyle;
 if ((currentStyle && !currentStyle.hasLayout) ||
 (!currentStyle && element.style.zoom == 'normal'))
 element.style.zoom = 1;

 var filter = element.getStyle('filter'), style = element.style;
 if (value == 1 || value === '') {
 (filter = stripAlpha(filter)) ?
 style.filter = filter : style.removeAttribute('filter');
 return element;
 } else if (value < 0.00001) value = 0;
 style.filter = stripAlpha(filter) +
 'alpha(opacity=' + (value * 100) + ')';
 return element;
 };

 Element._attributeTranslations = {
 read: {
 names: {
 'class': 'className',
 'for': 'htmlFor'
 },
 values: {
 _getAttr: function(element, attribute) {
 return element.getAttribute(attribute, 2);
 },
 _getAttrNode: function(element, attribute) {
 var node = element.getAttributeNode(attribute);
 return node ? node.value : "";
 },
 _getEv: function(element, attribute) {
 attribute = element.getAttribute(attribute);
 return attribute ? attribute.toString().slice(23, -2) : null;
 },
 _flag: function(element, attribute) {
 return $(element).hasAttribute(attribute) ? attribute : null;
 },
 style: function(element) {
 return element.style.cssText.toLowerCase();
 },
 title: function(element) {
 return element.title;
 }
 }
 }
 };

 Element._attributeTranslations.write = {
 names: Object.extend({
 cellpadding: 'cellPadding',
 cellspacing: 'cellSpacing'
 }, Element._attributeTranslations.read.names),
 values: {
 checked: function(element, value) {
 element.checked = !!value;
 },

 style: function(element, value) {
 element.style.cssText = value ? value : '';
 }
 }
 };

 Element._attributeTranslations.has = {};

 $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
 'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
 Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
 Element._attributeTranslations.has[attr.toLowerCase()] = attr;
 });

 (function(v) {
 Object.extend(v, {
 href: v._getAttr,
 src: v._getAttr,
 type: v._getAttr,
 action: v._getAttrNode,
 disabled: v._flag,
 checked: v._flag,
 readonly: v._flag,
 multiple: v._flag,
 onload: v._getEv,
 onunload: v._getEv,
 onclick: v._getEv,
 ondblclick: v._getEv,
 onmousedown: v._getEv,
 onmouseup: v._getEv,
 onmouseover: v._getEv,
 onmousemove: v._getEv,
 onmouseout: v._getEv,
 onfocus: v._getEv,
 onblur: v._getEv,
 onkeypress: v._getEv,
 onkeydown: v._getEv,
 onkeyup: v._getEv,
 onsubmit: v._getEv,
 onreset: v._getEv,
 onselect: v._getEv,
 onchange: v._getEv
 });
 })(Element._attributeTranslations.read.values);
}

else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
 Element.Methods.setOpacity = function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1) ? 0.999999 :
 (value === '') ? '' : (value < 0.00001) ? 0 : value;
 return element;
 };
}

else if (Prototype.Browser.WebKit) {
 Element.Methods.setOpacity = function(element, value) {
 element = $(element);
 element.style.opacity = (value == 1 || value === '') ? '' :
 (value < 0.00001) ? 0 : value;

 if (value == 1)
 if(element.tagName.toUpperCase() == 'IMG' && element.width) {
 element.width++; element.width--;
 } else try {
 var n = document.createTextNode(' ');
 element.appendChild(n);
 element.removeChild(n);
 } catch (e) { }

 return element;
 };

 // Safari returns margins on body which is incorrect if the child is absolutely
 // positioned. For performance reasons, redefine Element#cumulativeOffset for
 // KHTML/WebKit only.
 Element.Methods.cumulativeOffset = function(element) {
 var valueT = 0, valueL = 0;
 do {
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 if (element.offsetParent == document.body)
 if (Element.getStyle(element, 'position') == 'absolute') break;

 element = element.offsetParent;
 } while (element);

 return Element._returnOffset(valueL, valueT);
 };
}

if (Prototype.Browser.IE || Prototype.Browser.Opera) {
 // IE and Opera are missing .innerHTML support for TABLE-related and SELECT elements
 Element.Methods.update = function(element, content) {
 element = $(element);

 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) return element.update().insert(content);

 content = Object.toHTML(content);
 var tagName = element.tagName.toUpperCase();

 if (tagName in Element._insertionTranslations.tags) {
 $A(element.childNodes).each(function(node) { element.removeChild(node) });
 Element._getContentFromAnonymousElement(tagName, content.stripScripts())
 .each(function(node) { element.appendChild(node) });
 }
 else element.innerHTML = content.stripScripts();

 content.evalScripts.bind(content).defer();
 return element;
 };
}

if ('outerHTML' in document.createElement('div')) {
 Element.Methods.replace = function(element, content) {
 element = $(element);

 if (content && content.toElement) content = content.toElement();
 if (Object.isElement(content)) {
 element.parentNode.replaceChild(content, element);
 return element;
 }

 content = Object.toHTML(content);
 var parent = element.parentNode, tagName = parent.tagName.toUpperCase();

 if (Element._insertionTranslations.tags[tagName]) {
 var nextSibling = element.next();
 var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
 parent.removeChild(element);
 if (nextSibling)
 fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
 else
 fragments.each(function(node) { parent.appendChild(node) });
 }
 else element.outerHTML = content.stripScripts();

 content.evalScripts.bind(content).defer();
 return element;
 };
}

Element._returnOffset = function(l, t) {
 var result = [l, t];
 result.left = l;
 result.top = t;
 return result;
};

Element._getContentFromAnonymousElement = function(tagName, html) {
 var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
 if (t) {
 div.innerHTML = t[0] + html + t[1];
 t[2].times(function() { div = div.firstChild });
 } else div.innerHTML = html;
 return $A(div.childNodes);
};

Element._insertionTranslations = {
 before: function(element, node) {
 element.parentNode.insertBefore(node, element);
 },
 top: function(element, node) {
 element.insertBefore(node, element.firstChild);
 },
 bottom: function(element, node) {
 element.appendChild(node);
 },
 after: function(element, node) {
 element.parentNode.insertBefore(node, element.nextSibling);
 },
 tags: {
 TABLE: ['<table>', '</table>', 1],
 TBODY: ['<table><tbody>', '</tbody></table>', 2],
 TR: ['<table><tbody><tr>', '</tr></tbody></table>', 3],
 TD: ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
 SELECT: ['<select>', '</select>', 1]
 }
};

(function() {
 Object.extend(this.tags, {
 THEAD: this.tags.TBODY,
 TFOOT: this.tags.TBODY,
 TH: this.tags.TD
 });
}).call(Element._insertionTranslations);

Element.Methods.Simulated = {
 hasAttribute: function(element, attribute) {
 attribute = Element._attributeTranslations.has[attribute] || attribute;
 var node = $(element).getAttributeNode(attribute);
 return !!(node && node.specified);
 }
};

Element.Methods.ByTag = { };

Object.extend(Element, Element.Methods);

if (!Prototype.BrowserFeatures.ElementExtensions &&
 document.createElement('div')['__proto__']) {
 window.HTMLElement = { };
 window.HTMLElement.prototype = document.createElement('div')['__proto__'];
 Prototype.BrowserFeatures.ElementExtensions = true;
}

Element.extend = (function() {
 if (Prototype.BrowserFeatures.SpecificElementExtensions)
 return Prototype.K;

 var Methods = { }, ByTag = Element.Methods.ByTag;

 var extend = Object.extend(function(element) {
 if (!element || element._extendedByPrototype ||
 element.nodeType != 1 || element == window) return element;

 var methods = Object.clone(Methods),
 tagName = element.tagName.toUpperCase(), property, value;

 // extend methods for specific tags
 if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);

 for (property in methods) {
 value = methods[property];
 if (Object.isFunction(value) && !(property in element))
 element[property] = value.methodize();
 }

 element._extendedByPrototype = Prototype.emptyFunction;
 return element;

 }, {
 refresh: function() {
 // extend methods for all tags (Safari doesn't need this)
 if (!Prototype.BrowserFeatures.ElementExtensions) {
 Object.extend(Methods, Element.Methods);
 Object.extend(Methods, Element.Methods.Simulated);
 }
 }
 });

 extend.refresh();
 return extend;
})();

Element.hasAttribute = function(element, attribute) {
 if (element.hasAttribute) return element.hasAttribute(attribute);
 return Element.Methods.Simulated.hasAttribute(element, attribute);
};

Element.addMethods = function(methods) {
 var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;

 if (!methods) {
 Object.extend(Form, Form.Methods);
 Object.extend(Form.Element, Form.Element.Methods);
 Object.extend(Element.Methods.ByTag, {
 "FORM": Object.clone(Form.Methods),
 "INPUT": Object.clone(Form.Element.Methods),
 "SELECT": Object.clone(Form.Element.Methods),
 "TEXTAREA": Object.clone(Form.Element.Methods)
 });
 }

 if (arguments.length == 2) {
 var tagName = methods;
 methods = arguments[1];
 }

 if (!tagName) Object.extend(Element.Methods, methods || { });
 else {
 if (Object.isArray(tagName)) tagName.each(extend);
 else extend(tagName);
 }

 function extend(tagName) {
 tagName = tagName.toUpperCase();
 if (!Element.Methods.ByTag[tagName])
 Element.Methods.ByTag[tagName] = { };
 Object.extend(Element.Methods.ByTag[tagName], methods);
 }

 function copy(methods, destination, onlyIfAbsent) {
 onlyIfAbsent = onlyIfAbsent || false;
 for (var property in methods) {
 var value = methods[property];
 if (!Object.isFunction(value)) continue;
 if (!onlyIfAbsent || !(property in destination))
 destination[property] = value.methodize();
 }
 }

 function findDOMClass(tagName) {
 var klass;
 var trans = {
 "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
 "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
 "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
 "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
 "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
 "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
 "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
 "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
 "FrameSet", "IFRAME": "IFrame"
 };
 if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
 if (window[klass]) return window[klass];
 klass = 'HTML' + tagName + 'Element';
 if (window[klass]) return window[klass];
 klass = 'HTML' + tagName.capitalize() + 'Element';
 if (window[klass]) return window[klass];

 window[klass] = { };
 window[klass].prototype = document.createElement(tagName)['__proto__'];
 return window[klass];
 }

 if (F.ElementExtensions) {
 copy(Element.Methods, HTMLElement.prototype);
 copy(Element.Methods.Simulated, HTMLElement.prototype, true);
 }

 if (F.SpecificElementExtensions) {
 for (var tag in Element.Methods.ByTag) {
 var klass = findDOMClass(tag);
 if (Object.isUndefined(klass)) continue;
 copy(T[tag], klass.prototype);
 }
 }

 Object.extend(Element, Element.Methods);
 delete Element.ByTag;

 if (Element.extend.refresh) Element.extend.refresh();
 Element.cache = { };
};

document.viewport = {
 getDimensions: function() {
 var dimensions = { }, B = Prototype.Browser;
 $w('width height').each(function(d) {
 var D = d.capitalize();
 if (B.WebKit && !document.evaluate) {
 // Safari <3.0 needs self.innerWidth/Height
 dimensions[d] = self['inner' + D];
 } else if (B.Opera && parseFloat(window.opera.version()) < 9.5) {
 // Opera <9.5 needs document.body.clientWidth/Height
 dimensions[d] = document.body['client' + D]
 } else {
 dimensions[d] = document.documentElement['client' + D];
 }
 });
 return dimensions;
 },

 getWidth: function() {
 return this.getDimensions().width;
 },

 getHeight: function() {
 return this.getDimensions().height;
 },

 getScrollOffsets: function() {
 return Element._returnOffset(
 window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
 window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
 }
};
/* Portions of the Selector class are derived from Jack Slocum's DomQuery,
 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
 * license. Please see http://www.yui-ext.com/ for more information. */

var Selector = Class.create({
 initialize: function(expression) {
 this.expression = expression.strip();

 if (this.shouldUseSelectorsAPI()) {
 this.mode = 'selectorsAPI';
 } else if (this.shouldUseXPath()) {
 this.mode = 'xpath';
 this.compileXPathMatcher();
 } else {
 this.mode = "normal";
 this.compileMatcher();
 }

 },

 shouldUseXPath: function() {
 if (!Prototype.BrowserFeatures.XPath) return false;

 var e = this.expression;

 // Safari 3 chokes on :*-of-type and :empty
 if (Prototype.Browser.WebKit &&
 (e.include("-of-type") || e.include(":empty")))
 return false;

 // XPath can't do namespaced attributes, nor can it read
 // the "checked" property from DOM nodes
 if ((/(\[[\w-]*?:|:checked)/).test(e))
 return false;

 return true;
 },

 shouldUseSelectorsAPI: function() {
 if (!Prototype.BrowserFeatures.SelectorsAPI) return false;

 if (!Selector._div) Selector._div = new Element('div');

 // Make sure the browser treats the selector as valid. Test on an
 // isolated element to minimize cost of this check.
 try {
 Selector._div.querySelector(this.expression);
 } catch(e) {
 return false;
 }

 return true;
 },

 compileMatcher: function() {
 var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
 c = Selector.criteria, le, p, m;

 if (Selector._cache[e]) {
 this.matcher = Selector._cache[e];
 return;
 }

 this.matcher = ["this.matcher = function(root) {",
 "var r = root, h = Selector.handlers, c = false, n;"];

 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 p = ps[i];
 if (m = e.match(p)) {
 this.matcher.push(Object.isFunction(c[i]) ? c[i](m) :
 new Template(c[i]).evaluate(m));
 e = e.replace(m[0], '');
 break;
 }
 }
 }

 this.matcher.push("return h.unique(n);\n}");
 eval(this.matcher.join('\n'));
 Selector._cache[this.expression] = this.matcher;
 },

 compileXPathMatcher: function() {
 var e = this.expression, ps = Selector.patterns,
 x = Selector.xpath, le, m;

 if (Selector._cache[e]) {
 this.xpath = Selector._cache[e]; return;
 }

 this.matcher = ['.//*'];
 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 if (m = e.match(ps[i])) {
 this.matcher.push(Object.isFunction(x[i]) ? x[i](m) :
 new Template(x[i]).evaluate(m));
 e = e.replace(m[0], '');
 break;
 }
 }
 }

 this.xpath = this.matcher.join('');
 Selector._cache[this.expression] = this.xpath;
 },

 findElements: function(root) {
 root = root || document;
 var e = this.expression, results;

 switch (this.mode) {
 case 'selectorsAPI':
 // querySelectorAll queries document-wide, then filters to descendants
 // of the context element. That's not what we want.
 // Add an explicit context to the selector if necessary.
 if (root !== document) {
 var oldId = root.id, id = $(root).identify();
 e = "#" + id + " " + e;
 }

 results = $A(root.querySelectorAll(e)).map(Element.extend);
 root.id = oldId;

 return results;
 case 'xpath':
 return document._getElementsByXPath(this.xpath, root);
 default:
 return this.matcher(root);
 }
 },

 match: function(element) {
 this.tokens = [];

 var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
 var le, p, m;

 while (e && le !== e && (/\S/).test(e)) {
 le = e;
 for (var i in ps) {
 p = ps[i];
 if (m = e.match(p)) {
 // use the Selector.assertions methods unless the selector
 // is too complex.
 if (as[i]) {
 this.tokens.push([i, Object.clone(m)]);
 e = e.replace(m[0], '');
 } else {
 // reluctantly do a document-wide search
 // and look for a match in the array
 return this.findElements(document).include(element);
 }
 }
 }
 }

 var match = true, name, matches;
 for (var i = 0, token; token = this.tokens[i]; i++) {
 name = token[0], matches = token[1];
 if (!Selector.assertions[name](element, matches)) {
 match = false; break;
 }
 }

 return match;
 },

 toString: function() {
 return this.expression;
 },

 inspect: function() {
 return "#<Selector:" + this.expression.inspect() + ">";
 }
});

Object.extend(Selector, {
 _cache: { },

 xpath: {
 descendant: "//*",
 child: "/*",
 adjacent: "/following-sibling::*[1]",
 laterSibling: '/following-sibling::*',
 tagName: function(m) {
 if (m[1] == '*') return '';
 return "[local-name()='" + m[1].toLowerCase() +
 "' or local-name()='" + m[1].toUpperCase() + "']";
 },
 className: "[contains(concat(' ', @class, ' '), ' #{1} ')]",
 id: "[@id='#{1}']",
 attrPresence: function(m) {
 m[1] = m[1].toLowerCase();
 return new Template("[@#{1}]").evaluate(m);
 },
 attr: function(m) {
 m[1] = m[1].toLowerCase();
 m[3] = m[5] || m[6];
 return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
 },
 pseudo: function(m) {
 var h = Selector.xpath.pseudos[m[1]];
 if (!h) return '';
 if (Object.isFunction(h)) return h(m);
 return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
 },
 operators: {
 '=': "[@#{1}='#{3}']",
 '!=': "[@#{1}!='#{3}']",
 '^=': "[starts-with(@#{1}, '#{3}')]",
 '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
 '*=': "[contains(@#{1}, '#{3}')]",
 '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
 '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
 },
 pseudos: {
 'first-child': '[not(preceding-sibling::*)]',
 'last-child': '[not(following-sibling::*)]',
 'only-child': '[not(preceding-sibling::* or following-sibling::*)]',
 'empty': "[count(*) = 0 and (count(text()) = 0)]",
 'checked': "[@checked]",
 'disabled': "[(@disabled) and (@type!='hidden')]",
 'enabled': "[not(@disabled) and (@type!='hidden')]",
 'not': function(m) {
 var e = m[6], p = Selector.patterns,
 x = Selector.xpath, le, v;

 var exclusion = [];
 while (e && le != e && (/\S/).test(e)) {
 le = e;
 for (var i in p) {
 if (m = e.match(p[i])) {
 v = Object.isFunction(x[i]) ? x[i](m) : new Template(x[i]).evaluate(m);
 exclusion.push("(" + v.substring(1, v.length - 1) + ")");
 e = e.replace(m[0], '');
 break;
 }
 }
 }
 return "[not(" + exclusion.join(" and ") + ")]";
 },
 'nth-child': function(m) {
 return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
 },
 'nth-last-child': function(m) {
 return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
 },
 'nth-of-type': function(m) {
 return Selector.xpath.pseudos.nth("position() ", m);
 },
 'nth-last-of-type': function(m) {
 return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
 },
 'first-of-type': function(m) {
 m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
 },
 'last-of-type': function(m) {
 m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
 },
 'only-of-type': function(m) {
 var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
 },
 nth: function(fragment, m) {
 var mm, formula = m[6], predicate;
 if (formula == 'even') formula = '2n+0';
 if (formula == 'odd') formula = '2n+1';
 if (mm = formula.match(/^(\d+)$/)) // digit only
 return '[' + fragment + "= " + mm[1] + ']';
 if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
 if (mm[1] == "-") mm[1] = -1;
 var a = mm[1] ? Number(mm[1]) : 1;
 var b = mm[2] ? Number(mm[2]) : 0;
 predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
 "((#{fragment} - #{b}) div #{a} >= 0)]";
 return new Template(predicate).evaluate({
 fragment: fragment, a: a, b: b });
 }
 }
 }
 },

 criteria: {
 tagName: 'n = h.tagName(n, r, "#{1}", c); c = false;',
 className: 'n = h.className(n, r, "#{1}", c); c = false;',
 id: 'n = h.id(n, r, "#{1}", c); c = false;',
 attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
 attr: function(m) {
 m[3] = (m[5] || m[6]);
 return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
 },
 pseudo: function(m) {
 if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
 return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
 },
 descendant: 'c = "descendant";',
 child: 'c = "child";',
 adjacent: 'c = "adjacent";',
 laterSibling: 'c = "laterSibling";'
 },

 patterns: {
 // combinators must be listed first
 // (and descendant needs to be last combinator)
 laterSibling: /^\s*~\s*/,
 child: /^\s*>\s*/,
 adjacent: /^\s*\+\s*/,
 descendant: /^\s/,

 // selectors follow
 tagName: /^\s*(\*|[\w\-]+)(\b|$)?/,
 id: /^#([\w\-\*]+)(\b|$)/,
 className: /^\.([\w\-\*]+)(\b|$)/,
 pseudo:
/^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/,
 attrPresence: /^\[((?:[\w]+:)?[\w]+)\]/,
 attr: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/
 },

 // for Selector.match and Element#match
 assertions: {
 tagName: function(element, matches) {
 return matches[1].toUpperCase() == element.tagName.toUpperCase();
 },

 className: function(element, matches) {
 return Element.hasClassName(element, matches[1]);
 },

 id: function(element, matches) {
 return element.id === matches[1];
 },

 attrPresence: function(element, matches) {
 return Element.hasAttribute(element, matches[1]);
 },

 attr: function(element, matches) {
 var nodeValue = Element.readAttribute(element, matches[1]);
 return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
 }
 },

 handlers: {
 // UTILITY FUNCTIONS
 // joins two collections
 concat: function(a, b) {
 for (var i = 0, node; node = b[i]; i++)
 a.push(node);
 return a;
 },

 // marks an array of nodes for counting
 mark: function(nodes) {
 var _true = Prototype.emptyFunction;
 for (var i = 0, node; node = nodes[i]; i++)
 node._countedByPrototype = _true;
 return nodes;
 },

 unmark: function(nodes) {
 for (var i = 0, node; node = nodes[i]; i++)
 node._countedByPrototype = undefined;
 return nodes;
 },

 // mark each child node with its position (for nth calls)
 // "ofType" flag indicates whether we're indexing for nth-of-type
 // rather than nth-child
 index: function(parentNode, reverse, ofType) {
 parentNode._countedByPrototype = Prototype.emptyFunction;
 if (reverse) {
 for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
 var node = nodes[i];
 if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
 }
 } else {
 for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
 if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
 }
 },

 // filters out duplicates and extends all nodes
 unique: function(nodes) {
 if (nodes.length == 0) return nodes;
 var results = [], n;
 for (var i = 0, l = nodes.length; i < l; i++)
 if (!(n = nodes[i])._countedByPrototype) {
 n._countedByPrototype = Prototype.emptyFunction;
 results.push(Element.extend(n));
 }
 return Selector.handlers.unmark(results);
 },

 // COMBINATOR FUNCTIONS
 descendant: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 h.concat(results, node.getElementsByTagName('*'));
 return results;
 },

 child: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 for (var j = 0, child; child = node.childNodes[j]; j++)
 if (child.nodeType == 1 && child.tagName != '!') results.push(child);
 }
 return results;
 },

 adjacent: function(nodes) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 var next = this.nextElementSibling(node);
 if (next) results.push(next);
 }
 return results;
 },

 laterSibling: function(nodes) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 h.concat(results, Element.nextSiblings(node));
 return results;
 },

 nextElementSibling: function(node) {
 while (node = node.nextSibling)
 if (node.nodeType == 1) return node;
 return null;
 },

 previousElementSibling: function(node) {
 while (node = node.previousSibling)
 if (node.nodeType == 1) return node;
 return null;
 },

 // TOKEN FUNCTIONS
 tagName: function(nodes, root, tagName, combinator) {
 var uTagName = tagName.toUpperCase();
 var results = [], h = Selector.handlers;
 if (nodes) {
 if (combinator) {
 // fastlane for ordinary descendant combinators
 if (combinator == "descendant") {
 for (var i = 0, node; node = nodes[i]; i++)
 h.concat(results, node.getElementsByTagName(tagName));
 return results;
 } else nodes = this[combinator](nodes);
 if (tagName == "*") return nodes;
 }
 for (var i = 0, node; node = nodes[i]; i++)
 if (node.tagName.toUpperCase() === uTagName) results.push(node);
 return results;
 } else return root.getElementsByTagName(tagName);
 },

 id: function(nodes, root, id, combinator) {
 var targetNode = $(id), h = Selector.handlers;
 if (!targetNode) return [];
 if (!nodes && root == document) return [targetNode];
 if (nodes) {
 if (combinator) {
 if (combinator == 'child') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (targetNode.parentNode == node) return [targetNode];
 } else if (combinator == 'descendant') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (Element.descendantOf(targetNode, node)) return [targetNode];
 } else if (combinator == 'adjacent') {
 for (var i = 0, node; node = nodes[i]; i++)
 if (Selector.handlers.previousElementSibling(targetNode) == node)
 return [targetNode];
 } else nodes = h[combinator](nodes);
 }
 for (var i = 0, node; node = nodes[i]; i++)
 if (node == targetNode) return [targetNode];
 return [];
 }
 return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
 },

 className: function(nodes, root, className, combinator) {
 if (nodes && combinator) nodes = this[combinator](nodes);
 return Selector.handlers.byClassName(nodes, root, className);
 },

 byClassName: function(nodes, root, className) {
 if (!nodes) nodes = Selector.handlers.descendant([root]);
 var needle = ' ' + className + ' ';
 for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
 nodeClassName = node.className;
 if (nodeClassName.length == 0) continue;
 if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
 results.push(node);
 }
 return results;
 },

 attrPresence: function(nodes, root, attr, combinator) {
 if (!nodes) nodes = root.getElementsByTagName("*");
 if (nodes && combinator) nodes = this[combinator](nodes);
 var results = [];
 for (var i = 0, node; node = nodes[i]; i++)
 if (Element.hasAttribute(node, attr)) results.push(node);
 return results;
 },

 attr: function(nodes, root, attr, value, operator, combinator) {
 if (!nodes) nodes = root.getElementsByTagName("*");
 if (nodes && combinator) nodes = this[combinator](nodes);
 var handler = Selector.operators[operator], results = [];
 for (var i = 0, node; node = nodes[i]; i++) {
 var nodeValue = Element.readAttribute(node, attr);
 if (nodeValue === null) continue;
 if (handler(nodeValue, value)) results.push(node);
 }
 return results;
 },

 pseudo: function(nodes, name, value, root, combinator) {
 if (nodes && combinator) nodes = this[combinator](nodes);
 if (!nodes) nodes = root.getElementsByTagName("*");
 return Selector.pseudos[name](nodes, value, root);
 }
 },

 pseudos: {
 'first-child': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 if (Selector.handlers.previousElementSibling(node)) continue;
 results.push(node);
 }
 return results;
 },
 'last-child': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 if (Selector.handlers.nextElementSibling(node)) continue;
 results.push(node);
 }
 return results;
 },
 'only-child': function(nodes, value, root) {
 var h = Selector.handlers;
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
 results.push(node);
 return results;
 },
 'nth-child': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root);
 },
 'nth-last-child': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, true);
 },
 'nth-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, false, true);
 },
 'nth-last-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, formula, root, true, true);
 },
 'first-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, "1", root, false, true);
 },
 'last-of-type': function(nodes, formula, root) {
 return Selector.pseudos.nth(nodes, "1", root, true, true);
 },
 'only-of-type': function(nodes, formula, root) {
 var p = Selector.pseudos;
 return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
 },

 // handles the an+b logic
 getIndices: function(a, b, total) {
 if (a == 0) return b > 0 ? [b] : [];
 return $R(1, total).inject([], function(memo, i) {
 if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
 return memo;
 });
 },

 // handles nth(-last)-child, nth(-last)-of-type, and (first|last)-of-type
 nth: function(nodes, formula, root, reverse, ofType) {
 if (nodes.length == 0) return [];
 if (formula == 'even') formula = '2n+0';
 if (formula == 'odd') formula = '2n+1';
 var h = Selector.handlers, results = [], indexed = [], m;
 h.mark(nodes);
 for (var i = 0, node; node = nodes[i]; i++) {
 if (!node.parentNode._countedByPrototype) {
 h.index(node.parentNode, reverse, ofType);
 indexed.push(node.parentNode);
 }
 }
 if (formula.match(/^\d+$/)) { // just a number
 formula = Number(formula);
 for (var i = 0, node; node = nodes[i]; i++)
 if (node.nodeIndex == formula) results.push(node);
 } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
 if (m[1] == "-") m[1] = -1;
 var a = m[1] ? Number(m[1]) : 1;
 var b = m[2] ? Number(m[2]) : 0;
 var indices = Selector.pseudos.getIndices(a, b, nodes.length);
 for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
 for (var j = 0; j < l; j++)
 if (node.nodeIndex == indices[j]) results.push(node);
 }
 }
 h.unmark(nodes);
 h.unmark(indexed);
 return results;
 },

 'empty': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++) {
 // IE treats comments as element nodes
 if (node.tagName == '!' || node.firstChild) continue;
 results.push(node);
 }
 return results;
 },

 'not': function(nodes, selector, root) {
 var h = Selector.handlers, selectorType, m;
 var exclusions = new Selector(selector).findElements(root);
 h.mark(exclusions);
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!node._countedByPrototype) results.push(node);
 h.unmark(exclusions);
 return results;
 },

 'enabled': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (!node.disabled && (!node.type || node.type !== 'hidden'))
 results.push(node);
 return results;
 },

 'disabled': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (node.disabled) results.push(node);
 return results;
 },

 'checked': function(nodes, value, root) {
 for (var i = 0, results = [], node; node = nodes[i]; i++)
 if (node.checked) results.push(node);
 return results;
 }
 },

 operators: {
 '=': function(nv, v) { return nv == v; },
 '!=': function(nv, v) { return nv != v; },
 '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
 '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
 '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
 '$=': function(nv, v) { return nv.endsWith(v); },
 '*=': function(nv, v) { return nv.include(v); },
 '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
 '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
 '-').include('-' + (v || "").toUpperCase() + '-'); }
 },

 split: function(expression) {
 var expressions = [];
 expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
 expressions.push(m[1].strip());
 });
 return expressions;
 },

 matchElements: function(elements, expression) {
 var matches = $$(expression), h = Selector.handlers;
 h.mark(matches);
 for (var i = 0, results = [], element; element = elements[i]; i++)
 if (element._countedByPrototype) results.push(element);
 h.unmark(matches);
 return results;
 },

 findElement: function(elements, expression, index) {
 if (Object.isNumber(expression)) {
 index = expression; expression = false;
 }
 return Selector.matchElements(elements, expression || '*')[index || 0];
 },

 findChildElements: function(element, expressions) {
 expressions = Selector.split(expressions.join(','));
 var results = [], h = Selector.handlers;
 for (var i = 0, l = expressions.length, selector; i < l; i++) {
 selector = new Selector(expressions[i].strip());
 h.concat(results, selector.findElements(element));
 }
 return (l > 1) ? h.unique(results) : results;
 }
});

if (Prototype.Browser.IE) {
 Object.extend(Selector.handlers, {
 // IE returns comment nodes on getElementsByTagName("*").
 // Filter them out.
 concat: function(a, b) {
 for (var i = 0, node; node = b[i]; i++)
 if (node.tagName !== "!") a.push(node);
 return a;
 },

 // IE improperly serializes _countedByPrototype in (inner|outer)HTML.
 unmark: function(nodes) {
 for (var i = 0, node; node = nodes[i]; i++)
 node.removeAttribute('_countedByPrototype');
 return nodes;
 }
 });
}

function $$() {
 return Selector.findChildElements(document, $A(arguments));
}
var Form = {
 reset: function(form) {
 $(form).reset();
 return form;
 },

 serializeElements: function(elements, options) {
 if (typeof options != 'object') options = { hash: !!options };
 else if (Object.isUndefined(options.hash)) options.hash = true;
 var key, value, submitted = false, submit = options.submit;

 var data = elements.inject({ }, function(result, element) {
 if (!element.disabled && element.name) {
 key = element.name; value = $(element).getValue();
 if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
 submit !== false && (!submit || key == submit) && (submitted = true)))) {
 if (key in result) {
 // a key is already present; construct an array of values
 if (!Object.isArray(result[key])) result[key] = [result[key]];
 result[key].push(value);
 }
 else result[key] = value;
 }
 }
 return result;
 });

 return options.hash ? data : Object.toQueryString(data);
 }
};

Form.Methods = {
 serialize: function(form, options) {
 return Form.serializeElements(Form.getElements(form), options);
 },

 getElements: function(form) {
 return $A($(form).getElementsByTagName('*')).inject([],
 function(elements, child) {
 if (Form.Element.Serializers[child.tagName.toLowerCase()])
 elements.push(Element.extend(child));
 return elements;
 }
 );
 },

 getInputs: function(form, typeName, name) {
 form = $(form);
 var inputs = form.getElementsByTagName('input');

 if (!typeName && !name) return $A(inputs).map(Element.extend);

 for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
 var input = inputs[i];
 if ((typeName && input.type != typeName) || (name && input.name != name))
 continue;
 matchingInputs.push(Element.extend(input));
 }

 return matchingInputs;
 },

 disable: function(form) {
 form = $(form);
 Form.getElements(form).invoke('disable');
 return form;
 },

 enable: function(form) {
 form = $(form);
 Form.getElements(form).invoke('enable');
 return form;
 },

 findFirstElement: function(form) {
 var elements = $(form).getElements().findAll(function(element) {
 return 'hidden' != element.type && !element.disabled;
 });
 var firstByIndex = elements.findAll(function(element) {
 return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
 }).sortBy(function(element) { return element.tabIndex }).first();

 return firstByIndex ? firstByIndex : elements.find(function(element) {
 return ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
 });
 },

 focusFirstElement: function(form) {
 form = $(form);
 form.findFirstElement().activate();
 return form;
 },

 request: function(form, options) {
 form = $(form), options = Object.clone(options || { });

 var params = options.parameters, action = form.readAttribute('action') || '';
 if (action.blank()) action = window.location.href;
 options.parameters = form.serialize(true);

 if (params) {
 if (Object.isString(params)) params = params.toQueryParams();
 Object.extend(options.parameters, params);
 }

 if (form.hasAttribute('method') && !options.method)
 options.method = form.method;

 return new Ajax.Request(action, options);
 }
};

/*--------------------------------------------------------------------------*/

Form.Element = {
 focus: function(element) {
 $(element).focus();
 return element;
 },

 select: function(element) {
 $(element).select();
 return element;
 }
};

Form.Element.Methods = {
 serialize: function(element) {
 element = $(element);
 if (!element.disabled && element.name) {
 var value = element.getValue();
 if (value != undefined) {
 var pair = { };
 pair[element.name] = value;
 return Object.toQueryString(pair);
 }
 }
 return '';
 },

 getValue: function(element) {
 element = $(element);
 var method = element.tagName.toLowerCase();
 return Form.Element.Serializers[method](element);
 },

 setValue: function(element, value) {
 element = $(element);
 var method = element.tagName.toLowerCase();
 Form.Element.Serializers[method](element, value);
 return element;
 },

 clear: function(element) {
 $(element).value = '';
 return element;
 },

 present: function(element) {
 return $(element).value != '';
 },

 activate: function(element) {
 element = $(element);
 try {
 element.focus();
 if (element.select && (element.tagName.toLowerCase() != 'input' ||
 !['button', 'reset', 'submit'].include(element.type)))
 element.select();
 } catch (e) { }
 return element;
 },

 disable: function(element) {
 element = $(element);
 element.disabled = true;
 return element;
 },

 enable: function(element) {
 element = $(element);
 element.disabled = false;
 return element;
 }
};

/*--------------------------------------------------------------------------*/

var Field = Form.Element;
var $F = Form.Element.Methods.getValue;

/*--------------------------------------------------------------------------*/

Form.Element.Serializers = {
 input: function(element, value) {
 switch (element.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 return Form.Element.Serializers.inputSelector(element, value);
 default:
 return Form.Element.Serializers.textarea(element, value);
 }
 },

 inputSelector: function(element, value) {
 if (Object.isUndefined(value)) return element.checked ? element.value : null;
 else element.checked = !!value;
 },

 textarea: function(element, value) {
 if (Object.isUndefined(value)) return element.value;
 else element.value = value;
 },

 select: function(element, value) {
 if (Object.isUndefined(value))
 return this[element.type == 'select-one' ?
 'selectOne' : 'selectMany'](element);
 else {
 var opt, currentValue, single = !Object.isArray(value);
 for (var i = 0, length = element.length; i < length; i++) {
 opt = element.options[i];
 currentValue = this.optionValue(opt);
 if (single) {
 if (currentValue == value) {
 opt.selected = true;
 return;
 }
 }
 else opt.selected = value.include(currentValue);
 }
 }
 },

 selectOne: function(element) {
 var index = element.selectedIndex;
 return index >= 0 ? this.optionValue(element.options[index]) : null;
 },

 selectMany: function(element) {
 var values, length = element.length;
 if (!length) return null;

 for (var i = 0, values = []; i < length; i++) {
 var opt = element.options[i];
 if (opt.selected) values.push(this.optionValue(opt));
 }
 return values;
 },

 optionValue: function(opt) {
 // extend element because hasAttribute may not be native
 return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
 }
};

/*--------------------------------------------------------------------------*/

Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
 initialize: function($super, element, frequency, callback) {
 $super(callback, frequency);
 this.element = $(element);
 this.lastValue = this.getValue();
 },

 execute: function() {
 var value = this.getValue();
 if (Object.isString(this.lastValue) && Object.isString(value) ?
 this.lastValue != value : String(this.lastValue) != String(value)) {
 this.callback(this.element, value);
 this.lastValue = value;
 }
 }
});

Form.Element.Observer = Class.create(Abstract.TimedObserver, {
 getValue: function() {
 return Form.Element.getValue(this.element);
 }
});

Form.Observer = Class.create(Abstract.TimedObserver, {
 getValue: function() {
 return Form.serialize(this.element);
 }
});

/*--------------------------------------------------------------------------*/

Abstract.EventObserver = Class.create({
 initialize: function(element, callback) {
 this.element = $(element);
 this.callback = callback;

 this.lastValue = this.getValue();
 if (this.element.tagName.toLowerCase() == 'form')
 this.registerFormCallbacks();
 else
 this.registerCallback(this.element);
 },

 onElementEvent: function() {
 var value = this.getValue();
 if (this.lastValue != value) {
 this.callback(this.element, value);
 this.lastValue = value;
 }
 },

 registerFormCallbacks: function() {
 Form.getElements(this.element).each(this.registerCallback, this);
 },

 registerCallback: function(element) {
 if (element.type) {
 switch (element.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 Event.observe(element, 'click', this.onElementEvent.bind(this));
 break;
 default:
 Event.observe(element, 'change', this.onElementEvent.bind(this));
 break;
 }
 }
 }
});

Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
 getValue: function() {
 return Form.Element.getValue(this.element);
 }
});

Form.EventObserver = Class.create(Abstract.EventObserver, {
 getValue: function() {
 return Form.serialize(this.element);
 }
});
if (!window.Event) var Event = { };

Object.extend(Event, {
 KEY_BACKSPACE: 8,
 KEY_TAB: 9,
 KEY_RETURN: 13,
 KEY_ESC: 27,
 KEY_LEFT: 37,
 KEY_UP: 38,
 KEY_RIGHT: 39,
 KEY_DOWN: 40,
 KEY_DELETE: 46,
 KEY_HOME: 36,
 KEY_END: 35,
 KEY_PAGEUP: 33,
 KEY_PAGEDOWN: 34,
 KEY_INSERT: 45,

 cache: { },

 relatedTarget: function(event) {
 var element;
 switch(event.type) {
 case 'mouseover': element = event.fromElement; break;
 case 'mouseout': element = event.toElement; break;
 default: return null;
 }
 return Element.extend(element);
 }
});

Event.Methods = (function() {
 var isButton;

 if (Prototype.Browser.IE) {
 var buttonMap = { 0: 1, 1: 4, 2: 2 };
 isButton = function(event, code) {
 return event.button == buttonMap[code];
 };

 } else if (Prototype.Browser.WebKit) {
 isButton = function(event, code) {
 switch (code) {
 case 0: return event.which == 1 && !event.metaKey;
 case 1: return event.which == 1 && event.metaKey;
 default: return false;
 }
 };

 } else {
 isButton = function(event, code) {
 return event.which ? (event.which === code + 1) : (event.button === code);
 };
 }

 return {
 isLeftClick: function(event) { return isButton(event, 0) },
 isMiddleClick: function(event) { return isButton(event, 1) },
 isRightClick: function(event) { return isButton(event, 2) },

 element: function(event) {
 event = Event.extend(event);

 var node = event.target,
 type = event.type,
 currentTarget = event.currentTarget;

 if (currentTarget && currentTarget.tagName) {
 // Firefox screws up the "click" event when moving between radio buttons
 // via arrow keys. It also screws up the "load" and "error" events on images,
 // reporting the document as the target instead of the original image.
 if (type === 'load' || type === 'error' ||
 (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
 && currentTarget.type === 'radio'))
 node = currentTarget;
 }
 if (node) {
 if (node.nodeType == Node.TEXT_NODE) node = node.parentNode;
 return Element.extend(node);
 } else return false;
 },

 findElement: function(event, expression) {
 var element = Event.element(event);
 if (!expression) return element;
 var elements = [element].concat(element.ancestors());
 return Selector.findElement(elements, expression, 0);
 },

 pointer: function(event) {
 var docElement = document.documentElement,
 body = document.body || { scrollLeft: 0, scrollTop: 0 };
 return {
 x: event.pageX || (event.clientX +
 (docElement.scrollLeft || body.scrollLeft) -
 (docElement.clientLeft || 0)),
 y: event.pageY || (event.clientY +
 (docElement.scrollTop || body.scrollTop) -
 (docElement.clientTop || 0))
 };
 },

 pointerX: function(event) { return Event.pointer(event).x },
 pointerY: function(event) { return Event.pointer(event).y },

 stop: function(event) {
 Event.extend(event);
 event.preventDefault();
 event.stopPropagation();
 event.stopped = true;
 }
 };
})();

Event.extend = (function() {
 var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
 m[name] = Event.Methods[name].methodize();
 return m;
 });

 if (Prototype.Browser.IE) {
 Object.extend(methods, {
 stopPropagation: function() { this.cancelBubble = true },
 preventDefault: function() { this.returnValue = false },
 inspect: function() { return "[object Event]" }
 });

 return function(event) {
 if (!event) return false;
 if (event._extendedByPrototype) return event;

 event._extendedByPrototype = Prototype.emptyFunction;
 var pointer = Event.pointer(event);
 Object.extend(event, {
 target: event.srcElement,
 relatedTarget: Event.relatedTarget(event),
 pageX: pointer.x,
 pageY: pointer.y
 });
 return Object.extend(event, methods);
 };

 } else {
 Event.prototype = Event.prototype || document.createEvent("HTMLEvents")['__proto__'];
 Object.extend(Event.prototype, methods);
 return Prototype.K;
 }
})();

Object.extend(Event, (function() {
 var cache = Event.cache;

 function getEventID(element) {
 try {
 if (element._prototypeEventID) return element._prototypeEventID[0];
 arguments.callee.id = arguments.callee.id || 1;
 return element._prototypeEventID = [++arguments.callee.id];
 } catch (error) {
 return false;
 }
 }

 function getDOMEventName(eventName) {
 if (eventName && eventName.include(':')) return "dataavailable";
 return eventName;
 }

 function getCacheForID(id) {
 return cache[id] = cache[id] || { };
 }

 function getWrappersForEventName(id, eventName) {
 var c = getCacheForID(id);
 return c[eventName] = c[eventName] || [];
 }

 function createWrapper(element, eventName, handler) {
 var id = getEventID(element);
 var c = getWrappersForEventName(id, eventName);
 if (c.pluck("handler").include(handler)) return false;

 var wrapper = function(event) {
 if (!Event || !Event.extend ||
 (event.eventName && event.eventName != eventName))
 return false;

 Event.extend(event);
 handler.call(element, event);
 };

 wrapper.handler = handler;
 c.push(wrapper);
 return wrapper;
 }

 function findWrapper(id, eventName, handler) {
 var c = getWrappersForEventName(id, eventName);
 return c.find(function(wrapper) { return wrapper.handler == handler });
 }

 function destroyWrapper(id, eventName, handler) {
 var c = getCacheForID(id);
 if (!c[eventName]) return false;
 c[eventName] = c[eventName].without(findWrapper(id, eventName, handler));
 }

 function destroyCache() {
 for (var id in cache)
 for (var eventName in cache[id])
 cache[id][eventName] = null;
 }


 // Internet Explorer needs to remove event handlers on page unload
 // in order to avoid memory leaks.
 if (window.attachEvent) {
 window.attachEvent("onunload", destroyCache);
 }

 // Safari has a dummy event handler on page unload so that it won't
 // use its bfcache. Safari <= 3.1 has an issue with restoring the "document"
 // object when page is returned to via the back button using its bfcache.
 if (Prototype.Browser.WebKit) {
 window.addEventListener('unload', Prototype.emptyFunction, false);
 }

 return {
 observe: function(element, eventName, handler) {
 element = $(element);
 var name = getDOMEventName(eventName);

 var wrapper = createWrapper(element, eventName, handler);
 if (!wrapper) return element;

 if (element.addEventListener) {
 element.addEventListener(name, wrapper, false);
 } else {
 element.attachEvent("on" + name, wrapper);
 }

 return element;
 },

 stopObserving: function(element, eventName, handler) {
 element = $(element);
 var id = getEventID(element), name = getDOMEventName(eventName);

 if (!handler && eventName) {
 getWrappersForEventName(id, eventName).each(function(wrapper) {
 element.stopObserving(eventName, wrapper.handler);
 });
 return element;

 } else if (!eventName) {
 Object.keys(getCacheForID(id)).each(function(eventName) {
 element.stopObserving(eventName);
 });
 return element;
 }

 var wrapper = findWrapper(id, eventName, handler);
 if (!wrapper) return element;

 if (element.removeEventListener) {
 element.removeEventListener(name, wrapper, false);
 } else {
 element.detachEvent("on" + name, wrapper);
 }

 destroyWrapper(id, eventName, handler);

 return element;
 },

 fire: function(element, eventName, memo) {
 element = $(element);
 if (element == document && document.createEvent && !element.dispatchEvent)
 element = document.documentElement;

 var event;
 if (document.createEvent) {
 event = document.createEvent("HTMLEvents");
 event.initEvent("dataavailable", true, true);
 } else {
 event = document.createEventObject();
 event.eventType = "ondataavailable";
 }

 event.eventName = eventName;
 event.memo = memo || { };

 if (document.createEvent) {
 element.dispatchEvent(event);
 } else {
 element.fireEvent(event.eventType, event);
 }

 return Event.extend(event);
 }
 };
})());

Object.extend(Event, Event.Methods);

Element.addMethods({
 fire: Event.fire,
 observe: Event.observe,
 stopObserving: Event.stopObserving
});

Object.extend(document, {
 fire: Element.Methods.fire.methodize(),
 observe: Element.Methods.observe.methodize(),
 stopObserving: Element.Methods.stopObserving.methodize(),
 loaded: false
});

(function() {
 /* Support for the DOMContentLoaded event is based on work by Dan Webb,
 Matthias Miller, Dean Edwards and John Resig. */

 var timer;

 function fireContentLoadedEvent() {
 if (document.loaded) return;
 if (timer) window.clearInterval(timer);
 document.fire("dom:loaded");
 document.loaded = true;
 }

 if (document.addEventListener) {
 if (Prototype.Browser.WebKit) {
 timer = window.setInterval(function() {
 if (/loaded|complete/.test(document.readyState))
 fireContentLoadedEvent();
 }, 0);

 Event.observe(window, "load", fireContentLoadedEvent);

 } else {
 document.addEventListener("DOMContentLoaded",
 fireContentLoadedEvent, false);
 }

 } else {
 document.write("<script id=__onDOMContentLoaded defer src=//:><\/script>");
 $("__onDOMContentLoaded").onreadystatechange = function() {
 if (this.readyState == "complete") {
 this.onreadystatechange = null;
 fireContentLoadedEvent();
 }
 };
 }
})();
/*------------------------------- DEPRECATED -------------------------------*/

Hash.toQueryString = Object.toQueryString;

var Toggle = { display: Element.toggle };

Element.Methods.childOf = Element.Methods.descendantOf;

var Insertion = {
 Before: function(element, content) {
 return Element.insert(element, {before:content});
 },

 Top: function(element, content) {
 return Element.insert(element, {top:content});
 },

 Bottom: function(element, content) {
 return Element.insert(element, {bottom:content});
 },

 After: function(element, content) {
 return Element.insert(element, {after:content});
 }
};

var $continue = new Error('"throw $continue" is deprecated, use "return" instead');

// This should be moved to script.aculo.us; notice the deprecated methods
// further below, that map to the newer Element methods.
var Position = {
 // set to true if needed, warning: firefox performance problems
 // NOT neeeded for page scrolling, only if draggable contained in
 // scrollable elements
 includeScrollOffsets: false,

 // must be called before calling withinIncludingScrolloffset, every time the
 // page is scrolled
 prepare: function() {
 this.deltaX = window.pageXOffset
 || document.documentElement.scrollLeft
 || document.body.scrollLeft
 || 0;
 this.deltaY = window.pageYOffset
 || document.documentElement.scrollTop
 || document.body.scrollTop
 || 0;
 },

 // caches x/y coordinate pair to use with overlap
 within: function(element, x, y) {
 if (this.includeScrollOffsets)
 return this.withinIncludingScrolloffsets(element, x, y);
 this.xcomp = x;
 this.ycomp = y;
 this.offset = Element.cumulativeOffset(element);

 return (y >= this.offset[1] &&
 y < this.offset[1] + element.offsetHeight &&
 x >= this.offset[0] &&
 x < this.offset[0] + element.offsetWidth);
 },

 withinIncludingScrolloffsets: function(element, x, y) {
 var offsetcache = Element.cumulativeScrollOffset(element);

 this.xcomp = x + offsetcache[0] - this.deltaX;
 this.ycomp = y + offsetcache[1] - this.deltaY;
 this.offset = Element.cumulativeOffset(element);

 return (this.ycomp >= this.offset[1] &&
 this.ycomp < this.offset[1] + element.offsetHeight &&
 this.xcomp >= this.offset[0] &&
 this.xcomp < this.offset[0] + element.offsetWidth);
 },

 // within must be called directly before
 overlap: function(mode, element) {
 if (!mode) return 0;
 if (mode == 'vertical')
 return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
 element.offsetHeight;
 if (mode == 'horizontal')
 return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
 element.offsetWidth;
 },

 // Deprecation layer -- use newer Element methods now (1.5.2).

 cumulativeOffset: Element.Methods.cumulativeOffset,

 positionedOffset: Element.Methods.positionedOffset,

 absolutize: function(element) {
 Position.prepare();
 return Element.absolutize(element);
 },

 relativize: function(element) {
 Position.prepare();
 return Element.relativize(element);
 },

 realOffset: Element.Methods.cumulativeScrollOffset,

 offsetParent: Element.Methods.getOffsetParent,

 page: Element.Methods.viewportOffset,

 clone: function(source, target, options) {
 options = options || { };
 return Element.clonePosition(target, source, options);
 }
};

/*--------------------------------------------------------------------------*/

if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
 function iter(name) {
 return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
 }

 instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
 function(element, className) {
 className = className.toString().strip();
 var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
 return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
 } : function(element, className) {
 className = className.toString().strip();
 var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
 if (!classNames && !className) return elements;

 var nodes = $(element).getElementsByTagName('*');
 className = ' ' + className + ' ';

 for (var i = 0, child, cn; child = nodes[i]; i++) {
 if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
 (classNames && classNames.all(function(name) {
 return !name.toString().blank() && cn.include(' ' + name + ' ');
 }))))
 elements.push(Element.extend(child));
 }
 return elements;
 };

 return function(className, parentElement) {
 return $(parentElement || document.body).getElementsByClassName(className);
 };
}(Element.Methods);

/*--------------------------------------------------------------------------*/

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
 initialize: function(element) {
 this.element = $(element);
 },

 _each: function(iterator) {
 this.element.className.split(/\s+/).select(function(name) {
 return name.length > 0;
 })._each(iterator);
 },

 set: function(className) {
 this.element.className = className;
 },

 add: function(classNameToAdd) {
 if (this.include(classNameToAdd)) return;
 this.set($A(this).concat(classNameToAdd).join(' '));
 },

 remove: function(classNameToRemove) {
 if (!this.include(classNameToRemove)) return;
 this.set($A(this).without(classNameToRemove).join(' '));
 },

 toString: function() {
 return $A(this).join(' ');
 }
};

Object.extend(Element.ClassNames.prototype, Enumerable);

/*--------------------------------------------------------------------------*/

Element.addMethods();
/*
Script: Moo.js
 My Object Oriented javascript.

License:
 MIT-style license.

Moo.MooTools Copyright:
 copyright (c) 2007 Valerio Proietti, <http://mad4milk.net>

Moo.MooTools Credits:
 - Moo.Class is slightly based on Base.js <http://dean.edwards.name/weblog/2006/03/base/> (c) 2006 Dean Edwards, License <http://creativecommons.org/licenses/LGPL/2.1/>
 - Some functions are inspired by those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
 - Documentation by Aaron Newton (aaron.newton [at] cnet [dot] com) and Valerio Proietti.
*/

/*
Object: Moo
 The root namespace object for all replaced classes and methods

 Contains:
 MooTools, Class, $type, $merge, $mergeClass, $extend, $native, Abstract,
 Window, Document, $chk, $pick, $random, $time, $clear, Chain, Events,
 Options, $A, $each, Element, Elements, $, $$, Garbage, Event, $E, $ES,
 Filters, Fx, Drag, XHR, Ajax, Cookie, Json, Asset, Hash, $H, Color, $RGB,
 $HSB, Scroller, Slider, SmoothScroll, Sortables, Tips, Group, Accordion
*/

var Moo = {};


Moo.MooTools = {
 version: '1.1dev'
};

/*
Moo.Class: Moo.Class
 The base class object of the <http://mootools.net> framework.
 Creates a new class, its initialize method will fire upon class instantiation.
 Initialize wont fire on instantiation when you pass *null*.

Arguments:
 properties - the collection of properties that apply to the class.

Example:
 (start code)
 var Cat = new Moo.Class({
 initialize: function(name){
 this.name = name;
 }
 });
 var myCat = new Cat('Micia');
 alert(myCat.name); //alerts 'Micia'
 (end)
*/

Moo.Class = function(properties){
 var klass = function(){
 if (arguments[0] !== null && this.initialize && Moo.$type(this.initialize) == 'function') return this.initialize.apply(this, arguments);
 else return this;
 };
 Moo.$extend(klass, this);
 klass.prototype = properties;
 return klass;
};

/*
Property: empty
 Returns an empty function
*/

Moo.Class.empty = function(){};

Moo.Class.prototype = {

 /*
 Property: extend
 Returns the copy of the Moo.Class extended with the passed in properties.

 Arguments:
 properties - the properties to add to the base class in this new Moo.Class.

 Example:
 (start code)
 var Animal = new Moo.Class({
 initialize: function(age){
 this.age = age;
 }
 });
 var Cat = Animal.extend({
 initialize: function(name, age){
 this.parent(age); //will call the previous initialize;
 this.name = name;
 }
 });
 var myCat = new Cat('Micia', 20);
 alert(myCat.name); //alerts 'Micia'
 alert(myCat.age); //alerts 20
 (end)
 */

 extend: function(properties){
 var proto = new this(null);
 for (var property in properties){
 var pp = proto[property];
 proto[property] = Moo.$mergeClass(pp, properties[property]);
 }
 return new Moo.Class(proto);
 },

 /*
 Property: implement
 Implements the passed in properties to the base Moo.Class prototypes, altering the base class, unlike <Moo.Class.extend>.

 Arguments:
 properties - the properties to add to the base class.

 Example:
 (start code)
 var Animal = new Moo.Class({
 initialize: function(age){
 this.age = age;
 }
 });
 Animal.implement({
 setName: function(name){
 this.name = name
 }
 });
 var myAnimal = new Animal(20);
 myAnimal.setName('Micia');
 alert(myAnimal.name); //alerts 'Micia'
 (end)
 */

 implement: function(properties){
 Moo.$extend(this.prototype, properties);
 }

};

/* Section: Utility Functions */

/*
Function: Moo.$type
 Returns the type of object that matches the element passed in.

Arguments:
 obj - the object to inspect.

Example:
 >var myString = 'hello';
 >Moo.$type(myString); //returns "string"

Returns:
 'element' - if obj is a DOM element node
 'textnode' - if obj is a DOM text node
 'whitespace' - if obj is a DOM whitespace node
 'array' - if obj is an array
 'object' - if obj is an object
 'string' - if obj is a string
 'number' - if obj is a number
 'boolean' - if obj is a boolean
 'function' - if obj is a function
 'regexp' - if obj is a regular expression
 false - (boolean) if the object is not defined or none of the above.
*/

Moo.$type = function(obj){
 if (obj == undefined) return false;
 var type = typeof obj;
 if (type == 'object'){
 if (obj.htmlElement) return 'element';
 if (obj.push) return 'array';
 if (obj.nodeName){
 switch(obj.nodeType){
 case 1: return 'element';
 case 3: return obj.nodeValue.test(/\S/) ? 'textnode' : 'whitespace';
 }
 }
 }
 if ((type == 'object' || type == 'function') && obj.exec) return 'regexp';
 return type;
};

/*
Function: Moo.$merge
 merges a number of objects recursively without referencing them or their sub-objects.

Arguments:
 any number of objects.

Example:
 >var mergedObj = Moo.$merge(obj1, obj2, obj3);
 >//obj1, obj2, and obj3 are unaltered
*/

Moo.$merge = function(){
 var mix = {};
 for (var i = 0; i < arguments.length; i++){
 for (var property in arguments[i]){
 var ap = arguments[i][property];
 var mp = mix[property];
 if (mp && Moo.$type(ap) == 'object' && Moo.$type(mp) == 'object') mix[property] = Moo.$merge(mp, ap);
 else mix[property] = ap;
 }
 }
 return mix;
};

//internal

Moo.$mergeClass = function(previous, current){
 if (previous && previous != current){
 var ptype = Moo.$type(previous);
 var ctype = Moo.$type(current);
 if (ptype == 'function' && ctype == 'function'){
 var merged = function(){
 this.parent = arguments.callee.parent;
 return current.apply(this, arguments);
 };
 merged.parent = previous;
 return merged;
 } else if (ptype == 'object' && ctype == 'object'){
 return Moo.$merge(previous, current);
 }
 }
 return current;
};

/*
Function: Moo.$extend
 Copies all the properties from the second passed object to the first passed Object.
 If you do myWhatever.extend = Moo.$extend the first parameter will become myWhatever, and your extend function will only need one parameter.

Example:
 (start code)
 var firstOb = {
 'name': 'John',
 'lastName': 'Doe'
 };
 var secondOb = {
 'age': '20',
 'sex': 'male',
 'lastName': 'Dorian'
 };
 Moo.$extend(firstOb, secondOb);
 //firstOb will become:
 {
 'name': 'John',
 'lastName': 'Dorian',
 'age': '20',
 'sex': 'male'
 };
 (end)

Returns:
 The first object, extended.
*/

Moo.$extend = Object.extend = function(){
 var args = arguments;
 if (!args[1]) args = [this, args[0]];
 for (var property in args[1]) args[0][property] = args[1][property];
 return args[0];
};

/*
Function: Moo.$native
 Will add a .extend method to the objects passed as a parameter, but the property passed in will be copied to the object's prototype only if non previously existent.
 Its handy if you dont want the .extend method of an object to overwrite existing methods.
 Used automatically in mootools to implement Array/String/Function/Number methods to browser that dont support them whitout manual checking.

Arguments:
 a number of classes/native javascript objects

*/

Moo.$native = Object.Native = function(){
 for (var i = 0; i < arguments.length; i++) arguments[i].extend = Moo.$native.extend;
};

Moo.$native.extend = function(props){
 for (var prop in props){
 if (!this.prototype[prop]) this.prototype[prop] = props[prop];
 }
};

Moo.$native(Function, Array, String, Number, Moo.Class);

/*
Script: Utility.js
 Contains Utility functions

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Abstract
 Moo.Abstract class, to be used as singleton. Will add .extend to any object

Arguments:
 an object
 
Returns:
 the object with an .extend property, equivalent to <Moo.$extend>.
*/

Moo.Abstract = function(obj){
 obj = obj || {};
 obj.extend = Moo.$extend;
 return obj;
};

//window, document

Moo.Window = new Moo.Abstract(window);
Moo.Document = new Moo.Abstract(document);
document.head = document.getElementsByTagName('head')[0];

/* Section: Utility Functions */

/*
Function: Moo.$chk
 Returns true if the passed in value/object exists or is 0, otherwise returns false.
 Useful to accept zeroes.

Arguments:
 obj - object to inspect
*/

Moo.$chk = function(obj){
 return !!(obj || obj === 0);
};

/*
Function: Moo.$pick
 Returns the first object if defined, otherwise returns the second.

Arguments:
 obj - object to test
 picked - the default to return

Example:
 (start code)
 function say(msg){
 alert(Moo.$pick(msg, 'no meessage supplied'));
 }
 (end)
*/

Moo.$pick = function(obj, picked){
 return (obj != undefined) ? obj : picked;
};

/*
Function: Moo.$random
 Returns a random integer number between the two passed in values.

Arguments:
 min - integer, the minimum value (inclusive).
 max - integer, the maximum value (inclusive).

Returns:
 a random integer between min and max.
*/

Moo.$random = function(min, max){
 return Math.floor(Math.random() * (max - min + 1) + min);
};

/*
Function: Moo.$time
 Returns the current timestamp

Returns:
 a timestamp integer.
*/

Moo.$time = function(){
 return new Date().getTime();
};

/*
Function: Moo.$clear
 clears a timeout or an Interval.

Returns:
 null

Arguments:
 timer - the setInterval or setTimeout to clear.

Example:
 >var myTimer = myFunction.delay(5000); //wait 5 seconds and execute my function.
 >myTimer = Moo.$clear(myTimer); //nevermind

See also:
 <Function.delay>, <Function.periodical>
*/

Moo.$clear = function(timer){
 clearTimeout(timer);
 clearInterval(timer);
 return null;
};

/*
Moo.Class: window
 Some properties are attached to the window object by the browser detection.

Properties:
 window.ie - will be set to true if the current browser is internet explorer (any).
 window.ie6 - will be set to true if the current browser is internet explorer 6.
 window.ie7 - will be set to true if the current browser is internet explorer 7.
 window.khtml - will be set to true if the current browser is Safari/Konqueror.
 window.gecko - will be set to true if the current browser is Mozilla/Gecko.
*/

if (window.ActiveXObject) window.ie = window[window.XMLHttpRequest ? 'ie7' : 'ie6'] = true;
else if (document.childNodes && !document.all && !navigator.taintEnabled) window.khtml = true;
else if (document.getBoxObjectFor != null) window.gecko = true;
window.xpath = !!(document.evaluate);

//htmlelement

if (typeof HTMLElement == 'undefined'){
 var HTMLElement = Moo.Class.empty;
 if (window.khtml) document.createElement("iframe"); //fixes safari
 HTMLElement.prototype = (window.khtml) ? window["[[DOMElement.prototype]]"] : {};
}
HTMLElement.prototype.htmlElement = true;

//enables background image cache for internet explorer 6

if (window.ie6) try {document.execCommand("BackgroundImageCache", false, true);} catch(e){};

/*
Script: Common.js
 Contains common implementations for custom classes. In Mootools is implemented in <Moo.Ajax>, <Moo.XHR> and <Moo.Fx.Base> and many more.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Chain
 An "Utility" Moo.Class. Its methods can be implemented with <Moo.Class.implement> into any <Moo.Class>.
 Currently implemented in <Moo.Fx.Base>, <Moo.XHR> and <Moo.Ajax>. In <Moo.Fx.Base> for example, is used to execute a list of function, one after another, once the effect is completed.
 The functions will not be fired all togheter, but one every completion, to create custom complex animations.

Example:
 (start code)
 var myFx = new Moo.Fx.Style('element', 'opacity');

 myFx.start(1,0).chain(function(){
 myFx.start(0,1);
 }).chain(function(){
 myFx.start(1,0);
 }).chain(function(){
 myFx.start(0,1);
 });
 //the element will appear and disappear three times
 (end)
*/

Moo.Chain = new Moo.Class({

 /*
 Property: chain
 adds a function to the Moo.Chain instance stack.

 Arguments:
 fn - the function to append.
 */

 chain: function(fn){
 this.chains = this.chains || [];
 this.chains.push(fn);
 return this;
 },

 /*
 Property: callChain
 Executes the first function of the Moo.Chain instance stack, then removes it. The first function will then become the second.
 */

 callChain: function(){
 if (this.chains && this.chains.length) this.chains.shift().delay(10, this);
 },

 /*
 Property: clearChain
 Clears the stack of a Moo.Chain instance.
 */

 clearChain: function(){
 this.chains = [];
 }

});

/*
Moo.Class: Moo.Events
 An "Utility" Moo.Class. Its methods can be implemented with <Moo.Class.implement> into any <Moo.Class>.

 In <Moo.Fx.Base> Moo.Class, for example, is used to give the possibility add any number of functions to the Effects events, like onComplete, onStart, onCancel.

Example:
 (start code)
 var myFx = new Moo.Fx.Style('element', 'opacity').addEvent('onComplete', function(){
 alert('the effect is completed');
 }).addEvent('onComplete', function(){
 alert('I told you the effect is completed');
 });

 myFx.start(0,1);
 //upon completion it will display the 2 alerts, in order.
 (end)

 Implementing:
 This class can be implemented into other classes to add the functionality to them.
 Goes well with the <Moo.Options> class.

 Example:
 (start code)
 var Widget = new Moo.Class({
 initialize: function(){},
 finish: function(){
 this.fireEvent('onComplete');
 }
 });
 Widget.implement(new Moo.Events);
 //later...
 var myWidget = new Widget();
 myWidget.addEvent('onComplete', myfunction);
 (end)
*/

Moo.Events = new Moo.Class({

 /*
 Property: addEvent
 adds an event to the stack of events of the Moo.Class instance.

 Arguments:
 type - string; the event name (e.g. 'onComplete')
 fn - function to execute
 */

 addEvent: function(type, fn){
 if (fn != Moo.Class.empty){
 this.$events = this.$events || {};
 this.$events[type] = this.$events[type] || [];
 this.$events[type].include(fn);
 }
 return this;
 },

 /*
 Property: fireEvent
 fires all events of the specified type in the Moo.Class instance.

 Arguments:
 type - string; the event name (e.g. 'onComplete')
 args - array or single object; arguments to pass to the function; if more than one argument, must be an array
 delay - (integer) delay (in ms) to wait to execute the event

 Example:
 (start code)
 var Widget = new Moo.Class({
 initialize: function(arg1, arg2){
 ...
 this.fireEvent("onInitialize", [arg1, arg2], 50);
 }
 });
 Widget.implement(new Moo.Events);
 (end)
 */

 fireEvent: function(type, args, delay){
 if (this.$events && this.$events[type]){
 this.$events[type].each(function(fn){
 fn.create({'bind': this, 'delay': delay, 'arguments': args})();
 }, this);
 }
 return this;
 },

 /*
 Property: removeEvent
 removes an event from the stack of events of the Moo.Class instance.

 Arguments:
 type - string; the event name (e.g. 'onComplete')
 fn - function that was added
 */

 removeEvent: function(type, fn){
 if (this.$events && this.$events[type]) this.$events[type].remove(fn);
 return this;
 }

});

/*
Moo.Class: Moo.Options
 An "Utility" Moo.Class. Its methods can be implemented with <Moo.Class.implement> into any <Moo.Class>.
 Used to automate the options settings, also adding Moo.Class <Moo.Events> when the option begins with on.

 Example:
 (start code)
 var Widget = new Moo.Class({
 options: {
 color: '#fff',
 size: {
 width: 100
 height: 100
 }
 },
 initialize: function(options){
 this.setOptions(options);
 }
 });
 Widget.implement(new Moo.Options);
 //later...
 var myWidget = new Widget({
 color: '#f00',
 size: {
 width: 200
 }
 });
 //myWidget.options = {color: #f00, size: {width: 200, height: 100}}
 (end)


*/

Moo.Options = new Moo.Class({

 /*
 Property: setOptions
 sets this.options

 Arguments:
 defaults - object; the default set of options
 options - object; the user entered options. can be empty too.

 Note:
 if your Moo.Class has <Moo.Events> implemented, every option beginning with on, followed by a capital letter (onComplete) becomes an Moo.Class instance event.
 */

 setOptions: function(){
 var args = (arguments.length == 1) ? [this.options, arguments[0]] : arguments;
 this.options = Moo.$merge.apply(this, args);
 if (this.addEvent){
 for (var option in this.options){
 if ((Moo.$type(this.options[option]) == 'function') && option.test(/^on[A-Z]/)) this.addEvent(option, this.options[option]);
 }
 }
 return this;
 }

});

/*
Script: Array.js
 Contains Array prototypes, <Moo.$A>, <Moo.$each>

License:
 MIT-style license.
*/

/*
Moo.Class: Array
 A collection of The Array Object prototype methods.
*/

//custom methods

Array.extend({

 /*
 Property: forEach
 Iterates through an array; This method is only available for browsers without native *forEach* support.
 For more info see <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:forEach>

 *forEach* executes the provided function (callback) once for each element present in the array. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.

 Arguments:
 fn - function to execute with each item in the array; passed the item and the index of that item in the array
 bind - the object to bind "this" to (see <Function.bind>)

 Example:
 >['apple','banana','lemon'].each(function(item, index) {
 > alert(index + " = " + item); //alerts "0 = apple" etc.
 >}, bindObj); //optional second arg for binding, not used here
 */

 forEach: function(fn, bind){
 for (var i = 0, j = this.length; i < j; i++) fn.call(bind, this[i], i, this);
 },

 /*
 Property: filter
 This method is provided only for browsers without native *filter* support.
 For more info see <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:Array:filter>

 *filter* calls a provided callback function once for each element in an array, and constructs a new array of all the values for which callback returns a true value. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values. Array elements which do not pass the callback test are simply skipped, and are not included in the new array.

 Arguments:
 fn - function to execute with each item in the array; passed the item and the index of that item in the array
 bind - the object to bind "this" to (see <Function.bind>)

 Example:
 >var biggerThanTwenty = [10,3,25,100].filter(function(item, index) {
 > return item > 20;
 >});
 >//biggerThanTwenty = [25,100]
 */

 filter: function(fn, bind){
 var results = [];
 for (var i = 0, j = this.length; i < j; i++){
 if (fn.call(bind, this[i], i, this)) results.push(this[i]);
 }
 return results;
 },

 /*
 Property: map
 This method is provided only for browsers without native *map* support.
 For more info see <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:map>

 *map* calls a provided callback function once for each element in an array, in order, and constructs a new array from the results. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.

 Arguments:
 fn - function to execute with each item in the array; passed the item and the index of that item in the array
 bind - the object to bind "this" to (see <Function.bind>)

 Example:
 >var timesTwo = [1,2,3].map(function(item, index){
 > return item*2;
 >});
 >//timesTwo = [2,4,6];
 */

 map: function(fn, bind){
 var results = [];
 for (var i = 0, j = this.length; i < j; i++) results[i] = fn.call(bind, this[i], i, this);
 return results;
 },

 /*
 Property: every
 This method is provided only for browsers without native *every* support.
 For more info see <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:every>

 *every* executes the provided callback function once for each element present in the array until it finds one where callback returns a false value. If such an element is found, the every method immediately returns false. Otherwise, if callback returned a true value for all elements, every will return true. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.

 Arguments:
 fn - function to execute with each item in the array; passed the item and the index of that item in the array
 bind - the object to bind "this" to (see <Function.bind>)

 Example:
 >var areAllBigEnough = [10,4,25,100].every(function(item, index){
 > return item > 20;
 >});
 >//areAllBigEnough = false
 */

 every: function(fn, bind){
 for (var i = 0, j = this.length; i < j; i++){
 if (!fn.call(bind, this[i], i, this)) return false;
 }
 return true;
 },

 /*
 Property: some
 This method is provided only for browsers without native *some* support.
 For more info see <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:some>

 *some* executes the callback function once for each element present in the array until it finds one where callback returns a true value. If such an element is found, some immediately returns true. Otherwise, some returns false. callback is invoked only for indexes of the array which have assigned values; it is not invoked for indexes which have been deleted or which have never been assigned values.

 Arguments:
 fn - function to execute with each item in the array; passed the item and the index of that item in the array
 bind - the object to bind "this" to (see <Function.bind>)

 Example:
 >var isAnyBigEnough = [10,4,25,100].some(function(item, index){
 > return item > 20;
 >});
 >//isAnyBigEnough = true
 */

 some: function(fn, bind){
 for (var i = 0, j = this.length; i < j; i++){
 if (fn.call(bind, this[i], i, this)) return true;
 }
 return false;
 },

 /*
 Property: indexOf
 This method is provided only for browsers without native *indexOf* support.
 For more info see <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Objects:Array:indexOf>

 *indexOf* compares a search element to elements of the Array using strict equality (the same method used by the ===, or triple-equals, operator).

 Arguments:
 item - any type of object; element to locate in the array
 from - integer; optional; the index of the array at which to begin the search (defaults to 0)

 Example:
 >['apple','lemon','banana'].indexOf('lemon'); //returns 1
 >['apple','lemon'].indexOf('banana'); //returns -1
 */

 indexOf: function(item, from){
 var len = this.length;
 for (var i = (from < 0) ? Math.max(0, len + from) : from || 0; i < len; i++){
 if (this[i] === item) return i;
 }
 return -1;
 },

 /*
 Property: each
 Same as <Array.forEach>.

 Arguments:
 fn - function to execute with each item in the array; passed the item and the index of that item in the array
 bind - optional, the object that the "this" of the function will refer to.

 Example:
 >var Animals = ['Cat', 'Dog', 'Coala'];
 >Animals.each(function(animal){
 > document.write(animal)
 >});
 */

 /*
 Property: copy
 returns a copy of the array.

 Returns:
 a new array which is a copy of the current one.

 Arguments:
 start - integer; optional; the index where to start the copy, default is 0. If negative, it is taken as the offset from the end of the array.
 length - integer; optional; the number of elements to copy. By default, copies all elements from start to the end of the array.

 Example:
 >var letters = ["a","b","c"];
 >var copy = letters.copy(); // ["a","b","c"] (new instance)
 */

 copy: function(start, length){
 start = start || 0;
 if (start < 0) start = this.length + start;
 length = length || (this.length - start);
 var newArray = [];
 for (var i = 0; i < length; i++) newArray[i] = this[start++];
 return newArray;
 },

 /*
 Property: remove
 Removes all occurrences of an item from the array.

 Arguments:
 item - the item to remove

 Returns:
 the Array with all occurrences of the item removed.

 Example:
 >["1","2","3","2"].remove("2") // ["1","3"];
 */

 remove: function(item){
 var i = 0;
 var len = this.length;
 while (i < len){
 if (this[i] === item){
 this.splice(i, 1);
 len--;
 } else {
 i++;
 }
 }
 return this;
 },

 /*
 Property: contains
 Tests an array for the presence of an item.

 Arguments:
 item - the item to search for in the array.
 from - integer; optional; the index at which to begin the search, default is 0. If negative, it is taken as the offset from the end of the array.

 Returns:
 true - the item was found
 false - it wasn't

 Example:
 >["a","b","c"].contains("a"); // true
 >["a","b","c"].contains("d"); // false
 */

 contains: function(item, from){
 return this.indexOf(item, from) != -1;
 },

 /*
 Property: associate
 Creates an object with key-value pairs based on the array of keywords passed in
 and the current content of the array.

 Arguments:
 keys - the array of keywords.

 Example:
 (start code)
 var Animals = ['Cat', 'Dog', 'Coala', 'Lizard'];
 var Speech = ['Miao', 'Bau', 'Fruuu', 'Mute'];
 var Speeches = Animals.associate(Speech);
 //Speeches['Miao'] is now Cat.
 //Speeches['Bau'] is now Dog.
 //...
 (end)
 */

 associate: function(keys){
 var obj = {}, length = Math.min(this.length, keys.length);
 for (var i = 0; i < length; i++) obj[keys[i]] = this[i];
 return obj;
 },

 /*
 Property: extend
 Extends an array with another one.

 Arguments:
 array - the array to extend ours with

 Example:
 >var Animals = ['Cat', 'Dog', 'Coala'];
 >Animals.extend(['Lizard']);
 >//Animals is now: ['Cat', 'Dog', 'Coala', 'Lizard'];
 */

 extend: function(array){
 for (var i = 0, j = array.length; i < j; i++) this.push(array[i]);
 return this;
 },

 /*
 Property: merge
 merges an array in another array, without duplicates. (case- and type-sensitive)

 Arguments:
 array - the array to merge from.

 Example:
 >['Cat','Dog'].merge(['Dog','Coala']); //returns ['Cat','Dog','Coala']
 */

 merge: function(array){
 for (var i = 0, l = array.length; i < l; i++) this.include(array[i]);
 return this;
 },

 /*
 Property: include
 includes the passed in element in the array, only if its not already present. (case- and type-sensitive)

 Arguments:
 item - item to add to the array (if not present)

 Example:
 >['Cat','Dog'].include('Dog'); //returns ['Cat','Dog']
 >['Cat','Dog'].include('Coala'); //returns ['Cat','Dog','Coala']
 */

 include: function(item){
 if (!this.length || !this.contains(item)) this.push(item);
 return this;
 },

 /*
 Property: getRandom
 returns a random item in the Array
 */

 getRandom: function(){
 return this[Moo.$random(0, this.length - 1)];
 },

 /*
 Property: getLast
 returns the last item in the Array
 */

 getLast: function(){
 return this[this.length - 1];
 }

});

//copies

Array.prototype.each = Array.prototype.forEach;
Array.prototype.test = Array.prototype.contains;
Array.prototype.removeItem = Array.prototype.remove;

/* Section: Utility Functions */

/*
Function: Moo.$A()
 Same as <Array.copy>, but as function.
 Useful to apply Array prototypes to iterable objects, as a collection of DOM elements or the arguments object.

Example:
 (start code)
 function myFunction(){
 Moo.$A(arguments).each(argument, function(){
 alert(argument);
 });
 };
 //the above will alert all the arguments passed to the function myFunction.
 (end)
*/

Moo.$A = function(array, start, length){
 return Array.prototype.copy.call(array, start, length);
};

/*
Function: Moo.$each
 Use to iterate through iterables that are not regular arrays, such as builtin getElementsByTagName calls, arguments of a function, or an object.

Arguments:
 iterable - an iterable element or an objct.
 function - function to apply to the iterable.
 bind - optional, the 'this' of the function will refer to this object.

Function argument:
 The function argument will be passed the following arguments.

 item - the current item in the iterator being procesed
 index - integer; the index of the item, or key in case of an object.

Examples:
 (start code)
 Moo.$each(['Sun','Mon','Tue'], function(day, index) {
 alert('name:' + day + ', index: ' + index);
 });
 //alerts "name: Sun, index: 0", "name: Mon, index: 1", etc.
 //over an object
 Moo.$each({first: "Sunday", second: "Monday", third: "Tuesday"}, function(value, key){
 alert("the " + key + " day of the week is " + value);
 });
 //alerts "the first day of the week is Sunday",
 //"the second day of the week is Monday", etc.
 (end)
*/

Moo.$each = function(iterable, fn, bind){
 if (iterable.length != undefined) Array.prototype.forEach.call(iterable, fn, bind);
 else for (var name in iterable) fn.call(bind || iterable, iterable[name], name);
};

/*
Script: String.js
 Contains String prototypes and Number prototypes.

License:
 MIT-style license.
*/

/*
Moo.Class: String
 A collection of The String Object prototype methods.
*/

String.extend({

 /*
 Property: test
 Tests a string with a regular expression.

 Arguments:
 regex - a string or regular expression object, the regular expression you want to match the string with
 params - optional, if first parameter is a string, any parameters you want to pass to the regex ('g' has no effect)

 Returns:
 true if a match for the regular expression is found in the string, false if not.
 See <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:RegExp:test>

 Example:
 >"I like cookies".test("cookie"); // returns true
 >"I like cookies".test("COOKIE", "i") // ignore case, returns true
 >"I like cookies".test("cake"); // returns false
 */

 test: function(regex, params){
 return ((typeof regex == 'string') ? new RegExp(regex, params) : regex).test(this);
 },

 /*
 Property: toInt
 parses a string to an integer.

 Returns:
 either an int or "NaN" if the string is not a number.

 Example:
 >var value = "10px".toInt(); // value is 10
 */

 toInt: function(){
 return parseInt(this, 10);
 },

 /*
 Property: toFloat
 parses a string to an float.

 Returns:
 either a float or "NaN" if the string is not a number.

 Example:
 >var value = "10.848".toFloat(); // value is 10.848
 */

 toFloat: function(){
 return parseFloat(this);
 },

 /*
 Property: camelCase
 Converts a hiphenated string to a camelcase string.

 Example:
 >"I-like-cookies".camelCase(); //"ILikeCookies"

 Returns:
 the camel cased string
 */

 camelCase: function(){
 return this.replace(/-\D/g, function(match){
 return match.charAt(1).toUpperCase();
 });
 },

 /*
 Property: hyphenate
 Converts a camelCased string to a hyphen-ated string.

 Example:
 >"ILikeCookies".hyphenate(); //"I-like-cookies"
 */

 hyphenate: function(){
 return this.replace(/\w[A-Z]/g, function(match){
 return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());
 });
 },

 /*
 Property: capitalize
 Converts the first letter in each word of a string to Uppercase.

 Example:
 >"i like cookies".capitalize(); //"I Like Cookies"

 Returns:
 the capitalized string
 */

 capitalize: function(){
 return this.replace(/\b[a-z]/g, function(match){
 return match.toUpperCase();
 });
 },

 /*
 Property: trim
 Trims the leading and trailing spaces off a string.

 Example:
 >" i like cookies ".trim() //"i like cookies"

 Returns:
 the trimmed string
 */

 trim: function(){
 return this.replace(/^\s+|\s+$/g, '');
 },

 /*
 Property: clean
 trims (<String.trim>) a string AND removes all the double spaces in a string.

 Returns:
 the cleaned string

 Example:
 >" i like cookies \n\n".clean() //"i like cookies"
 */

 clean: function(){
 return this.replace(/\s{2,}/g, ' ').trim();
 },

 /*
 Property: rgbToHex
 Converts an RGB value to hexidecimal. The string must be in the format of "rgb(255,255,255)" or "rgba(255,255,255,1)";

 Arguments:
 array - boolean value, defaults to false. Use true if you want the array ['FF','33','00'] as output instead of "#FF3300"

 Returns:
 hex string or array. returns "transparent" if the output is set as string and the fourth value of rgba in input string is 0.

 Example:
 >"rgb(17,34,51)".rgbToHex(); //"#112233"
 >"rgba(17,34,51,0)".rgbToHex(); //"transparent"
 >"rgb(17,34,51)".rgbToHex(true); //['11','22','33']
 */

 rgbToHex: function(array){
 var rgb = this.match(/\d{1,3}/g);
 return (rgb) ? rgb.rgbToHex(array) : false;
 },

 /*
 Property: hexToRgb
 Converts a hexidecimal color value to RGB. Input string must be the hex color value (with or without the hash). Also accepts triplets ('333');

 Arguments:
 array - boolean value, defaults to false. Use true if you want the array [255,255,255] as output instead of "rgb(255,255,255)";

 Returns:
 rgb string or array.

 Example:
 >"#112233".hexToRgb(); //"rgb(17,34,51)"
 >"#112233".hexToRgb(true); //[17,34,51]
 */

 hexToRgb: function(array){
 var hex = this.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);
 return (hex) ? hex.slice(1).hexToRgb(array) : false;
 },

 /*
 Property: contains
 checks if the passed in string is contained in the String. also accepts an optional second parameter, to check if the string is contained in a list of separated values.

 Example:
 >'a b c'.contains('c', ' '); //true
 >'a bc'.contains('bc'); //true
 >'a bc'.contains('b', ' '); //false
 */
 
 contains: function(string, s){
 return (s) ? (s + this + s).indexOf(s + string + s) > -1 : this.indexOf(string) > -1;
 },

 /*
 Property: escapeRegExp
 Returns string with escaped regular expression characters

 Example:
 >var search = 'animals.sheeps[1]'.escapeRegExp(); // search is now 'animals\.sheeps\[1\]'

 Returns:
 Escaped string
 */

 escapeRegExp: function(){
 return this.replace(/([.*+?^${}()|[\]\/\\])/g, '\\Moo.$1');
 }

});

Array.extend({

 /*
 Property: rgbToHex
 see <String.rgbToHex>, but as an array method.
 */

 rgbToHex: function(array){
 if (this.length < 3) return false;
 if (this[3] && (this[3] == 0) && !array) return 'transparent';
 var hex = [];
 for (var i = 0; i < 3; i++){
 var bit = (this[i] - 0).toString(16);
 hex.push((bit.length == 1) ? '0' + bit : bit);
 }
 return array ? hex : '#' + hex.join('');
 },

 /*
 Property: hexToRgb
 same as <String.hexToRgb>, but as an array method.
 */

 hexToRgb: function(array){
 if (this.length != 3) return false;
 var rgb = [];
 for (var i = 0; i < 3; i++){
 rgb.push(parseInt((this[i].length == 1) ? this[i] + this[i] : this[i], 16));
 }
 return array ? rgb : 'rgb(' + rgb.join(',') + ')';
 }

});

/*
Moo.Class: Number
 contains the internal method toInt.
*/

Number.extend({

 /*
 Property: toInt
 Returns this number; useful because toInt must work on both Strings and Numbers.
 */

 toInt: function(){
 return parseInt(this);
 },

 /*
 Property: toFloat
 Returns this number as a float; useful because toFloat must work on both Strings and Numbers.
 */

 toFloat: function(){
 return parseFloat(this);
 }

});

/* 
Script: Function.js
 Contains Function prototypes and utility functions .

License:
 MIT-style license.

Credits:
 - Some functions are inspired by those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
*/

/*
Moo.Class: Function
 A collection of The Function Object prototype methods.
*/

Function.extend({

 /*
 Property: create
 Main function to create closures.

 Returns:
 a function.

 Arguments:
 options - An Moo.Options object.

 Moo.Options:
 bind - The object that the "this" of the function will refer to. Default is the current function.
 event - If set to true, the function will act as an event listener and receive an event as first argument.
 If set to a class name, the function will receive a new instance of this class (with the event passed as argument's constructor) as first argument.
 Default is false.
 arguments - A single argument or array of arguments that will be passed to the function when called.
 
 If both the event and arguments options are set, the event is passed as first argument and the arguments array will follow.
 
 Default is no custom arguments, the function will receive the standard arguments when called.
 
 delay - Numeric value: if set, the returned function will delay the actual execution by this amount of milliseconds and return a timer handle when called.
 Default is no delay.
 periodical - Numeric value: if set, the returned function will periodically perform the actual execution with this specified interval and return a timer handle when called.
 Default is no periodical execution.
 attempt - If set to true, the returned function will try to execute and return either the results or the error when called. Default is false.
 */

 create: function(options){
 var fn = this;
 options = Moo.$merge({
 'bind': fn,
 'event': false,
 'arguments': null,
 'delay': false,
 'periodical': false,
 'attempt': false
 }, options);
 if (Moo.$chk(options.arguments) && Moo.$type(options.arguments) != 'array') options.arguments = [options.arguments];
 return function(event){
 var args;
 if (options.event){
 event = event || window.event;
 args = [(options.event === true) ? event : new options.event(event)];
 if (options.arguments) args = args.concat(options.arguments);
 }
 else args = options.arguments || arguments;
 var returns = function(){
 return fn.apply(Moo.$pick(options.bind, fn), args);
 };
 if (options.delay) return setTimeout(returns, options.delay);
 if (options.periodical) return setInterval(returns, options.periodical);
 if (options.attempt) try {return returns();} catch(err){return false;};
 return returns();
 };
 },

 /*
 Property: pass
 Shortcut to create closures with arguments and bind.

 Returns:
 a function.

 Arguments:
 args - the arguments passed. must be an array if arguments > 1
 bind - optional, the object that the "this" of the function will refer to.

 Example:
 >myFunction.pass([arg1, arg2], myElement);
 */

 pass: function(args, bind){
 return this.create({'arguments': args, 'bind': bind});
 },

 /*
 Property: attempt
 Tries to execute the function, returns either the function results or the error.

 Arguments:
 args - the arguments passed. must be an array if arguments > 1
 bind - optional, the object that the "this" of the function will refer to.

 Example:
 >myFunction.attempt([arg1, arg2], myElement);
 */

 attempt: function(args, bind){
 return this.create({'arguments': args, 'bind': bind, 'attempt': true})();
 },

 /*
 Property: bind
 method to easily create closures with "this" altered.

 Arguments:
 bind - optional, the object that the "this" of the function will refer to.
 args - optional, the arguments passed. must be an array if arguments > 1

 Returns:
 a function.

 Example:
 >function myFunction(){
 > this.setStyle('color', 'red');
 > // note that 'this' here refers to myFunction, not an element
 > // we'll need to bind this function to the element we want to alter
 >};
 >var myBoundFunction = myFunction.bind(myElement);
 >myBoundFunction(); // this will make the element myElement red.
 */

 bind: function(bind, args){
 return this.create({'bind': bind, 'arguments': args});
 },

 /*
 Property: bindAsEventListener
 cross browser method to pass event firer

 Arguments:
 bind - optional, the object that the "this" of the function will refer to.
 args - optional, the arguments passed. must be an array if arguments > 1

 Returns:
 a function with the parameter bind as its "this" and as a pre-passed argument event or window.event, depending on the browser.

 Example:
 >function myFunction(event){
 > alert(event.clientx) //returns the coordinates of the mouse..
 >};
 >myElement.onclick = myFunction.bindAsEventListener(myElement);
 */

 bindAsEventListener: function(bind, args){
 return this.create({'bind': bind, 'event': true, 'arguments': args});
 },

 /*
 Property: delay
 Delays the execution of a function by a specified duration.

 Arguments:
 delay - the duration to wait in milliseconds.
 bind - optional, the object that the "this" of the function will refer to.
 args - optional, the arguments passed. must be an array if arguments > 1

 Example:
 >myFunction.delay(50, myElement) //wait 50 milliseconds, then call myFunction and bind myElement to it
 >(function(){alert('one second later...')}).delay(1000); //wait a second and alert
 */

 delay: function(delay, bind, args){
 return this.create({'delay': delay, 'bind': bind, 'arguments': args})();
 },

 /*
 Property: periodical
 Executes a function in the specified intervals of time

 Arguments:
 interval - the duration of the intervals between executions.
 bind - optional, the object that the "this" of the function will refer to.
 args - optional, the arguments passed. must be an array if arguments > 1
 */

 periodical: function(interval, bind, args){
 return this.create({'periodical': interval, 'bind': bind, 'arguments': args})();
 }

});

/*
Script: Moo.Element.js
 Contains useful Moo.Element prototypes, to be used with the dollar function <Moo.$>.

License:
 MIT-style license.

Credits:
 - Some functions are inspired by those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
*/

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element = new Moo.Class({

 /*
 Property: initialize
 Creates a new element of the type passed in.

 Arguments:
 el - string; the tag name for the element you wish to create. you can also pass in an element reference, in which case it will be extended.
 props - object; the properties you want to add to your element.
 Accepts the same keys as <Moo.Element.setProperties>, but also allows events and styles

 Props:
 the key styles will be used as setStyles, the key events will be used as addEvents. any other key is used as setProperty.

 Example:
 (start code)
 new Moo.Element('a', {
 'styles': {
 'display': 'block',
 'border': '1px solid black'
 },
 'events': {
 'click': function(){
 //aaa
 },
 'mousedown': function(){
 //aaa
 }
 },
 'class': 'myClassSuperClass',
 'href': 'http://mad4milk.net'
 });

 (end)
 */

 initialize: function(el, props){
 if (Moo.$type(el) == 'string'){
 if (window.ie && props && (props.name || props.type)){
 var name = (props.name) ? ' name="' + props.name + '"' : '';
 var type = (props.type) ? ' type="' + props.type + '"' : '';
 delete props.name;
 delete props.type;
 el = '<' + el + name + type + '>';
 }
 el = document.createElement(el);
 }
 el = Moo.$(el);
 if (!props || !el) return el;
 for (var prop in props){
 var val = props[prop];
 switch(prop){
 case 'styles': el.setStyles(val); break;
 case 'events': if (el.addEvents) el.addEvents(val); break;
 case 'properties': el.setProperties(val); break;
 default: el.setProperty(prop, val);
 }
 }
 return el;
 }

});

/*
Moo.Class: Moo.Elements
 - Every dom function such as <Moo.$$>, or in general every function that returns a collection of nodes in mootools, returns them as an Moo.Elements class.
 - The purpose of the Moo.Elements class is to allow <Moo.Element> methods to work also on <Moo.Elements> array.
 - Moo.Elements is also an Array, so it accepts all the <Array> methods.
 - Every node of the Moo.Elements instance is already extended with <Moo.$>.

Example:
 >Moo.$$('myselector').each(function(el){
 > //...
 >});
 
 some iterations here, Moo.$$('myselector') is also an array.
 
 >Moo.$$('myselector').setStyle('color', 'red');
 every element returned by Moo.$$('myselector') also accepts <Moo.Element> methods, in this example every element will be made red.
*/

Moo.Elements = new Moo.Class({});

Moo.Elements.extend = Moo.Class.prototype.implement;

/*
Section: Utility Functions

Function: Moo.$
 returns the element passed in with all the Moo.Element prototypes applied.

Arguments:
 el - a reference to an actual element or a string representing the id of an element

Example:
 >Moo.$('myElement') // gets a DOM element by id with all the Moo.Element prototypes applied.
 >var div = document.getElementById('myElement');
 >Moo.$(div) //returns an Moo.Element also with all the mootools extentions applied.

 You'll use this when you aren't sure if a variable is an actual element or an id, as
 well as just shorthand for document.getElementById().

Returns:
 a DOM element or false (if no id was found).

Note:
 you need to call Moo.$ on an element only once to get all the prototypes.
 But its no harm to call it multiple times, as it will detect if it has been already extended.
*/

Moo.$ = function(el){
 if (!el) return false;
 if (el.htmlElement) return Moo.Garbage.collect(el);
 if ([window, document].contains(el)) return el;
 var type = Moo.$type(el);
 if (type == 'string'){
 el = document.getElementById(el);
 type = (el) ? 'element' : false;
 }
 if (type != 'element') return false;
 if (el.htmlElement) return Moo.Garbage.collect(el);
 if (['object', 'embed'].contains(el.tagName.toLowerCase())) return el;
 Moo.$extend(el, Moo.Element.prototype);
 el.htmlElement = true;
 return Moo.Garbage.collect(el);
};

/*
Function: Moo.$$
 Selects, and extends DOM elements. Moo.Elements arrays returned with Moo.$$ will also accept all the <Moo.Element> methods.
 The return type of element methods run through Moo.$$ is always an array. If the return array is only made by elements,
 Moo.$$ will be applied automatically.

Arguments:
 HTML Collections, arrays of elements, arrays of strings as element ids, elements, strings as selectors.
 Any number of the above as arguments are accepted.

Note:
 if you load <Dom.js>, Moo.$$ will also accept CSS Selectors, otherwise the only selectors supported are tag names.

Example:
 >Moo.$$('a') //an array of all anchor tags on the page
 >Moo.$$('a', 'b') //an array of all anchor and bold tags on the page
 >Moo.$$('#myElement') //array containing only the element with id = myElement. (only with <Dom.js>)
 >Moo.$$('#myElement a.myClass') //an array of all anchor tags with the class "myClass"
 >//within the DOM element with id "myElement" (only with <Dom.js>)
 >Moo.$$(myelement, myelement2, 'a', ['myid', myid2, 'myid3'], document.getElementsByTagName('div')) //an array containing:
 >// the element referenced as myelement if existing,
 >// the element referenced as myelement2 if existing,
 >// all the elements with a as tag in the page,
 >// the element with id = myid if existing
 >// the element with id = myid2 if existing
 >// the element with id = myid3 if existing
 >// all the elements with div as tag in the page

Returns:
 array - array of all the dom elements matched, extended with <Moo.$>. Returns as <Moo.Elements>.
*/

document.getElementsBySelector = document.getElementsByTagName;

Moo.$$ = function(){
 if (!arguments) return false;
 var elements = [];
 for (var i = 0, j = arguments.length; i < j; i++){
 var selector = arguments[i];
 switch(Moo.$type(selector)){
 case 'element': elements.push(selector);
 case 'boolean':
 case false: break;
 case 'string': selector = document.getElementsBySelector(selector, true);
 default: elements = elements.concat((selector.push) ? selector : Moo.$A(selector));
 }
 }
 return Moo.$$.unique(elements);
};

Moo.$$.unique = function(array){
 var elements = [];
 for (var i = 0, l = array.length; i < l; i++){
 if (array[i].$included) continue;
 var element = Moo.$(array[i]);
 if (element && !element.$included){
 element.$included = true;
 elements.push(element);
 }
 }
 for (var i = 0, l = elements.length; i < l; i++) elements[i].$included = null;
 return Moo.$extend(elements, new Moo.Elements);
};

Moo.Elements.Multi = function(property){
 return function(){
 var args = arguments;
 var items = [];
 var elements = true;
 for (var i = 0, j = this.length, returns; i < j; i++){
 returns = this[i][property].apply(this[i], args);
 if (Moo.$type(returns) != 'element') elements = false;
 items.push(returns);
 };
 return (elements) ? Moo.$$.unique(items) : items;
 };
};

Moo.Element.extend = function(properties){
 for (var property in properties){
 HTMLElement.prototype[property] = properties[property];
 Moo.Element.prototype[property] = properties[property];
 Moo.Elements.prototype[property] = Moo.Elements.Multi(property);
 }
};

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 inject: function(el, where){
 el = Moo.$(el);
 switch(where){
 case 'before': el.parentNode.insertBefore(this, el); break;
 case 'after':
 var next = el.getNext();
 if (!next) el.parentNode.appendChild(this);
 else el.parentNode.insertBefore(this, next);
 break;
 case 'top':
 var first = el.firstChild;
 if (first){
 el.insertBefore(this, first);
 break;
 }
 default: el.appendChild(this);
 }
 return this;
 },

 /*
 Property: injectBefore
 Inserts the Moo.Element before the passed element.

 Parameteres:
 el - an element reference or the id of the element to be injected in.

 Example:
 >html:
 ><div id="myElement"></div>
 ><div id="mySecondElement"></div>
 >js:
 >Moo.$('mySecondElement').injectBefore('myElement');
 >resulting html:
 ><div id="mySecondElement"></div>
 ><div id="myElement"></div>
 */

 injectBefore: function(el){
 return this.inject(el, 'before');
 },

 /*
 Property: injectAfter
 Same as <Moo.Element.injectBefore>, but inserts the element after.
 */

 injectAfter: function(el){
 return this.inject(el, 'after');
 },

 /*
 Property: injectInside
 Same as <Moo.Element.injectBefore>, but inserts the element inside.
 */

 injectInside: function(el){
 return this.inject(el, 'bottom');
 },
 
 /*
 Property: injectTop
 Same as <Moo.Element.injectInside>, but inserts the element inside, at the top.
 */
 
 injectTop: function(el){
 return this.inject(el, 'top');
 },

 /*
 Property: adopt
 Inserts the passed element(s) inside the Moo.Element. Works as <Moo.Element.injectInside> but in reverse and with any number of elements.

 Parameteres:
 el - an element reference or the id of the element to be injected in.
 */

 adopt: function(){
 Moo.$$.unique(arguments).injectInside(this);
 return this;
 },

 /*
 Property: remove
 Removes the Moo.Element from the DOM.

 Example:
 >Moo.$('myElement').remove() //bye bye
 */

 remove: function(){
 return this.parentNode.removeChild(this);
 },

 /*
 Property: clone
 Clones the Moo.Element and returns the cloned one.

 Returns:
 the cloned element

 Example:
 >var clone = Moo.$('myElement').clone().injectAfter('myElement');
 >//clones the Moo.Element and append the clone after the Moo.Element.
 */

 clone: function(contents){
 return Moo.$(this.cloneNode(contents !== false));
 },

 /*
 Property: replaceWith
 Replaces the Moo.Element with an element passed.

 Parameteres:
 el - a string representing the element to be injected in (myElementId, or div), or an element reference.
 If you pass div or another tag, the element will be created.

 Returns:
 the passed in element

 Example:
 >Moo.$('myOldElement').replaceWith(Moo.$('myNewElement')); //Moo.$('myOldElement') is gone, and Moo.$('myNewElement') is in its place.
 */

 replaceWith: function(el){
 el = Moo.$(el);
 this.parentNode.replaceChild(el, this);
 return el;
 },

 /*
 Property: appendText
 Appends text node to a DOM element.

 Arguments:
 text - the text to append.

 Example:
 ><div id="myElement">hey</div>
 >Moo.$('myElement').appendText(' howdy'); //myElement innerHTML is now "hey howdy"
 */

 appendText: function(text){
 if (window.ie){
 switch(this.getTag()){
 case 'style': this.styleSheet.cssText = text; return this;
 case 'script': return this.setProperty('text', text);
 }
 }
 this.appendChild(document.createTextNode(text));
 return this;
 },

 /*
 Property: hasClass
 Tests the Moo.Element to see if it has the passed in className.

 Returns:
 true - the Moo.Element has the class
 false - it doesn't

 Arguments:
 className - string; the class name to test.

 Example:
 ><div id="myElement" class="testClass"></div>
 >Moo.$('myElement').hasClass('testClass'); //returns true
 */

 hasClass: function(className){
 return this.className.contains(className, ' ');
 },

 /*
 Property: addClass
 Adds the passed in class to the Moo.Element, if the element doesnt already have it.

 Arguments:
 className - string; the class name to add

 Example:
 ><div id="myElement" class="testClass"></div>
 >Moo.$('myElement').addClass('newClass'); //<div id="myElement" class="testClass newClass"></div>
 */

 addClass: function(className){
 if (!this.hasClass(className)) this.className = (this.className + ' ' + className).clean();
 return this;
 },

 /*
 Property: removeClass
 Works like <Moo.Element.addClass>, but removes the class from the element.
 */

 removeClass: function(className){
 this.className = this.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|Moo.$)'), 'Moo.$1').clean();
 return this;
 },

 /*
 Property: toggleClass
 Adds or removes the passed in class name to the element, depending on if it's present or not.

 Arguments:
 className - the class to add or remove

 Example:
 ><div id="myElement" class="myClass"></div>
 >Moo.$('myElement').toggleClass('myClass');
 ><div id="myElement" class=""></div>
 >Moo.$('myElement').toggleClass('myClass');
 ><div id="myElement" class="myClass"></div>
 */

 toggleClass: function(className){
 return this.hasClass(className) ? this.removeClass(className) : this.addClass(className);
 },

 /*
 Property: setStyle
 Sets a css property to the Moo.Element.

 Arguments:
 property - the property to set
 value - the value to which to set it; for numeric values that require "px" you can pass an integer

 Example:
 >Moo.$('myElement').setStyle('width', '300px'); //the width is now 300px
 >Moo.$('myElement').setStyle('width', 300); //the width is now 300px
 */

 setStyle: function(property, value){
 switch(property){
 case 'opacity': return this.setOpacity(parseFloat(value));
 case 'float': property = (window.ie) ? 'styleFloat' : 'cssFloat';
 }
 property = property.camelCase();
 switch(Moo.$type(value)){
 case 'number': if (!['zIndex', 'zoom'].contains(property)) value += 'px'; break;
 case 'array': value = 'rgb(' + value.join(',') + ')';
 }
 this.style[property] = value;
 return this;
 },

 /*
 Property: setStyles
 Applies a collection of styles to the Moo.Element.

 Arguments:
 source - an object or string containing all the styles to apply. When its a string it overrides old style.

 Examples:
 >Moo.$('myElement').setStyles({
 > border: '1px solid #000',
 > width: 300,
 > height: 400
 >});

 OR

 >Moo.$('myElement').setStyles('border: 1px solid #000; width: 300px; height: 400px;');
 */

 setStyles: function(source){
 switch(Moo.$type(source)){
 case 'object': Moo.Element.setMany(this, 'setStyle', source); break;
 case 'string': this.style.cssText = source;
 }
 return this;
 },

 /*
 Property: setOpacity
 Sets the opacity of the Moo.Element, and sets also visibility == "hidden" if opacity == 0, and visibility = "visible" if opacity > 0.

 Arguments:
 opacity - float; Accepts values from 0 to 1.

 Example:
 >Moo.$('myElement').setOpacity(0.5) //make it 50% transparent
 */

 setOpacity: function(opacity){
 if (opacity == 0){
 if (this.style.visibility != "hidden") this.style.visibility = "hidden";
 } else {
 if (this.style.visibility != "visible") this.style.visibility = "visible";
 }
 if (!this.currentStyle || !this.currentStyle.hasLayout) this.style.zoom = 1;
 if (window.ie) this.style.filter = (opacity == 1) ? '' : "alpha(opacity=" + opacity * 100 + ")";
 this.style.opacity = this.$.opacity = opacity;
 return this;
 },

 /*
 Property: getStyle
 Returns the style of the Moo.Element given the property passed in.

 Arguments:
 property - the css style property you want to retrieve

 Example:
 >Moo.$('myElement').getStyle('width'); //returns "400px"
 >//but you can also use
 >Moo.$('myElement').getStyle('width').toInt(); //returns 400

 Returns:
 the style as a string
 */

 getStyle: function(property){
 property = property.camelCase();
 var result = this.style[property];
 if (!Moo.$chk(result)){
 if (property == 'opacity') return this.$.opacity;
 var result = [];
 for (var style in Moo.Element.Styles){
 if (property == style){
 Moo.Element.Styles[style].each(function(s){
 result.push(this.getStyle(s));
 }, this);
 if (property == 'border'){
 var every = result.every(function(bit){
 return (bit == result[0]);
 });
 return (every) ? result[0] : false;
 }
 return result.join(' ');
 }
 }
 if (Moo.Element.Styles.border.contains(property)){
 ['Width', 'Moo.Color', 'Style'].each(function(p){
 result.push(this.getStyle(property + p));
 }, this);
 return result.join(' ');
 }
 if (document.defaultView) result = document.defaultView.getComputedStyle(this, null).getPropertyValue(property.hyphenate());
 else if (this.currentStyle) result = this.currentStyle[property];
 }
 if (window.ie) result = Moo.Element.fixStyle(property, result, this);
 return (result && property.test(/color/i) && result.contains('rgb')) ? result.rgbToHex() : result;
 },

 /*
 Property: getStyles
 Returns an object of styles of the Moo.Element for each argument passed in.
 Arguments:
 properties - strings; any number of style properties
 Example:
 >Moo.$('myElement').getStyles('width','height','padding');
 >//returns an object like:
 >{width: "10px", height: "10px", padding: "10px 0px 10px 0px"}
 */

 getStyles: function(){
 return Moo.Element.getMany(this, 'getStyle', arguments);
 },

 walk: function(brother, start){
 brother += 'Sibling';
 var el = (start) ? this[start] : this[brother];
 while (el && Moo.$type(el) != 'element') el = el[brother];
 return Moo.$(el);
 },

 /*
 Property: getPrevious
 Returns the previousSibling of the Moo.Element, excluding text nodes.

 Example:
 >Moo.$('myElement').getPrevious(); //get the previous DOM element from myElement

 Returns:
 the sibling element or undefined if none found.
 */

 getPrevious: function(){
 return this.walk('previous');
 },

 /*
 Property: getNext
 Works as Moo.Element.getPrevious, but tries to find the nextSibling.
 */

 getNext: function(){
 return this.walk('next');
 },

 /*
 Property: getFirst
 Works as <Moo.Element.getPrevious>, but tries to find the firstChild.
 */

 getFirst: function(){
 return this.walk('next', 'firstChild');
 },

 /*
 Property: getLast
 Works as <Moo.Element.getPrevious>, but tries to find the lastChild.
 */

 getLast: function(){
 return this.walk('previous', 'lastChild');
 },

 /*
 Property: getParent
 returns the Moo.$(element.parentNode)
 */

 getParent: function(){
 return Moo.$(this.parentNode);
 },

 /*
 Property: getChildren
 returns all the Moo.$(element.childNodes), excluding text nodes. Returns as <Moo.Elements>.
 */

 getChildren: function(){
 return Moo.$$(this.childNodes);
 },

 /*
 Property: hasChild
 returns true if the passed in element is a child of the Moo.$(element).
 */

 hasChild: function(el) {
 return !!Moo.$A(this.getElementsByTagName('*')).contains(el);
 },

 /*
 Property: getProperty
 Gets the an attribute of the Moo.Element.

 Arguments:
 property - string; the attribute to retrieve

 Example:
 >Moo.$('myImage').getProperty('src') // returns whatever.gif

 Returns:
 the value, or an empty string
 */

 getProperty: function(property){
 var index = Moo.Element.Properties[property];
 return (index) ? this[index] : this.getAttribute(property);
 },

 /*
 Property: removeProperty
 Removes an attribute from the Moo.Element

 Arguments:
 property - string; the attribute to remove
 */

 removeProperty: function(property){
 var index = Moo.Element.Properties[property];
 if (index) this[index] = '';
 else this.removeAttribute(property);
 return this;
 },

 /*
 Property: getProperties
 same as <Moo.Element.getStyles>, but for properties
 */

 getProperties: function(){
 return Moo.Element.getMany(this, 'getProperty', arguments);
 },

 /*
 Property: setProperty
 Sets an attribute for the Moo.Element.

 Arguments:
 property - string; the property to assign the value passed in
 value - the value to assign to the property passed in

 Example:
 >Moo.$('myImage').setProperty('src', 'whatever.gif'); //myImage now points to whatever.gif for its source
 */

 setProperty: function(property, value){
 var index = Moo.Element.Properties[property];
 if (index) this[index] = value;
 else this.setAttribute(property, value);
 return this;
 },

 /*
 Property: setProperties
 Sets numerous attributes for the Moo.Element.

 Arguments:
 source - an object with key/value pairs.

 Example:
 (start code)
 Moo.$('myElement').setProperties({
 src: 'whatever.gif',
 alt: 'whatever dude'
 });
 <img src="whatever.gif" alt="whatever dude">
 (end)
 */

 setProperties: function(source){
 return Moo.Element.setMany(this, 'setProperty', source);
 },

 /*
 Property: setHTML
 Sets the innerHTML of the Moo.Element.

 Arguments:
 html - string; the new innerHTML for the element.

 Example:
 >Moo.$('myElement').setHTML(newHTML) //the innerHTML of myElement is now = newHTML
 */

 setHTML: function(){
 this.innerHTML = Moo.$A(arguments).join('');
 return this;
 },

 /*
 Property: getTag
 Returns the tagName of the element in lower case.

 Example:
 >Moo.$('myImage').getTag() // returns 'img'

 Returns:
 The tag name in lower case
 */

 getTag: function(){
 return this.tagName.toLowerCase();
 },

 /*
 Property: empty
 Empties an element of all its children.

 Example:
 >Moo.$('myDiv').empty() // empties the Div and returns it

 Returns:
 The element.
 */

 empty: function(){
 Moo.Garbage.trash(this.getElementsByTagName('*'));
 return this.setHTML('');
 }

});

Moo.Element.fixStyle = function(property, result, element){
 if (Moo.$chk(parseInt(result))) return result;
 if (['height', 'width'].contains(property)){
 var values = (property == 'width') ? ['left', 'right'] : ['top', 'bottom'];
 var size = 0;
 values.each(function(value){
 size += element.getStyle('border-' + value + '-width').toInt() + element.getStyle('padding-' + value).toInt();
 });
 return element['offset' + property.capitalize()] - size + 'px';
 } else if (property.test(/border(.+)Width/)){
 return '0px';
 }
 return result;
};

Moo.Element.Styles = {'border': [], 'padding': [], 'margin': []};
['Top', 'Right', 'Bottom', 'Left'].each(function(direction){
 for (var style in Moo.Element.Styles) Moo.Element.Styles[style].push(style + direction);
});

Moo.Element.getMany = function(el, method, keys){
 var result = {};
 Moo.$each(keys, function(key){
 result[key] = el[method](key);
 });
 return result;
};

Moo.Element.setMany = function(el, method, pairs){
 for (var key in pairs) el[method](key, pairs[key]);
 return el;
};

Moo.Element.Properties = new Moo.Abstract({
 'class': 'className', 'for': 'htmlFor', 'colspan': 'colSpan',
 'rowspan': 'rowSpan', 'accesskey': 'accessKey', 'tabindex': 'tabIndex',
 'maxlength': 'maxLength', 'readonly': 'readOnly', 'value': 'value',
 'disabled': 'disabled', 'checked': 'checked', 'multiple': 'multiple'
});

Moo.Element.listenerMethods = {

 addListener: function(type, fn){
 if (this.addEventListener) this.addEventListener(type, fn, false);
 else this.attachEvent('on' + type, fn);
 return this;
 },

 removeListener: function(type, fn){
 if (this.removeEventListener) this.removeEventListener(type, fn, false);
 else this.detachEvent('on' + type, fn);
 return this;
 }

};

window.extend(Moo.Element.listenerMethods);
document.extend(Moo.Element.listenerMethods);
Moo.Element.extend(Moo.Element.listenerMethods);

Moo.Element.Events = new Moo.Abstract({});

Moo.Garbage = {

 elements: [],

 collect: function(el){
 if (!el.$){
 Moo.Garbage.elements.push(el);
 el.$ = {'opacity': 1};
 }
 return el;
 },

 trash: function(elements){
 for (var i = 0, j = elements.length, el; i < j; i++){
 if (!(el = elements[i]) || !el.$) return;
 if (el.$events) {
 el.fireEvent('onTrash');
 el.removeEvents();
 }
 for (var p in el.$) el.$[p] = null;
 for (var p in Moo.Element.prototype) el[p] = null;
 el.htmlElement = el.$ = null;
 Moo.Garbage.elements.remove(el);
 }
 },

 empty: function(){
 Moo.Garbage.collect(window);
 Moo.Garbage.collect(document);
 Moo.Garbage.trash(Moo.Garbage.elements);
 }

};

window.addListener('unload', Moo.Garbage.empty);

/*
Script: Moo.Event.js
 Moo.Event class

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Event
 Cross browser methods to manage events.

Arguments:
 event - the event

Properties:
 shift - true if the user pressed the shift
 control - true if the user pressed the control 
 alt - true if the user pressed the alt
 meta - true if the user pressed the meta key
 wheel - the amount of third button scrolling
 code - the keycode of the key pressed
 page.x - the x position of the mouse, relative to the full window
 page.y - the y position of the mouse, relative to the full window
 client.x - the x position of the mouse, relative to the viewport
 client.y - the y position of the mouse, relative to the viewport
 key - the key pressed as a lowercase string. key also returns 'enter', 'up', 'down', 'left', 'right', 'space', 'backspace', 'delete', 'esc'. Handy for these special keys.
 target - the event target
 relatedTarget - the event related target

Example:
 (start code)
 Moo.$('myLink').onkeydown = function(event){
 var event = new Moo.Event(event);
 //event is now the Moo.Event class.
 alert(event.key); //returns the lowercase letter pressed
 alert(event.shift); //returns true if the key pressed is shift
 if (event.key == 's' && event.control) alert('document saved');
 };
 (end)
*/

Moo.Event = new Moo.Class({

 initialize: function(event){
 event = event || window.event;
 this.event = event;
 this.type = event.type;
 this.target = event.target || event.srcElement;
 if (this.target.nodeType == 3) this.target = this.target.parentNode;
 this.shift = event.shiftKey;
 this.control = event.ctrlKey;
 this.alt = event.altKey;
 this.meta = event.metaKey;
 if (['DOMMouseScroll', 'mousewheel'].contains(this.type)){
 this.wheel = (event.wheelDelta) ? event.wheelDelta / 120 : -(event.detail || 0) / 3;
 } else if (this.type.contains('key')){
 this.code = event.which || event.keyCode;
 for (var name in Moo.Event.keys){
 if (Moo.Event.keys[name] == this.code){
 this.key = name;
 break;
 }
 }
 if (this.type == 'keydown'){
 var fKey = this.code - 111;
 if (fKey > 0 && fKey < 13) this.key = 'f' + fKey;
 }
 this.key = this.key || String.fromCharCode(this.code).toLowerCase();
 } else if (this.type.test(/(click|mouse|menu)/)){
 this.page = {
 'x': event.pageX || event.clientX + document.documentElement.scrollLeft,
 'y': event.pageY || event.clientY + document.documentElement.scrollTop
 };
 this.client = {
 'x': event.pageX ? event.pageX - window.pageXOffset : event.clientX,
 'y': event.pageY ? event.pageY - window.pageYOffset : event.clientY
 };
 this.rightClick = (event.which == 3) || (event.button == 2);
 switch(this.type){
 case 'mouseover': this.relatedTarget = event.relatedTarget || event.fromElement; break;
 case 'mouseout': this.relatedTarget = event.relatedTarget || event.toElement;
 }
 if (this.relatedTarget && this.relatedTarget.nodeType == 3) this.relatedTarget = this.relatedTarget.parentNode;
 }
 },

 /*
 Property: stop
 cross browser method to stop an event
 */

 stop: function() {
 return this.stopPropagation().preventDefault();
 },

 /*
 Property: stopPropagation
 cross browser method to stop the propagation of an event
 */

 stopPropagation: function(){
 if (this.event.stopPropagation) this.event.stopPropagation();
 else this.event.cancelBubble = true;
 return this;
 },

 /*
 Property: preventDefault
 cross browser method to prevent the default action of the event
 */

 preventDefault: function(){
 if (this.event.preventDefault) this.event.preventDefault();
 else this.event.returnValue = false;
 return this;
 }

});

Moo.Event.keys = new Moo.Abstract({
 'enter': 13,
 'up': 38,
 'down': 40,
 'left': 37,
 'right': 39,
 'esc': 27,
 'space': 32,
 'backspace': 8,
 'tab': 9,
 'delete': 46
});

/* Section: Custom Moo.Events */

Moo.Element.Events.extend({

 /* Moo.Event: mouseenter
 In addition to the standard javascript events (load, mouseover, mouseout, click, etc.) <Moo.Event.js> contains two custom events
 this event fires when the mouse enters the area of the dom element; will not be fired again if the mouse crosses over children of the element (unlike mouseover)
 

 Example:
 >Moo.$(myElement).addEvent('mouseenter', myFunction);
 */

 'mouseenter': {
 type: 'mouseover',
 map: function(event){
 event = new Moo.Event(event);
 if (event.relatedTarget == this || this.hasChild(event.relatedTarget)) return;
 this.fireEvent('mouseenter', event);
 }
 },
 
 /* Moo.Event: mouseleave
 this event fires when the mouse exits the area of the dom element; will not be fired again if the mouse crosses over children of the element (unlike mouseout)
 

 Example:
 >Moo.$(myElement).addEvent('mouseleave', myFunction);
 */
 
 'mouseleave': {
 type: 'mouseout',
 map: function(event){
 event = new Moo.Event(event);
 if (event.relatedTarget == this || this.hasChild(event.relatedTarget)) return;
 this.fireEvent('mouseleave', event);
 }
 }
 
});

/*
Moo.Class: Function
 A collection of The Function Object prototype methods.
*/

Function.extend({

 /*
 Property: bindWithEvent
 automatically passes mootools Moo.Event Moo.Class.

 Arguments:
 bind - optional, the object that the "this" of the function will refer to.
 args - optional, an argument to pass to the function; if more than one argument, it must be an array of arguments.

 Returns:
 a function with the parameter bind as its "this" and as a pre-passed argument event or window.event, depending on the browser.

 Example:
 >function myFunction(event){
 > alert(event.client.x) //returns the coordinates of the mouse..
 >};
 >myElement.onclick = myFunction.bindWithEvent(myElement);
 */

 bindWithEvent: function(bind, args){
 return this.create({'bind': bind, 'arguments': args, 'event': Moo.Event});
 }

});

/*
Script: Dom.js
 Css Query related function and <Moo.Element> extensions

License:
 MIT-style license.
*/

/* Section: Utility Functions */

/*
Function: Moo.$E
 Selects a single (i.e. the first found) Moo.Element based on the selector passed in and an optional filter element.
 Returns as <Moo.Element>.

Arguments:
 selector - string; the css selector to match
 filter - optional; a DOM element to limit the scope of the selector match; defaults to document.

Example:
 >Moo.$E('a', 'myElement') //find the first anchor tag inside the DOM element with id 'myElement'

Returns:
 a DOM element - the first element that matches the selector
*/

Moo.$E = function(selector, filter){
 return (Moo.$(filter) || document).getElement(selector);
};

/*
Function: Moo.$ES
 Returns a collection of Moo.Elements that match the selector passed in limited to the scope of the optional filter.
 See Also: <Moo.Element.getElements> for an alternate syntax.
 Returns as <Moo.Elements>.

Returns:
 an array of dom elements that match the selector within the filter

Arguments:
 selector - string; css selector to match
 filter - optional; a DOM element to limit the scope of the selector match; defaults to document.

Examples:
 >Moo.$ES("a") //gets all the anchor tags; synonymous with Moo.$$("a")
 >Moo.$ES('a','myElement') //get all the anchor tags within Moo.$('myElement')
*/

Moo.$ES = function(selector, filter){
 return (Moo.$(filter) || document).getElementsBySelector(selector);
};

Moo.$$.shared = {

 cache: {},

 regexp: /^(\w*|\*)(?:#([\w-]+)|\.([\w-]+))?(?:\[(\w+)(?:([!*^$]?=)["']?([^"'\]]*)["']?)?])?$/,

 getNormalParam: function(selector, items, context, param, i){
 Moo.Filters.selector = param;
 if (i == 0){
 if (param[2]){
 var el = context.getElementById(param[2]);
 if (!el || ((param[1] != '*') && (el.tagName.toLowerCase() != param[1]))) return false;
 items = [el];
 } else {
 items = Moo.$A(context.getElementsByTagName(param[1]));
 }
 } else {
 items = Moo.$$.shared.getElementsByTagName(items, param[1]);
 if (param[2]) items = items.filter(Moo.Filters.id);
 }
 if (param[3]) items = items.filter(Moo.Filters.className);
 if (param[4]) items = items.filter(Moo.Filters.attribute);
 return items;
 },

 getXpathParam: function(selector, items, context, param, i){
 if (Moo.$$.shared.cache[selector].xpath){
 items.push(Moo.$$.shared.cache[selector].xpath);
 return items;
 }
 var temp = context.namespaceURI ? ['xhtml:'] : [];
 temp.push(param[1]);
 if (param[2]) temp.push('[@id="', param[2], '"]');
 if (param[3]) temp.push('[contains(concat(" ", @class, " "), " ', param[3], ' ")]');
 if (param[4]){
 if (param[5] && param[6]){
 switch(param[5]){
 case '*=': temp.push('[contains(@', param[4], ', "', param[6], '")]'); break;
 case '^=': temp.push('[starts-with(@', param[4], ', "', param[6], '")]'); break;
 case 'Moo.$=': temp.push('[substring(@', param[4], ', string-length(@', param[4], ') - ', param[6].length, ' + 1) = "', param[6], '"]'); break;
 case '=': temp.push('[@', param[4], '="', param[6], '"]'); break;
 case '!=': temp.push('[@', param[4], '!="', param[6], '"]');
 }
 } else {
 temp.push('[@', param[4], ']');
 }
 }
 temp = temp.join('');
 Moo.$$.shared.cache[selector].xpath = temp;
 items.push(temp);
 return items;
 },

 getNormalItems: function(items, context, nocash){
 return (nocash) ? items : Moo.$$.unique(items);
 },

 getXpathItems: function(items, context, nocash){
 var elements = [];
 var xpath = document.evaluate('.//' + items.join('//'), context, Moo.$$.shared.resolver, XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE, null);
 for (var i = 0, j = xpath.snapshotLength; i < j; i++) elements.push(xpath.snapshotItem(i));
 return (nocash) ? elements : Moo.$extend(elements.map(Moo.$), new Moo.Elements);
 },

 resolver: function(prefix){
 return (prefix == 'xhtml') ? 'http://www.w3.org/1999/xhtml' : false;
 },

 getElementsByTagName: function(context, tagName){
 var found = [];
 for (var i = 0, j = context.length; i < j; i++) found = found.concat(Moo.$A(context[i].getElementsByTagName(tagName)));
 return found;
 }

};

if (window.xpath){
 Moo.$$.shared.getParam = Moo.$$.shared.getXpathParam;
 Moo.$$.shared.getItems = Moo.$$.shared.getXpathItems;
} else {
 Moo.$$.shared.getParam = Moo.$$.shared.getNormalParam;
 Moo.$$.shared.getItems = Moo.$$.shared.getNormalItems;
}

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.domMethods = {

 /*
 Property: getElements
 Gets all the elements within an element that match the given (single) selector.
 Returns as <Moo.Elements>.

 Arguments:
 selector - string; the css selector to match

 Examples:
 >Moo.$('myElement').getElements('a'); // get all anchors within myElement
 >Moo.$('myElement').getElements('input[name=dialog]') //get all input tags with name 'dialog'
 >Moo.$('myElement').getElements('input[name$=log]') //get all input tags with names ending with 'log'

 Notes:
 Supports these operators in attribute selectors:

 - = : is equal to
 - ^= : starts-with
 - Moo.$= : ends-with
 - != : is not equal to

 Xpath is used automatically for compliant browsers.
 */

 getElements: function(selector, nocash){
 var items = [];
 selector = selector.trim().split(' ');
 for (var i = 0, j = selector.length; i < j; i++){
 var sel = selector[i];
 var param;
 if (Moo.$$.shared.cache[sel]){
 param = Moo.$$.shared.cache[sel].param;
 } else {
 param = sel.match(Moo.$$.shared.regexp);
 if (!param) break;
 param[1] = param[1] || '*';
 Moo.$$.shared.cache[sel] = {'param': param};
 }
 var temp = Moo.$$.shared.getParam(sel, items, this, param, i);
 if (!temp) break;
 items = temp;
 }
 return Moo.$$.shared.getItems(items, this, nocash);
 },

 /*
 Property: getElement
 Same as <Moo.Element.getElements>, but returns only the first. Alternate syntax for <Moo.$E>, where filter is the Moo.Element.
 Returns as <Moo.Element>.

 Arguments:
 selector - string; css selector
 */

 getElement: function(selector){
 return Moo.$(this.getElements(selector, true)[0] || false);
 },

 /*
 Property: getElementsBySelector
 Same as <Moo.Element.getElements>, but allows for comma separated selectors, as in css. Alternate syntax for <Moo.$$>, where filter is the Moo.Element.
 Returns as <Moo.Elements>.

 Arguments:
 selector - string; css selector
 */

 getElementsBySelector: function(selector, nocash){
 var elements = [];
 selector = selector.split(',');
 for (var i = 0, j = selector.length; i < j; i++) elements = elements.concat(this.getElements(selector[i], true));
 return (nocash) ? elements : Moo.$$.unique(elements);
 },

 /*
 Property: getElementsByClassName
 Returns all the elements that match a specific class name.
 Here for compatibility purposes. can also be written: document.getElements('.className'), or Moo.$$('.className')
 Returns as <Moo.Elements>.

 Arguments:
 className - string; css classname
 */

 getElementsByClassName: function(className){
 return this.getElements('.' + className);
 }

};

Moo.Element.extend({

 /*
 Property: getElementById
 Targets an element with the specified id found inside the Moo.Element. Does not overwrite document.getElementById.

 Arguments:
 id - string; the id of the element to find.
 */

 getElementById: function(id){
 var el = document.getElementById(id);
 if (!el) return false;
 for (var parent = el.parentNode; parent != this; parent = parent.parentNode){
 if (!parent) return false;
 }
 return el;
 }

});

document.extend(Moo.Element.domMethods);
Moo.Element.extend(Moo.Element.domMethods);

//dom filters, internal methods.

Moo.Filters = {

 selector: [],

 id: function(el){
 return (el.id == Moo.Filters.selector[2]);
 },

 className: function(el){
 return el.className.contains(Moo.Filters.selector[3], ' ');
 },

 attribute: function(el){
 var current = Moo.Element.prototype.getProperty.call(el, Moo.Filters.selector[4]);
 if (!current) return false;
 var operator = Moo.Filters.selector[5];
 if (!operator) return true;
 var value = Moo.Filters.selector[6];
 switch(operator){
 case '=': return (current == value);
 case '*=': return (current.contains(value));
 case '^=': return (current.test('^' + value));
 case 'Moo.$=': return (current.test(value + 'Moo.$'));
 case '!=': return (current != value);
 case '~=': return current.contains(value, ' ');
 }
 return false;
 }

};

/*
Script: Moo.Element.Form.js
 Contains Moo.Element prototypes to deal with Forms and their elements.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 /*
 Property: getValue
 Returns the value of the Moo.Element, if its tag is textarea, select or input. getValue called on a multiple select will return an array.
 */

 getValue: function(){
 switch(this.getTag()){
 case 'select':
 var values = [];
 Moo.$each(this.options, function(opt){
 if (opt.selected) values.push(Moo.$pick(opt.value, opt.text));
 });
 return (this.multiple) ? values : values[0];
 case 'input': if (!(this.checked && ['checkbox', 'radio'].contains(this.type)) && !['hidden', 'text', 'password'].contains(this.type)) break;
 case 'textarea': return this.value;
 }
 return false;
 },

 getFormElements: function(){
 return Moo.$$(this.getElementsByTagName('input'), this.getElementsByTagName('select'), this.getElementsByTagName('textarea'));
 },

 /*
 Property: toQueryString
 Reads the children inputs of the Moo.Element and generates a query string, based on their values. Used internally in <Moo.Ajax>

 Example:
 (start code)
 <form id="myForm" action="submit.php">
 <input name="email" value="bob@bob.com">
 <input name="zipCode" value="90210">
 </form>

 <script>
 Moo.$('myForm').toQueryString()
 </script>
 (end)

 Returns:
 email=bob@bob.com&zipCode=90210
 */

 toQueryString: function(){
 var queryString = [];
 this.getFormElements().each(function(el){
 var name = el.name;
 var value = el.getValue();
 if (value === false || !name || el.disabled) return;
 var qs = function(val){
 queryString.push(name + '=' + encodeURIComponent(val));
 };
 if (Moo.$type(value) == 'array') value.each(qs);
 else qs(value);
 });
 return queryString.join('&');
 }

});

/*
Script: Moo.Element.Dimensions.js
 Contains Moo.Element prototypes to deal with Moo.Element size and position in space.
 
Note:
 The functions in this script require n XHTML doctype.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({
 
 /*
 Property: scrollTo
 Scrolls the element to the specified coordinated (if the element has an overflow)

 Arguments:
 x - the x coordinate
 y - the y coordinate

 Example:
 >Moo.$('myElement').scrollTo(0, 100)
 */

 scrollTo: function(x, y){
 this.scrollLeft = x;
 this.scrollTop = y;
 },

 /*
 Property: getSize
 Return an Object representing the size/scroll values of the element.

 Example:
 (start code)
 Moo.$('myElement').getSize();
 (end)

 Returns:
 (start code)
 {
 'scroll': {'x': 100, 'y': 100},
 'size': {'x': 200, 'y': 400},
 'scrollSize': {'x': 300, 'y': 500}
 }
 (end)
 */

 getSize: function(){
 return {
 'scroll': {'x': this.scrollLeft, 'y': this.scrollTop},
 'size': {'x': this.offsetWidth, 'y': this.offsetHeight},
 'scrollSize': {'x': this.scrollWidth, 'y': this.scrollHeight}
 };
 },

 /*
 Property: getPosition
 Returns the real offsets of the element.

 Example:
 >Moo.$('element').getPosition();

 Returns:
 >{x: 100, y:500};
 */

 getPosition: function(overflown){
 overflown = overflown || [];
 var el = this, left = 0, top = 0;
 do {
 left += el.offsetLeft || 0;
 top += el.offsetTop || 0;
 el = el.offsetParent;
 } while (el);
 overflown.each(function(element){
 left -= element.scrollLeft || 0;
 top -= element.scrollTop || 0;
 });
 return {'x': left, 'y': top};
 },

 /*
 Property: getTop
 Returns the distance from the top of the window to the Moo.Element.
 */

 getTop: function(){
 return this.getPosition().y;
 },

 /*
 Property: getLeft
 Returns the distance from the left of the window to the Moo.Element.
 */

 getLeft: function(){
 return this.getPosition().x;
 },

 /*
 Property: getCoordinates
 Returns an object with width, height, left, right, top, and bottom, representing the values of the Moo.Element

 Example:
 (start code)
 var myValues = Moo.$('myElement').getCoordinates();
 (end)

 Returns:
 (start code)
 {
 width: 200,
 height: 300,
 left: 100,
 top: 50,
 right: 300,
 bottom: 350
 }
 (end)
 */

 getCoordinates: function(overflown){
 var position = this.getPosition(overflown);
 var obj = {
 'width': this.offsetWidth,
 'height': this.offsetHeight,
 'left': position.x,
 'top': position.y
 };
 obj.right = obj.left + obj.width;
 obj.bottom = obj.top + obj.height;
 return obj;
 }

});

/*
Script: Moo.Element.Events.js
 Contains Moo.Element prototypes to deal with Moo.Element events.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.eventMethods = {

 /*
 Property: addEvent
 Attaches an event listener to a DOM element.

 Arguments:
 type - the event to monitor ('click', 'load', etc) without the prefix 'on'.
 fn - the function to execute

 Example:
 >Moo.$('myElement').addEvent('click', function(){alert('clicked!')});
 */

 addEvent: function(type, fn){
 this.$events = this.$events || {};
 this.$events[type] = this.$events[type] || {'keys': [], 'values': []};
 if (this.$events[type].keys.contains(fn)) return this;
 this.$events[type].keys.push(fn);
 var realType = type;
 var bound = false;
 if (Moo.Element.Events[type]){
 if (Moo.Element.Events[type].add) Moo.Element.Events[type].add.call(this, fn);
 if (Moo.Element.Events[type].map) bound = Moo.Element.Events[type].map.bindAsEventListener(this);
 realType = Moo.Element.Events[type].type || type;
 }
 if (!this.addEventListener) bound = bound || fn.bindAsEventListener(this);
 else bound = bound || fn;
 this.$events[type].values.push(bound);
 return this.addListener(realType, bound);
 },

 /*
 Property: removeEvent
 Works as Moo.Element.addEvent, but instead removes the previously added event listener.
 */

 removeEvent: function(type, fn){
 if (!this.$events || !this.$events[type]) return this;
 var pos = this.$events[type].keys.indexOf(fn);
 if (pos == -1) return this;
 var key = this.$events[type].keys.splice(pos,1)[0];
 var value = this.$events[type].values.splice(pos,1)[0];
 if (Moo.Element.Events[type]){
 if (Moo.Element.Events[type].remove) Moo.Element.Events[type].remove.call(this, fn);
 type = Moo.Element.Events[type].type || type;
 }
 return this.removeListener(type, value);
 },

 /*
 Property: addEvents
 As <addEvent>, but accepts an object and add multiple events at once.
 */

 addEvents: function(source){
 return Moo.Element.setMany(this, 'addEvent', source);
 },

 /*
 Property: removeEvents
 removes all events of a certain type from an element. if no argument is passed in, removes all events.
 */

 removeEvents: function(type){
 if (!this.$events) return this;
 if (type){
 if (this.$events[type]){
 Moo.$A(this.$events[type].keys).each(function(fn, i){
 this.removeEvent(type, fn);
 }, this);
 this.$events[type] = null;
 }
 } else {
 for (var evType in this.$events) this.removeEvents(evType);
 this.$events = null;
 }
 return this;
 },

 /*
 Property: fireEvent
 executes all events of the specified type present in the element.
 */

 fireEvent: function(type, args){
 if (this.$events && this.$events[type]){
 this.$events[type].keys.each(function(fn){
 fn.bind(this, args)();
 }, this);
 }
 }

};

Moo.Element.Events.mousewheel = {
 type: (window.gecko) ? 'DOMMouseScroll' : 'mousewheel'
};

window.extend(Moo.Element.eventMethods);
document.extend(Moo.Element.eventMethods);
Moo.Element.extend(Moo.Element.eventMethods);

/*
Script: Moo.Window.DomReady.js
 Contains the custom event domready, for window.

License:
 MIT-style license.
*/

/* Section: Custom Moo.Events */

/*
Moo.Event: domready
 executes a function when the dom tree is loaded, without waiting for images. Only works when called from window. 

Credits:
 (c) Dean Edwards/Matthias Miller/John Resig, remastered for mootools.

Arguments:
 fn - the function to execute when the DOM is ready

Example:
 > window.addEvent('domready', function(){
 > alert('the dom is ready');
 > });
*/

Moo.Element.Events.domready = {

 add: function(fn){
 if (window.loaded){
 fn.call(this);
 return;
 }
 var domReady = function(){
 if (window.loaded) return;
 window.loaded = true;
 window.timer = Moo.$clear(window.timer);
 this.fireEvent('domready');
 }.bind(this);
 if (document.readyState && window.khtml){
 window.timer = function(){
 if (['loaded','complete'].contains(document.readyState)) domReady();
 }.periodical(50);
 } else if (document.readyState && window.ie){
 if (!Moo.$('ie_ready')){
 var src = (window.location.protocol == 'https:') ? '://0' : 'javascript:void(0)';
 document.write('<script id="ie_ready" defer src="' + src + '"><\/script>');
 Moo.$('ie_ready').onreadystatechange = function(){
 if (this.readyState == 'complete') domReady();
 };
 }
 } else {
 window.addListener("load", domReady);
 document.addListener("DOMContentLoaded", domReady);
 }
 }

};

/* Section: Utility Functions */

/*
Function: window.onDomReady
 DEPRECATED: Executes the passed in function when the DOM is ready (when the document tree has loaded, not waiting for images).
 Same as <window.addEvent> ('domready', init).
*/

window.onDomReady = function(fn){
 return this.addEvent('domready', fn);
};

/*
Script: Moo.Window.Size.js
 Moo.Window cross-browser dimensions methods.
 
Note:
 The Functions in this script require an XHTML doctype.

License:
 MIT-style license.
*/

/*
Moo.Class: window
 Cross browser methods to get various window dimensions.
 Warning: All these methods require that the browser operates in strict mode, not quirks mode.
*/

window.extend({

 /*
 Property: getWidth
 Returns an integer representing the width of the browser window (without the scrollbar).
 */

 getWidth: function(){
 if (this.khtml) return this.innerWidth;
 if (this.opera) return document.body.clientWidth;
 return document.documentElement.clientWidth;
 },

 /*
 Property: getHeight
 Returns an integer representing the height of the browser window (without the scrollbar).
 */

 getHeight: function(){
 if (this.khtml) return this.innerHeight;
 if (this.opera) return document.body.clientHeight;
 return document.documentElement.clientHeight;
 },

 /*
 Property: getScrollWidth
 Returns an integer representing the scrollWidth of the window.
 This value is equal to or bigger than <getWidth>.

 See Also:
 <http://developer.mozilla.org/en/docs/DOM:element.scrollWidth>
 */

 getScrollWidth: function(){
 if (this.ie) return Math.max(document.documentElement.offsetWidth, document.documentElement.scrollWidth);
 if (this.khtml) return document.body.scrollWidth;
 return document.documentElement.scrollWidth;
 },

 /*
 Property: getScrollHeight
 Returns an integer representing the scrollHeight of the window.
 This value is equal to or bigger than <getHeight>.

 See Also:
 <http://developer.mozilla.org/en/docs/DOM:element.scrollHeight>
 */

 getScrollHeight: function(){
 if (this.ie) return Math.max(document.documentElement.offsetHeight, document.documentElement.scrollHeight);
 if (this.khtml) return document.body.scrollHeight;
 return document.documentElement.scrollHeight;
 },

 /*
 Property: getScrollLeft
 Returns an integer representing the scrollLeft of the window (the number of pixels the window has scrolled from the left).

 See Also:
 <http://developer.mozilla.org/en/docs/DOM:element.scrollLeft>
 */

 getScrollLeft: function(){
 return this.pageXOffset || document.documentElement.scrollLeft;
 },

 /*
 Property: getScrollTop
 Returns an integer representing the scrollTop of the window (the number of pixels the window has scrolled from the top).

 See Also:
 <http://developer.mozilla.org/en/docs/DOM:element.scrollTop>
 */

 getScrollTop: function(){
 return this.pageYOffset || document.documentElement.scrollTop;
 },

 /*
 Property: getSize
 Same as <Moo.Element.getSize>
 */

 getSize: function(){
 return {
 'size': {'x': this.getWidth(), 'y': this.getHeight()},
 'scrollSize': {'x': this.getScrollWidth(), 'y': this.getScrollHeight()},
 'scroll': {'x': this.getScrollLeft(), 'y': this.getScrollTop()}
 };
 },

 //ignore
 getPosition: function(){return {'x': 0, 'y': 0}}

});

/*
Script: Moo.Fx.Base.js
 Contains <Moo.Fx.Base> and two Transitions.

License:
 MIT-style license.
*/

Moo.Fx = {Shared: {}};

/*
Moo.Class: Moo.Fx.Base
 Base class for the Mootools Effects (Moo.Fx) library.

Moo.Options:
 onStart - the function to execute as the effect begins; nothing (<Moo.Class.empty>) by default.
 onComplete - the function to execute after the effect has processed; nothing (<Moo.Class.empty>) by default.
 transition - the equation to use for the effect see <Moo.Fx.Transitions>; default is <Moo.Fx.Transitions.Sine.easeInOut>
 duration - the duration of the effect in ms; 500 is the default.
 unit - the unit is 'px' by default (other values include things like 'em' for fonts or '%').
 wait - boolean: to wait or not to wait for a current transition to end before running another of the same instance. defaults to true.
 fps - the frames per second for the transition; default is 30
*/

Moo.Fx.Base = new Moo.Class({

 options: {
 onStart: Moo.Class.empty,
 onComplete: Moo.Class.empty,
 onCancel: Moo.Class.empty,
 transition: function(t, c, d){
 return -c / 2 * (Math.cos(Math.PI * t / d) - 1);
 },
 duration: 500,
 unit: 'px',
 wait: true,
 fps: 50
 },

 initialize: function(options){
 this.element = this.element || null;
 this.setOptions(options);
 if (this.options.initialize) this.options.initialize.call(this);
 },

 step: function(){
 var time = Moo.$time();
 if (time < this.time + this.options.duration){
 this.cTime = time - this.time;
 this.setNow();
 this.increase();
 } else {
 this.stop(true);
 this.now = this.to;
 this.increase();
 this.fireEvent('onComplete', this.element, 10);
 this.callChain();
 }
 },

 /*
 Property: set
 Immediately sets the value with no transition.

 Arguments:
 to - the point to jump to

 Example:
 >var myFx = new Moo.Fx.Style('myElement', 'opacity').set(0); //will make it immediately transparent
 */

 set: function(to){
 this.now = to;
 this.increase();
 return this;
 },

 setNow: function(){
 this.now = this.compute(this.from, this.to);
 },

 compute: function(from, to){
 return this.options.transition(this.cTime, (to - from), this.options.duration) + from;
 },

 /*
 Property: start
 Executes an effect from one position to the other.

 Arguments:
 from - integer: staring value
 to - integer: the ending value

 Examples:
 >var myFx = new Moo.Fx.Style('myElement', 'opacity').start(0,1); //display a transition from transparent to opaque.
 */

 start: function(from, to){
 if (!this.options.wait) this.stop();
 else if (this.timer) return this;
 this.from = from;
 this.to = to;
 this.time = Moo.$time();
 this.timer = this.step.periodical(Math.round(1000 / this.options.fps), this);
 this.fireEvent('onStart', this.element);
 return this;
 },

 /*
 Property: stop
 Stops the transition.
 */

 stop: function(end){
 if (!this.timer) return this;
 this.timer = Moo.$clear(this.timer);
 if (!end) this.fireEvent('onCancel', this.element);
 return this;
 },

 //compat
 custom: function(from, to){return this.start(from, to)},
 clearTimer: function(end){return this.stop(end)}

});

Moo.Fx.Base.implement(new Moo.Chain);
Moo.Fx.Base.implement(new Moo.Events);
Moo.Fx.Base.implement(new Moo.Options);

/*
Script: Moo.Fx.CSS.js
 Css parsing class for effects. Required by <Moo.Fx.Style>, <Moo.Fx.Styles>, <Moo.Fx.Elements>. No documentation needed, as its used internally.

License:
 MIT-style license.
*/

Moo.Fx.CSS = {

 select: function(property, to){
 if (property.test(/color/i)) return this.Color;
 if (to.contains && to.contains(' ')) return this.Multi;
 return this.Single;
 },

 parse: function(el, property, fromTo){
 if (!fromTo.push) fromTo = [fromTo];
 var from = fromTo[0], to = fromTo[1];
 if (!to && to != 0){
 to = from;
 from = el.getStyle(property);
 }
 var css = this.select(property, to);
 return {from: css.parse(from), to: css.parse(to), css: css};
 }

};

Moo.Fx.CSS.Single = {

 parse: function(value){
 return parseFloat(value);
 },

 getNow: function(from, to, fx){
 return fx.compute(from, to);
 },

 getValue: function(value, unit){
 return value + unit;
 }

};

Moo.Fx.CSS.Multi = {

 parse: function(value){
 return value.push ? value : value.split(' ').map(function(v){
 return parseFloat(v);
 });
 },

 getNow: function(from, to, fx){
 var now = [];
 for (var i = 0; i < from.length; i++) now[i] = fx.compute(from[i], to[i]);
 return now;
 },

 getValue: function(value, unit){
 return value.join(unit + ' ') + unit;
 }

};

Moo.Fx.CSS.Color = {

 parse: function(value){
 return value.push ? value : value.hexToRgb(true);
 },

 getNow: function(from, to, fx){
 var now = [];
 for (var i = 0; i < from.length; i++) now[i] = Math.round(fx.compute(from[i], to[i]));
 return now;
 },

 getValue: function(value){
 return 'rgb(' + value.join(',') + ')';
 }

};

/*
Script: Moo.Fx.Style.js
 Contains <Moo.Fx.Style>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Fx.Style
 The Style effect; Extends <Moo.Fx.Base>, inherits all its properties. Used to transition any css property from one value to another. Includes colors.
 Colors must be in hex format.

Arguments:
 el - the Moo.$(element) to apply the style transition to
 property - the property to transition
 options - the Moo.Fx.Base options (see: <Moo.Fx.Base>)

Example:
 >var marginChange = new Moo.Fx.Style('myElement', 'margin-top', {duration:500});
 >marginChange.start(10, 100);
*/

Moo.Fx.Style = Moo.Fx.Base.extend({

 initialize: function(el, property, options){
 this.element = Moo.$(el);
 this.property = property;
 this.parent(options);
 },

 /*
 Property: hide
 Same as <Moo.Fx.Base.set> (0); hides the element immediately without transition.
 */

 hide: function(){
 return this.set(0);
 },

 setNow: function(){
 this.now = this.css.getNow(this.from, this.to, this);
 },

 /*
 Property: set
 Sets the element's css property (specified at instantiation) to the specified value immediately.

 Example:
 (start code)
 var marginChange = new Moo.Fx.Style('myElement', 'margin-top', {duration:500});
 marginChange.set(10); //margin-top is set to 10px immediately
 (end)
 */

 set: function(to){
 this.css = Moo.Fx.CSS.select(this.property, to);
 return this.parent(this.css.parse(to));
 },

 /*
 Property: start
 Displays the transition to the value/values passed in

 Arguments:
 from - (integer; optional) the starting position for the transition
 to - (integer) the ending position for the transition

 Note:
 If you provide only one argument, the transition will use the current css value for its starting value.

 Example:
 (start code)
 var marginChange = new Moo.Fx.Style('myElement', 'margin-top', {duration:500});
 marginChange.start(10); //tries to read current margin top value and goes from current to 10
 (end)
 */

 start: function(from, to){
 if (this.timer && this.options.wait) return this;
 var parsed = Moo.Fx.CSS.parse(this.element, this.property, [from, to]);
 this.css = parsed.css;
 return this.parent(parsed.from, parsed.to);
 },

 increase: function(){
 this.element.setStyle(this.property, this.css.getValue(this.now, this.options.unit));
 }

});

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 /*
 Property: effect
 Applies an <Moo.Fx.Style> to the Moo.Element; This a shortcut for <Moo.Fx.Style>.
 
 Arguments:
 property - (string) the css property to alter
 options - (object; optional) key/value set of options (see <Moo.Fx.Style>)

 Example:
 >var myEffect = Moo.$('myElement').effect('height', {duration: 1000, transition: Moo.Fx.Transitions.linear});
 >myEffect.start(10, 100);
 >//OR
 >Moo.$('myElement').effect('height', {duration: 1000, transition: Moo.Fx.Transitions.linear}).start(10,100);
 */

 effect: function(property, options){
 return new Moo.Fx.Style(this, property, options);
 }

});

/*
Script: Moo.Fx.Styles.js
 Contains <Moo.Fx.Styles>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Fx.Styles
 Allows you to animate multiple css properties at once; Extends <Moo.Fx.Base>, inherits all its properties. Includes colors.
 Colors must be in hex format.

Arguments:
 el - the Moo.$(element) to apply the styles transition to
 options - the fx options (see: <Moo.Fx.Base>)

Example:
 (start code)
 var myEffects = new Moo.Fx.Styles('myElement', {duration: 1000, transition: Moo.Fx.Transitions.linear});

 //height from 10 to 100 and width from 900 to 300
 myEffects.start({
 'height': [10, 100],
 'width': [900, 300]
 });

 //or height from current height to 100 and width from current width to 300
 myEffects.start({
 'height': 100,
 'width': 300
 });
 (end)
*/

Moo.Fx.Styles = Moo.Fx.Base.extend({

 initialize: function(el, options){
 this.element = Moo.$(el);
 this.parent(options);
 },

 setNow: function(){
 for (var p in this.from) this.now[p] = this.css[p].getNow(this.from[p], this.to[p], this);
 },

 set: function(to){
 var parsed = {};
 this.css = {};
 for (var p in to){
 this.css[p] = Moo.Fx.CSS.select(p, to[p]);
 parsed[p] = this.css[p].parse(to[p]);
 }
 return this.parent(parsed);
 },

 /*
 Property: start
 Executes a transition for any number of css properties in tandem.

 Arguments:
 obj - an object containing keys that specify css properties to alter and values that specify either the from/to values (as an array) or just the end value (an integer).

 Example:
 see <Moo.Fx.Styles>
 */

 start: function(obj){
 if (this.timer && this.options.wait) return this;
 this.now = {};
 this.css = {};
 var from = {}, to = {};
 for (var p in obj){
 var parsed = Moo.Fx.CSS.parse(this.element, p, obj[p]);
 from[p] = parsed.from;
 to[p] = parsed.to;
 this.css[p] = parsed.css;
 }
 return this.parent(from, to);
 },

 increase: function(){
 for (var p in this.now) this.element.setStyle(p, this.css[p].getValue(this.now[p], this.options.unit));
 }

});

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 /*
 Property: effects
 Applies an <Moo.Fx.Styles> to the Moo.Element; This a shortcut for <Moo.Fx.Styles>.

 Example:
 >var myEffects = Moo.$(myElement).effects({duration: 1000, transition: Moo.Fx.Transitions.Sine.easeInOut});
 >myEffects.start({'height': [10, 100], 'width': [900, 300]});
 */

 effects: function(options){
 return new Moo.Fx.Styles(this, options);
 }

});

/*
Script: Moo.Fx.Elements.js
 Contains <Moo.Fx.Elements>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Fx.Elements
 Moo.Fx.Elements allows you to apply any number of styles transitions to a selection of elements. Includes colors (must be in hex format).

Arguments:
 elements - a collection of elements the effects will be applied to.
 options - same as <Moo.Fx.Base> options.
*/

Moo.Fx.Elements = Moo.Fx.Base.extend({

 initialize: function(elements, options){
 this.elements = Moo.$$(elements);
 this.parent(options);
 },

 setNow: function(){
 for (var i in this.from){
 var iFrom = this.from[i], iTo = this.to[i], iCss = this.css[i], iNow = this.now[i] = {};
 for (var p in iFrom) iNow[p] = iCss[p].getNow(iFrom[p], iTo[p], this);
 }
 },

 set: function(to){
 var parsed = {};
 this.css = {};
 for (var i in to){
 var iTo = to[i], iCss = this.css[i] = {}, iParsed = parsed[i] = {};
 for (var p in iTo){
 iCss[p] = Moo.Fx.CSS.select(p, iTo[p]);
 iParsed[p] = iCss[p].parse(iTo[p]);
 }
 }
 return this.parent(parsed);
 },

 /*
 Property: start
 Applies the passed in style transitions to each object named (see example). Each item in the collection is refered to as a numerical string ("1" for instance). The first item is "0", the second "1", etc.

 Example:
 (start code)
 var myElementsEffects = new Moo.Fx.Elements(Moo.$$('a'));
 myElementsEffects.start({
 '0': { //let's change the first element's opacity and width
 'opacity': [0,1],
 'width': [100,200]
 },
 '4': { //and the fifth one's opacity
 'opacity': [0.2, 0.5]
 }
 });
 (end)
 */

 start: function(obj){
 if (this.timer && this.options.wait) return this;
 this.now = {};
 this.css = {};
 var from = {}, to = {};
 for (var i in obj){
 var iProps = obj[i], iFrom = from[i] = {}, iTo = to[i] = {}, iCss = this.css[i] = {};
 for (var p in iProps){
 var parsed = Moo.Fx.CSS.parse(this.elements[i], p, iProps[p]);
 iFrom[p] = parsed.from;
 iTo[p] = parsed.to;
 iCss[p] = parsed.css;
 }
 }
 return this.parent(from, to);
 },

 increase: function(){
 for (var i in this.now){
 var iNow = this.now[i], iCss = this.css[i];
 for (var p in iNow) this.elements[i].setStyle(p, iCss[p].getValue(iNow[p], this.options.unit));
 }
 }

});

/*
Script: Moo.Fx.Scroll.js
 Contains <Moo.Fx.Scroll>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Fx.Scroll
 Scroll any element with an overflow, including the window element.
 
Note:
 Moo.Fx.Scroll requires an XHTML doctype.

Arguments:
 element - the element to scroll
 options - same as <Moo.Fx.Base> options.
*/

Moo.Fx.Scroll = Moo.Fx.Base.extend({

 initialize: function(element, options){
 this.now = [];
 this.element = Moo.$(element);
 this.addEvent('onStart', function(){
 this.element.addEvent('mousewheel', this.stop.bind(this, false));
 }.bind(this));
 this.removeEvent('onComplete', function(){
 this.element.removeEvent('mousewheel', this.stop.bind(this, false));
 }.bind(this));
 this.parent(options);
 },

 setNow: function(){
 for (var i = 0; i < 2; i++) this.now[i] = this.compute(this.from[i], this.to[i]);
 },

 /*
 Property: scrollTo
 Scrolls the chosen element to the x/y coordinates.

 Arguments:
 x - the x coordinate to scroll the element to
 y - the y coordinate to scroll the element to
 */

 scrollTo: function(x, y){
 if (this.timer && this.options.wait) return this;
 var el = this.element.getSize();
 var values = {'x': x, 'y': y};
 for (var z in el.size){
 var max = el.scrollSize[z] - el.size[z];
 if (Moo.$chk(values[z])) values[z] = (Moo.$type(values[z]) == 'number') ? Math.max(Math.min(values[z], max), 0) : max;
 else values[z] = el.scroll[z];
 }
 return this.start([el.scroll.x, el.scroll.y], [values.x, values.y]);
 },

 /*
 Property: toTop
 Scrolls the chosen element to its maximum top.
 */

 toTop: function(){
 return this.scrollTo(false, 0);
 },

 /*
 Property: toBottom
 Scrolls the chosen element to its maximum bottom.
 */

 toBottom: function(){
 return this.scrollTo(false, 'full');
 },

 /*
 Property: toLeft
 Scrolls the chosen element to its maximum left.
 */

 toLeft: function(){
 return this.scrollTo(0, false);
 },

 /*
 Property: toRight
 Scrolls the chosen element to its maximum right.
 */

 toRight: function(){
 return this.scrollTo('full', false);
 },

 /*
 Property: toElement
 Scrolls the specified element to the position the passed in element is found.

 Arguments:
 el - the Moo.$(element) to scroll the window to
 */

 toElement: function(el){
 var parent = this.element.getPosition();
 var target = Moo.$(el).getPosition();
 return this.scrollTo(target.x - parent.x, target.y - parent.y);
 },

 increase: function(){
 this.element.scrollTo(this.now[0], this.now[1]);
 }

});

/*
Script: Moo.Fx.Slide.js
 Contains <Moo.Fx.Slide>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Fx.Slide
 The slide effect; slides an element in horizontally or vertically, the contents will fold inside. Extends <Moo.Fx.Base>, inherits all its properties.
 
Note:
 Moo.Fx.Slide requires an XHTML doctype.

Moo.Options:
 mode - set it to vertical or horizontal. Defaults to vertical.
 options - all the <Moo.Fx.Base> options

Example:
 (start code)
 var mySlider = new Moo.Fx.Slide('myElement', {duration: 500});
 mySlider.toggle() //toggle the slider up and down.
 (end)
*/

Moo.Fx.Slide = Moo.Fx.Base.extend({

 options: {
 mode: 'vertical'
 },

 initialize: function(el, options){
 this.element = Moo.$(el);
 this.wrapper = new Moo.Element('div', {'styles': Moo.$extend(this.element.getStyles('margin'), {'overflow': 'hidden'})}).injectAfter(this.element).adopt(this.element);
 this.element.setStyle('margin', 0);
 this.setOptions(options);
 this.now = [];
 this.parent(this.options);
 },

 setNow: function(){
 for (var i = 0; i < 2; i++) this.now[i] = this.compute(this.from[i], this.to[i]);
 },

 vertical: function(){
 this.margin = 'margin-top';
 this.layout = 'height';
 this.offset = this.element.offsetHeight;
 },

 horizontal: function(){
 this.margin = 'margin-left';
 this.layout = 'width';
 this.offset = this.element.offsetWidth;
 },

 /*
 Property: slideIn
 Slides the elements in view horizontally or vertically.

 Arguments:
 mode - (optional, string) 'horizontal' or 'vertical'; defaults to options.mode.
 */

 slideIn: function(mode){
 this[mode || this.options.mode]();
 return this.start([this.element.getStyle(this.margin).toInt(), this.wrapper.getStyle(this.layout).toInt()], [0, this.offset]);
 },

 /*
 Property: slideOut
 Sides the elements out of view horizontally or vertically.

 Arguments:
 mode - (optional, string) 'horizontal' or 'vertical'; defaults to options.mode.
 */

 slideOut: function(mode){
 this[mode || this.options.mode]();
 return this.start([this.element.getStyle(this.margin).toInt(), this.wrapper.getStyle(this.layout).toInt()], [-this.offset, 0]);
 },

 /*
 Property: hide
 Hides the element without a transition.

 Arguments:
 mode - (optional, string) 'horizontal' or 'vertical'; defaults to options.mode.
 */

 hide: function(mode){
 this[mode || this.options.mode]();
 return this.set([-this.offset, 0]);
 },

 /*
 Property: show
 Shows the element without a transition.

 Arguments:
 mode - (optional, string) 'horizontal' or 'vertical'; defaults to options.mode.
 */

 show: function(mode){
 this[mode || this.options.mode]();
 return this.set([0, this.offset]);
 },

 /*
 Property: toggle
 Slides in or Out the element, depending on its state

 Arguments:
 mode - (optional, string) 'horizontal' or 'vertical'; defaults to options.mode.

 */

 toggle: function(mode){
 if (this.wrapper.offsetHeight == 0 || this.wrapper.offsetWidth == 0) return this.slideIn(mode);
 return this.slideOut(mode);
 },

 increase: function(){
 this.element.setStyle(this.margin, this.now[0] + this.options.unit);
 this.wrapper.setStyle(this.layout, this.now[1] + this.options.unit);
 }

});

/*
Script: Moo.Fx.Transitions.js
 Effects transitions, to be used with all the effects.

Author:
 Easing Equations by Robert Penner, <http://www.robertpenner.com/easing/>, modified & optimized to be used with mootools.

License:
 Easing Equations v1.5, (c) 2003 Robert Penner, all rights reserved. Open Source BSD License.
*/

/*
Moo.Class: Moo.Fx.Transitions
 A collection of tweening transitions for use with the <Moo.Fx.Base> classes.
 Some transitions accept additional parameters. You can set them using the .set property of each transition type.
 
Example:
 >new Moo.Fx.Style('margin', {transition: Moo.Fx.Transitions.Elastic.easeInOut});
 >//Elastic.easeInOut with default values
 >new Moo.Fx.Style('margin', {transition: Moo.Fx.Transitions.Elastic.easeInOut.set(3)});
 >//Elastic.easeInOut with user-defined value for elasticity.
 >p, t, c, d means: // p: current time / duration, t: current time, c: change in value (distance), d: duration

See also:
 http://www.robertpenner.com/easing/
*/

Moo.Fx.Transitions = new Moo.Abstract({
 
 /*
 Property: linear
 displays a linear transition.
 
 Graph:
 (see Linear.png)
 */
 
 linear: function(t, c, d){
 return c * (t / d);
 }

});

Moo.Fx.Shared.CreateTransitionEases = function(transition, type){
 Moo.$extend(transition, {
 easeIn: function(t, c, d, x, y, z){
 return c - c * transition((d - t) / d, t, c, d, x, y, z);
 },

 easeOut: function(t, c, d, x, y, z){
 return c * transition(t / d, t, c, d, x, y, z);
 },

 easeInOut: function(t, c, d, x, y, z){
 d /= 2, c /= 2;
 var p = t / d;
 return (p < 1) ? transition.easeIn(t, c, d, x, y, z) : c * (transition(p - 1, t, c, d, x, y, z) + 1);
 }
 });
 //compatibility
 ['In', 'Out', 'InOut'].each(function(mode){
 transition['ease' + mode].set = Moo.Fx.Shared.SetTransitionValues(transition['ease' + mode]);
 Moo.Fx.Transitions[type.toLowerCase() + mode] = transition['ease' + mode];
 });
};

Moo.Fx.Shared.SetTransitionValues = function(transition){
 return function(){
 var args = Moo.$A(arguments);
 return function(){
 return transition.apply(Moo.Fx.Transitions, Moo.$A(arguments).concat(args));
 };
 }
};

Moo.Fx.Transitions.extend = function(transitions){
 for (var type in transitions){
 if (type.test(/^[A-Z]/)) Moo.Fx.Shared.CreateTransitionEases(transitions[type], type);
 else transitions[type].set = Moo.Fx.Shared.SetTransitionValues(transitions[type]);
 Moo.Fx.Transitions[type] = transitions[type];
 }
};

Moo.Fx.Transitions.extend({
 
 /*
 Property: Sine
 displays a sineousidal transition. Must be used as Sine.easeIn or Sine.easeOut or Sine.easeInOut
 
 Graph:
 (see Sine.png)
 */

 Sine: function(p){
 return Math.sin(p * (Math.PI / 2));
 },
 
 /*
 Property: Quad
 displays a quadratic transition. Must be used as Quad.easeIn or Quad.easeOut or Quad.easeInOut
 
 Graph:
 (see Quad.png)
 */

 Quad: function(p){
 return -(Math.pow(p - 1, 2) - 1);
 },
 
 /*
 Property: Cubic
 displays a cubicular transition. Must be used as Cubic.easeIn or Cubic.easeOut or Cubic.easeInOut
 
 Graph:
 (see Cubic.png)
 */

 Cubic: function(p){
 return Math.pow(p - 1, 3) + 1;
 },
 
 /*
 Property: Quart
 displays a quartetic transition. Must be used as Quart.easeIn or Quart.easeOut or Quart.easeInOut
 
 Graph:
 (see Quart.png)
 */

 Quart: function(p){
 return -(Math.pow(p - 1, 4) - 1);
 },
 
 /*
 Property: Quint
 displays a quintic transition. Must be used as Quint.easeIn or Quint.easeOut or Quint.easeInOut
 
 Graph:
 (see Quint.png)
 */

 Quint: function(p){
 return Math.pow(p - 1, 5) + 1;
 },
 
 /*
 Property: Expo
 displays a exponential transition. Must be used as Expo.easeIn or Expo.easeOut or Expo.easeInOut
 
 Graph:
 (see Expo.png)
 */

 Expo: function(p){
 return -Math.pow(2, -10 * p) + 1;
 },
 
 /*
 Property: Circ
 displays a circular transition. Must be used as Circ.easeIn or Circ.easeOut or Circ.easeInOut
 
 Graph:
 (see Circ.png)
 */

 Circ: function(p){
 return Math.sqrt(1 - Math.pow(p - 1, 2));
 },
 
 /*
 Property: Bounce
 makes the transition bouncy. Must be used as Bounce.easeIn or Bounce.easeOut or Bounce.easeInOut
 
 
 Graph:
 (see Bounce.png)
 */

 Bounce: function(p){
 var b = 7.5625;
 if (p < (1 / 2.75)) return b * Math.pow(p, 2);
 else if (p < (2 / 2.75)) return b * (p -= (1.5 / 2.75)) * p + 0.75;
 else if (p < (2.5 / 2.75)) return b * (p -= (2.25 / 2.75)) * p + 0.9375;
 else return b * (p -= (2.625 / 2.75)) * p + 0.984375;
 },
 
 /*
 Property: Back
 makes the transition go back, then all forth. Must be used as Back.easeIn or Back.easeOut or Back.easeInOut
 set() changes the way it overshoots the target, default is 1.70158

 Graph:
 (see Back.png)
 */

 Back: function(p, t, c, d, x){
 x = x || 1.70158;
 p -= 1;
 return Math.pow(p, 2) * ((x + 1) * p + x) + 1;
 },
 
 /*
 Property: Elastic
 Elastic curve. Must be used as Elastic.easeIn or Elastic.easeOut or Elastic.easeInOut
 set() works as a multiplier of the elasicity effect. set(2) makes it twice as strong
 
 Graph:
 (see Elastic.png)
 */

 Elastic: function(p, t, c, d, x){
 x = d * 0.3 / (x || 1);
 return (c * Math.pow(2, -10 * p) * Math.sin((p * d - x / 4) * (2 * Math.PI) / x) + c) / c;
 }

});

/*
Script: Moo.Drag.Base.js
 Contains <Moo.Drag.Base>, <Moo.Element.makeResizable>

License:
 MIT-style license.
*/

Moo.Drag = {};

/*
Moo.Class: Moo.Drag.Base
 Modify two css properties of an element based on the position of the mouse.
 
Note:
 Moo.Drag.Base requires an XHTML doctype.

Arguments:
 el - the Moo.$(element) to apply the transformations to.
 options - optional. The options object.

Moo.Options:
 handle - the Moo.$(element) to act as the handle for the draggable element. defaults to the Moo.$(element) itself.
 modifiers - an object. see Modifiers Below.
 onStart - optional, function to execute when the user starts to drag (on mousedown);
 onComplete - optional, function to execute when the user completes the drag.
 onDrag - optional, function to execute at every step of the drag
 limit - an object, see Limit below.
 grid - optional, distance in px for snap-to-grid dragging
 snap - optional, the distance you have to drag before the element starts to respond to the drag. defaults to false

 modifiers:
 x - string, the style you want to modify when the mouse moves in an horizontal direction. defaults to 'left'
 y - string, the style you want to modify when the mouse moves in a vertical direction. defaults to 'top'

 limit:
 x - array with start and end limit relative to modifiers.x
 y - array with start and end limit relative to modifiers.y
*/

Moo.Drag.Base = new Moo.Class({

 options: {
 handle: false,
 unit: 'px',
 onStart: Moo.Class.empty,
 onBeforeStart: Moo.Class.empty,
 onComplete: Moo.Class.empty,
 onSnap: Moo.Class.empty,
 onDrag: Moo.Class.empty,
 limit: false,
 modifiers: {x: 'left', y: 'top'},
 grid: false,
 snap: 6
 },

 initialize: function(el, options){
 this.setOptions(options);
 this.element = Moo.$(el);
 this.handle = Moo.$(this.options.handle) || this.element;
 this.mouse = {'now': {}, 'pos': {}};
 this.value = {'start': {}, 'now': {}};
 this.bound = {
 'start': this.start.bindWithEvent(this),
 'check': this.check.bindWithEvent(this),
 'drag': this.drag.bindWithEvent(this),
 'stop': this.stop.bind(this)
 };
 this.attach();
 if (this.options.initialize) this.options.initialize.call(this);
 },

 attach: function(){
 this.handle.addEvent('mousedown', this.bound.start);
 return this;
 },

 detach: function(){
 this.handle.removeEvent('mousedown', this.bound.start);
 return this;
 },

 start: function(event){
 this.fireEvent('onBeforeStart', this.element);
 this.mouse.start = event.page;
 var limit = this.options.limit;
 this.limit = {'x': [], 'y': []};
 for (var z in this.options.modifiers){
 if (!this.options.modifiers[z]) continue;
 this.value.now[z] = this.element.getStyle(this.options.modifiers[z]).toInt();
 this.mouse.pos[z] = event.page[z] - this.value.now[z];
 if (limit && limit[z]){
 for (var i = 0; i < 2; i++){
 if (Moo.$chk(limit[z][i])) this.limit[z][i] = limit[z][i].apply ? limit[z][i].call(this) : limit[z][i];
 }
 }
 }
 if (Moo.$type(this.options.grid) == 'number') this.options.grid = {'x': this.options.grid, 'y': this.options.grid};
 document.addListener('mousemove', this.bound.check);
 document.addListener('mouseup', this.bound.stop);
 this.fireEvent('onStart', this.element);
 event.stop();
 },

 check: function(event){
 var distance = Math.round(Math.sqrt(Math.pow(event.page.x - this.mouse.start.x, 2) + Math.pow(event.page.y - this.mouse.start.y, 2)));
 if (distance > this.options.snap){
 document.removeListener('mousemove', this.bound.check);
 document.addListener('mousemove', this.bound.drag);
 this.drag(event);
 this.fireEvent('onSnap', this.element);
 }
 event.stop();
 },

 drag: function(event){
 this.out = false;
 this.mouse.now = event.page;
 for (var z in this.options.modifiers){
 if (!this.options.modifiers[z]) continue;
 this.value.now[z] = this.mouse.now[z] - this.mouse.pos[z];
 if (this.limit[z]){
 if (Moo.$chk(this.limit[z][1]) && (this.value.now[z] > this.limit[z][1])){
 this.value.now[z] = this.limit[z][1];
 this.out = true;
 } else if (Moo.$chk(this.limit[z][0]) && (this.value.now[z] < this.limit[z][0])){
 this.value.now[z] = this.limit[z][0];
 this.out = true;
 }
 }
 if (this.options.grid[z]) this.value.now[z] -= (this.value.now[z] % this.options.grid[z]);
 this.element.setStyle(this.options.modifiers[z], this.value.now[z] + this.options.unit);
 }
 this.fireEvent('onDrag', this.element);
 event.stop();
 },

 stop: function(){
 document.removeListener('mousemove', this.bound.check);
 document.removeListener('mousemove', this.bound.drag);
 document.removeListener('mouseup', this.bound.stop);
 this.fireEvent('onComplete', this.element);
 }

});

Moo.Drag.Base.implement(new Moo.Events);
Moo.Drag.Base.implement(new Moo.Options);

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 /*
 Property: makeResizable
 Makes an element resizable (by dragging) with the supplied options.

 Arguments:
 options - see <Moo.Drag.Base> for acceptable options.
 */

 makeResizable: function(options){
 return new Moo.Drag.Base(this, Moo.$merge({modifiers: {x: 'width', y: 'height'}}, options));
 }

});

/*
Script: Moo.Drag.Move.js
 Contains <Moo.Drag.Move>, <Moo.Element.makeDraggable>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Drag.Move
 Extends <Moo.Drag.Base>, has additional functionality for dragging an element, support snapping and droppables.
 Moo.Drag.move supports either position absolute or relative. If no position is found, absolute will be set.
 
Note:
 Moo.Drag.Move requires an XHTML doctype.

Arguments:
 el - the Moo.$(element) to apply the drag to.
 options - optional. see Moo.Options below.

Moo.Options:
 all the drag.Base options, plus:
 container - an element, will fill automatically limiting options based on the Moo.$(element) size and position. defaults to false (no limiting)
 droppables - an array of elements you can drop your draggable to.
*/

Moo.Drag.Move = Moo.Drag.Base.extend({

 options: {
 droppables: [],
 container: false,
 overflown: []
 },

 initialize: function(el, options){
 this.setOptions(options);
 this.element = Moo.$(el);
 this.position = this.element.getStyle('position');
 this.droppables = Moo.$$(this.options.droppables);
 if (!['absolute', 'relative'].contains(this.position)) this.position = 'absolute';
 var top = this.element.getStyle('top').toInt();
 var left = this.element.getStyle('left').toInt();
 if (this.position == 'absolute'){
 top = Moo.$chk(top) ? top : this.element.getTop();
 left = Moo.$chk(left) ? left : this.element.getLeft();
 } else {
 top = Moo.$chk(top) ? top : 0;
 left = Moo.$chk(left) ? left : 0;
 }
 this.element.setStyles({
 'top': top,
 'left': left,
 'position': this.position
 });
 this.parent(this.element, this.options);
 },

 start: function(event){
 this.container = Moo.$(this.options.container);
 if (this.container){
 var cont = this.container.getCoordinates();
 var el = this.element.getCoordinates();
 if (this.position == 'absolute'){
 this.options.limit = {
 'x': [cont.left, cont.right - el.width],
 'y': [cont.top, cont.bottom - el.height]
 };
 } else {
 var diffx = el.left - this.element.getStyle('left').toInt();
 var diffy = el.top - this.element.getStyle('top').toInt();
 this.options.limit = {
 'y': [-(diffy) + cont.top, cont.bottom - diffy - el.height],
 'x': [-(diffx) + cont.left, cont.right - diffx - el.width]
 };
 }
 }
 this.parent(event);
 },

 drag: function(event){
 this.parent(event);
 if (this.out) return this;
 this.droppables.each(function(drop){
 if (this.checkAgainst(Moo.$(drop))){
 if (!drop.overing) drop.fireEvent('over', [this.element, this]);
 drop.overing = true;
 } else {
 if (drop.overing) drop.fireEvent('leave', [this.element, this]);
 drop.overing = false;
 }
 }, this);
 return this;
 },

 checkAgainst: function(el){
 el = el.getCoordinates(this.options.overflown);
 return (this.mouse.now.x > el.left && this.mouse.now.x < el.right && this.mouse.now.y < el.bottom && this.mouse.now.y > el.top);
 },

 stop: function(){
 if (!this.out){
 var dropped = false;
 this.droppables.each(function(drop){
 if (this.checkAgainst(drop)){
 drop.fireEvent('drop', [this.element, this]);
 dropped = true;
 }
 }, this);
 if (!dropped) this.element.fireEvent('emptydrop', this);
 }
 this.parent();
 return this;
 }

});

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 /*
 Property: makeDraggable
 Makes an element draggable with the supplied options.

 Arguments:
 options - see <Moo.Drag.Move> and <Moo.Drag.Base> for acceptable options.
 */

 makeDraggable: function(options){
 return new Moo.Drag.Move(this, options);
 }

});

/*
Script: Moo.XHR.js
 Contains the basic XMLHttpRequest Moo.Class Wrapper.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.XHR
 Basic XMLHttpRequest Wrapper.

Arguments:
 options - an object with options names as keys. See options below.

Moo.Options:
 method - 'post' or 'get' - the protocol for the request; optional, defaults to 'post'.
 async - boolean: asynchronous option; true uses asynchronous requests. Defaults to true.
 onRequest - function to execute when the Moo.XHR request is fired.
 onSuccess - function to execute when the Moo.XHR request completes.
 onStateChange - function to execute when the state of the XMLHttpRequest changes.
 onFailure - function to execute when the state of the XMLHttpRequest changes.
 encoding - the encoding, defaults to utf-8.
 autoCancel - cancels the already running request if another one is sent. defaults to false.
 headers - accepts an object, that will be set to request headers.

Properties:
 running - true if the request is running.
 response - object, text and xml as keys. You can access this property in the onSuccess event.

Example:
 >var myXHR = new Moo.XHR({method: 'get'}).send('http://site.com/requestHandler.php', 'name=john&lastname=dorian');
*/

Moo.XHR = new Moo.Class({

 options: {
 method: 'post',
 async: true,
 onRequest: Moo.Class.empty,
 onSuccess: Moo.Class.empty,
 onFailure: Moo.Class.empty,
 urlEncoded: true,
 encoding: 'utf-8',
 autoCancel: false,
 headers: {}
 },

 initialize: function(options){
 this.transport = (window.XMLHttpRequest) ? new XMLHttpRequest() : (window.ie ? new ActiveXObject('Microsoft.XMLHTTP') : false);
 if (!this.transport) return;
 this.setOptions(options);
 this.options.isSuccess = this.options.isSuccess || this.isSuccess;
 this.headers = {};
 if (this.options.urlEncoded && this.options.method == 'post'){
 var encoding = (this.options.encoding) ? '; charset=' + this.options.encoding : '';
 this.setHeader('Content-type', 'application/x-www-form-urlencoded' + encoding);
 }
 if (this.options.initialize) this.options.initialize.call(this);
 },

 onStateChange: function(){
 if (this.transport.readyState != 4 || !this.running) return;
 this.running = false;
 var status = 0;
 try {status = this.transport.status} catch(e){};
 if (this.options.isSuccess.call(this, status)) this.onSuccess();
 else this.onFailure();
 this.transport.onreadystatechange = Moo.Class.empty;
 },

 isSuccess: function(status){
 return ((status >= 200) && (status < 300));
 },

 onSuccess: function(){
 this.response = {
 'text': this.transport.responseText,
 'xml': this.transport.responseXML
 };
 this.fireEvent('onSuccess', [this.response.text, this.response.xml]);
 this.callChain();
 },

 onFailure: function(){
 this.fireEvent('onFailure', this.transport);
 },

 /*
 Property: setHeader
 Add/modify an header for the request. It will not override headers from the options.

 Example:
 >var myAjax = new Moo.Ajax(url, {method: 'get', headers: {'X-Request': 'JSON'}});
 >myAjax.setHeader('Last-Modified','Sat, 1 Jan 2005 05:00:00 GMT');
 */

 setHeader: function(name, value){
 this.headers[name] = value;
 return this;
 },

 /*
 Property: send
 Opens the xhr connection and sends the data. Data has to be null or a string.

 Example:
 >var myXhr = new Xhr({method: 'post'});
 >myXhr.send(url, querystring);
 >
 >var syncXhr = new Xhr({async: false, method: 'post'});
 >syncXhr.send(url, null);
 >
 */

 send: function(url, data){
 if (this.options.autoCancel) this.cancel();
 else if (this.running) return this;
 this.running = true;
 if (data && this.options.method == 'get') url = url + (url.contains('?') ? '&' : '?') + data, data = null;
 (function(){
 this.transport.open(this.options.method, url, this.options.async);
 this.transport.onreadystatechange = this.onStateChange.bind(this);
 if ((this.options.method == 'post') && this.transport.overrideMimeType) this.setHeader('Connection', 'close');
 Moo.$extend(this.headers, this.options.headers);
 for (var type in this.headers) try {this.transport.setRequestHeader(type, this.headers[type]);} catch(e){};
 this.fireEvent('onRequest');
 this.transport.send(Moo.$pick(data, null));
 }).delay(this.options.async ? 1 : false, this);
 return this;
 },

 /*
 Property: cancel
 Cancels the running request. No effect if the request is not running.

 Example:
 >var myAjax = new Moo.Ajax(url, {method: 'get'}).request();
 >myAjax.cancel();
 */

 cancel: function(){
 if (!this.running) return this;
 this.running = false;
 this.transport.abort();
 this.transport.onreadystatechange = Moo.Class.empty;
 this.fireEvent('onCancel');
 return this;
 }

});

Moo.XHR.implement(new Moo.Chain);
Moo.XHR.implement(new Moo.Events);
Moo.XHR.implement(new Moo.Options);

/*
Script: Moo.Ajax.js
 Contains the <Moo.Ajax> class. Also contains methods to generate querystings from forms and Objects.

Credits:
 Loosely based on the version from prototype.js <http://prototype.conio.net>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Ajax
 An Moo.Ajax class, For all your asynchronous needs. Inherits methods, properties and options from <Moo.XHR>.

Arguments:
 url - the url pointing to the server-side script.
 options - optional, an object containing options.

Moo.Options:
 data - you can write parameters here. Can be a querystring, an object or a Form element.
 onComplete - function to execute when the ajax request completes.
 update - Moo.$(element) to insert the response text of the Moo.XHR into, upon completion of the request.
 evalScripts - boolean; default is false. Execute scripts in the response text onComplete. When the response is javascript the whole response is evaluated.
 evalResponse - boolean; default is false. Force global evalulation of the whole response, no matter what content-type it is.

Example:
 >var myAjax = new Moo.Ajax(url, {method: 'get'}).request();
*/

Moo.Ajax = Moo.XHR.extend({

 options: {
 data: null,
 update: null,
 onComplete: Moo.Class.empty,
 evalScripts: false,
 evalResponse: false
 },

 initialize: function(url, options){
 this.addEvent('onSuccess', this.onComplete);
 this.setOptions(options);
 this.options.data = this.options.data || this.options.postBody;
 if (!['post', 'get'].contains(this.options.method)){
 this._method = '_method=' + this.options.method;
 this.options.method = 'post';
 }
 this.parent(this.options);
 this.setHeader('X-Requested-With', 'XMLHttpRequest');
 this.setHeader('Accept', 'text/javascript, text/html, application/xml, text/xml, */*');
 this.url = url;
 },

 onComplete: function(){
 if (this.options.update) Moo.$(this.options.update).setHTML(this.response.text);
 if (this.options.evalScripts || this.options.evalResponse) this.evalScripts();
 this.fireEvent('onComplete', [this.response.text, this.response.xml], 20);
 },

 /*
 Property: request
 Executes the ajax request.

 Example:
 >var myAjax = new Moo.Ajax(url, {method: 'get'});
 >myAjax.request();

 OR

 >new Moo.Ajax(url, {method: 'get'}).request();
 */

 request: function(data){
 data = data || this.options.data;
 switch(Moo.$type(data)){
 case 'element': data = Moo.$(data).toQueryString(); break;
 case 'object': data = Object.toQueryString(data);
 }
 if (this._method) data = (data) ? [this._method, data].join('&') : this._method;
 return this.send(this.url, data);
 },

 /*
 Property: evalScripts
 Executes scripts in the response text
 */

 evalScripts: function(){
 if (this.options.evalResponse || /(ecma|java)script/.test(this.getHeader('Content-type'))) var scripts = this.response.text;
 else {
 var script, scripts = [], regexp = /<script[^>]*>([\s\S]*?)<\/script>/gi;
 while ((script = regexp.exec(this.response.text))) scripts.push(script[1]);
 scripts = scripts.join('\n');
 }
 if (scripts) (window.execScript) ? window.execScript(scripts) : window.setTimeout(scripts, 0);
 },

 /*
 Property: getHeader
 Returns the given response header or null
 */

 getHeader: function(name) {
 try {return this.transport.getResponseHeader(name);} catch(e){};
 return null;
 }

});

/* Section: Object related Functions */

/*
Function: Object.toQueryString
 Generates a querystring from key/pair values in an object

Arguments:
 source - the object to generate the querystring from.

Returns:
 the query string.

Example:
 >Object.toQueryString({apple: "red", lemon: "yellow"}); //returns "apple=red&lemon=yellow"
*/

Object.toQueryString = function(source){
 var queryString = [];
 for (var property in source) queryString.push(encodeURIComponent(property) + '=' + encodeURIComponent(source[property]));
 return queryString.join('&');
};

/*
Moo.Class: Moo.Element
 Custom class to allow all of its methods to be used with any DOM element via the dollar function <Moo.$>.
*/

Moo.Element.extend({

 /*
 Property: send
 Sends a form with an ajax post request

 Arguments:
 options - option collection for ajax request. See <Moo.Ajax> for the options list.

 Returns:
 The Moo.Ajax Moo.Class Instance

 Example:
 (start code)
 <form id="myForm" action="submit.php">
 <input name="email" value="bob@bob.com">
 <input name="zipCode" value="90210">
 </form>
 <script>
 Moo.$('myForm').send()
 </script>
 (end)
 */

 send: function(options){
 return new Moo.Ajax(this.getProperty('action'), Moo.$merge({postBody: this.toQueryString()}, options, {method: 'post'})).request();
 }

});

/*
Script: Moo.Cookie.js
 A cookie reader/creator

Credits:
 based on the functions by Peter-Paul Koch (http://quirksmode.org)
*/

/*
Moo.Class: Moo.Cookie
 Moo.Class for creating, getting, and removing cookies.
*/

Moo.Cookie = new Moo.Abstract({

 options: {
 domain: false,
 path: false,
 duration: false,
 secure: false
 },

 /*
 Property: set
 Sets a cookie in the browser.

 Arguments:
 key - the key (name) for the cookie
 value - the value to set, cannot contain semicolons
 options - an object representing the Moo.Cookie options. See Moo.Options below. Default values are stored in Moo.Cookie.options.

 Moo.Options:
 domain - the domain the Moo.Cookie belongs to. If you want to share the cookie with pages located on a different domain, you have to set this value. Defaults to the current domain.
 path - the path the Moo.Cookie belongs to. If you want to share the cookie with pages located in a different path, you have to set this value, for example to "/" to share the cookie with all pages on the domain. Defaults to the current path.
 duration - the duration of the Moo.Cookie before it expires, in seconds.
 If set to false or 0, the cookie will be a session cookie that expires when the browser is closed. This is default.
 secure - Stored cookie information can be accessed only from a secure environment.

 Example:
 >Moo.Cookie.set("username", "Harald", {duration: 3600}); //save this for 1 hour
 >Moo.Cookie.set("username", "JackBauer", {duration: false}); //session cookie

 */

 set: function(key, value, options){
 options = Moo.$merge(this.options, options);
 value = encodeURIComponent(value);
 if (options.domain) value += '; domain=' + options.domain;
 if (options.path) value += '; path=' + options.path;
 if (options.duration){
 var date = new Date();
 date.setTime(date.getTime() + options.duration * 1000);
 value += '; expires=' + date.toGMTString();
 }
 if (options.secure) value += '; secure';
 document.cookie = key + '=' + value;
 return Moo.$extend(options, {'key': key, 'value': value});
 },

 /*
 Property: get
 Gets the value of a cookie.

 Arguments:
 key - the name of the cookie you wish to retrieve.

 Returns:
 The cookie string value, or false if not found.

 Example:
 >Moo.Cookie.get("username") //returns Aaron
 */

 get: function(key){
 var value = document.cookie.match('(?:^|;)\\s*' + key.escapeRegExp() + '=([^;]*)');
 return value ? decodeURIComponent(value[1]) : false;
 },

 /*
 Property: remove
 Removes a cookie from the browser.

 Arguments:
 cookie - the name of the cookie to remove or a previous cookie (for domains)
 options - optional. you can also pass the domain and path here. Same as options in <Moo.Cookie.set>

 Examples:
 >Moo.Cookie.remove("username") //bye-bye Aaron
 >var myCookie = Moo.Cookie.set('user', 'jackbauer', {domain: 'mootools.net'});
 >Moo.Cookie.remove(myCookie);
 */

 remove: function(cookie, options){
 if (Moo.$type(cookie) == 'object') this.set(cookie.key, '', Moo.$merge(cookie, {duration: -1}));
 else this.set(cookie, '', Moo.$merge(options, {duration: -1}));
 }

});

/* 
Script: Moo.Cookie.Json.js
 A cookie reader/creator that allows for the storage and retrieval of JSON data and collections of items.

Credits:
 based on the CookieJar class by Lalit Patel (http://www.lalit.org/lab/jsoncookies)
*/
 
/*
Moo.Class: Moo.Cookie.Json
 Stores an object as a cookie using json format.
 
Arguments:
 name - (string) a unique name for all the items in this jar; required.
 options - an object with options names as keys. See options below.

Moo.Options:
 These options are identical to <Moo.Cookie> and are simply passed along to it.
 
 domain - the domain the Moo.Cookie belongs to. If you want to share the cookie with pages located on a different domain, you have to set this value. Defaults to the current domain.
 path - the path the Moo.Cookie belongs to. If you want to share the cookie with pages located in a different path, you have to set this value, for example to "/" to share the cookie with all pages on the domain. Defaults to the current path.
 duration - the duration of the Moo.Cookie before it expires, in seconds. If set to false or 0, the cookie will be a session cookie that expires when the browser is closed. This is default.
 secure - Stored cookie information can be accessed only from a secure environment.

Example:
 (start code)
 var cookieJar = new Moo.Cookie.Json('myCookieName');
 var myObject = {
 lemon: 'yellow',
 apple: 'red'
 }
 cookieJar.put('myObject', myObject);
 cookieJar.get('lemon'); //returns yellow
 
 var myOtherObject = {
 apple: {
 sour: 'green',
 sweet: 'red'
 }
 lime: 'green',
 grape: 'purple'
 }
 cookieJar.merge(myOtherObject);
 cookieJar.get('apple').sour; //returns green
 (end)
*/

Moo.Cookie.Json = new Moo.Class({

 initialize: function(name, options){
 this.name = name;
 this.options = options;
 return;
 },

 /* 
 Property: set
 Puts an item into the collection (and stores it as a cookie with the name prefix).

 Arguments: 
 key - (string) the name of the item
 value - (object) the object to store (can be a string, number, object, etc.)
 */

 set: function(key, value){
 var object = this.get() || {};
 object[key] = value;
 this.save(object);
 return this;
 },
 
 /* 
 Property: save
 Saves an object for the entire value of this Moo.Json.Cookie, overwriting any previous data.

 Arguments: 
 object - the value to save
 */

 save: function(object){
 object = Moo.Json.toString(object);
 if (object.length > 4096) return false; //cookie would be truncated!
 Moo.Cookie.set(this.name, object, this.options);
 return this;
 },

 /* 
 Property: remove
 Removes an item from the collection.

 Arguments: 
 key - (string) the name of the item
 */

 remove: function(key){
 var object = this.get();
 delete object[key];
 this.save(object);
 return this;
 },

 /* 
 Property: get
 Returns the value of an item in the collection, or the entire collection.
 
 Arguments:
 key - (string) the name of the item; if not provided, the entire object is returned.
 */

 get: function(key){
 var value = Moo.Cookie.get(this.name);
 if(value && !value.test(/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/)) {
 var object = Moo.Json.evaluate(value);
 return (key) ? object[key] : object;
 } else return false;
 },

 /*
 Property: empty
 Removes the cookie.
 */

 empty: function(){
 this.save(null);
 },

 /*
 Property: merge
 Merges an object with the values in the cookie, *overwritting the cookie* values where namespaces overlap.
 */
 
 merge: function(obj){
 this.save(Moo.$merge(this.get(), obj));
 },

 /*
 Property: fill
 Merges an object with the values in the cookie, *overwritting the passed in values* where namespaces overlap.
 */
 
 fill: function(obj){
 this.save(Moo.$merge(obj, this.get()));
 }

});

/*
Script: Moo.Json.js
 Simple Moo.Json parser and Stringyfier, See: <http://www.json.org/>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Json
 Simple Moo.Json parser and Stringyfier, See: <http://www.json.org/>
*/

Moo.Json = {

 /*
 Property: toString
 Converts an object to a string, to be passed in server-side scripts as a parameter. Although its not normal usage for this class, this method can also be used to convert functions and arrays to strings.

 Arguments:
 obj - the object to convert to string

 Returns:
 A json string

 Example:
 (start code)
 Moo.Json.toString({apple: 'red', lemon: 'yellow'}); '{"apple":"red","lemon":"yellow"}'
 (end)
 */

 toString: function(obj){
 switch(Moo.$type(obj)){
 case 'string':
 return '"' + obj.replace(/(["\\])/g, '\\Moo.$1') + '"';
 case 'array':
 return '[' + obj.map(function(ar){
 return Moo.Json.toString(ar);
 }).join(',') + ']';
 case 'object':
 var string = [];
 for (var property in obj) string.push(Moo.Json.toString(property) + ':' + Moo.Json.toString(obj[property]));
 return '{' + string.join(',') + '}';
 }
 return String(obj);
 },

 /*
 Property: evaluate
 converts a json string to an javascript Object.

 Arguments:
 str - the string to evaluate.

 Example:
 >var myObject = Moo.Json.evaluate('{"apple":"red","lemon":"yellow"}');
 >//myObject will become {apple: 'red', lemon: 'yellow'}
 */

 evaluate: function(str){
 return eval('(' + str + ')');
 }

};

/*
Script: Moo.Json.Remote.js
 Contains <Moo.Json.Remote>.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Json.Remote
 Wrapped Moo.XHR with automated sending and receiving of Javascript Objects in Moo.Json Format.

Arguments:
 url - the url you want to send your object to.
 options - see <Moo.XHR> options

Example:
 this code will send user information based on name/last name
 (start code)
 var jSonRequest = new Moo.Json.Remote("http://site.com/tellMeAge.php", {onComplete: function(person){
 alert(person.age); //is 25 years
 alert(person.height); //is 170 cm
 alert(person.weight); //is 120 kg
 }}).send({'name': 'John', 'lastName': 'Doe'});
 (end)
*/

Moo.Json.Remote = Moo.XHR.extend({

 initialize: function(url, options){
 this.url = url;
 this.addEvent('onSuccess', this.onComplete);
 this.parent(options);
 this.setHeader('X-Request', 'JSON');
 },

 send: function(obj){
 return this.parent(this.url, 'json=' + Moo.Json.toString(obj));
 },

 onComplete: function(){
 this.fireEvent('onComplete', Moo.Json.evaluate(this.response.text));
 }

});

/*
Script: Assets.js
 provides dynamic loading for images, css and javascript files.

License:
 MIT-style license.
*/

Moo.Asset = new Moo.Abstract({

 /*
 Property: javascript
 Injects a javascript file in the page.

 Arguments:
 source - the path of the javascript file
 properties - some additional attributes you might want to add to the script element

 Example:
 > new Moo.Asset.javascript('/scripts/myScript.js', {id: 'myScript'});
 */

 javascript: function(source, properties){
 properties = Moo.$merge({
 'onload': Moo.Class.empty
 }, properties);
 var script = new Moo.Element('script', {'src': source}).addEvents({
 'load': properties.onload,
 'readystatechange': function(){
 if (this.readyState == 'complete') this.fireEvent('load');
 }
 });
 delete properties.onload;
 return script.setProperties(properties).inject(document.head);
 },

 /*
 Property: css
 Injects a css file in the page.

 Arguments:
 source - the path of the css file
 properties - some additional attributes you might want to add to the link element

 Example:
 > new Moo.Asset.css('/css/myStyle.css', {id: 'myStyle', title: 'myStyle'});
 */

 css: function(source, properties){
 return new Moo.Element('link', Moo.$merge({
 'rel': 'stylesheet', 'media': 'screen', 'type': 'text/css', 'href': source
 }, properties)).inject(document.head);
 },

 /*
 Property: image
 Preloads an image and returns the img element. does not inject it to the page.

 Arguments:
 source - the path of the image file
 properties - some additional attributes you might want to add to the img element

 Example:
 > new Moo.Asset.image('/images/myImage.png', {id: 'myImage', title: 'myImage', onload: myFunction});

 Returns:
 the img element. you can inject it anywhere you want with <Moo.Element.injectInside>/<Moo.Element.injectAfter>/<Moo.Element.injectBefore>
 */

 image: function(source, properties){
 properties = Moo.$merge({
 'onload': Moo.Class.empty,
 'onabort': Moo.Class.empty,
 'onerror': Moo.Class.empty
 }, properties);
 var image = new Image();
 image.src = source;
 var element = new Moo.Element('img', {'src': source});
 ['load', 'abort', 'error'].each(function(type){
 var event = properties['on' + type];
 delete properties['on' + type];
 element.addEvent(type, function(){
 this.removeEvent(type, arguments.callee);
 event.call(this);
 });
 });
 if (image.width && image.height) element.fireEvent('load');
 return element.setProperties(properties);
 },

 /*
 Property: images
 Preloads an array of images (as strings) and returns an array of img elements. does not inject them to the page.

 Arguments:
 sources - array, the paths of the image files
 options - object, see below

 Moo.Options:
 onComplete - a function to execute when all image files are loaded in the browser's cache
 onProgress - a function to execute when one image file is loaded in the browser's cache

 Example:
 (start code)
 new Moo.Asset.images(['/images/myImage.png', '/images/myImage2.gif'], {
 onComplete: function(){
 alert('all images loaded!');
 }
 });
 (end)

 Returns:
 the img elements as Moo.$$. you can inject them anywhere you want with <Moo.Element.injectInside>/<Moo.Element.injectAfter>/<Moo.Element.injectBefore>
 */

 images: function(sources, options){
 options = Moo.$merge({
 onComplete: Moo.Class.empty,
 onProgress: Moo.Class.empty
 }, options);
 if (!sources.push) sources = [sources];
 var images = [];
 var counter = 0;
 sources.each(function(source){
 var img = new Moo.Asset.image(source, {
 'onload': function(){
 options.onProgress.call(this, counter);
 counter++;
 if (counter == sources.length) options.onComplete();
 }
 });
 images.push(img);
 });
 return Moo.$extend(images, new Moo.Elements);
 }

});

/*
Script: Moo.Hash.js
 Contains the class Moo.Hash.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Hash
 It wraps an object that it uses internally as a map. The user must use set(), get(), and remove() to add/change, retrieve and remove values, it must not access the internal object directly. null/undefined values are allowed.

Arguments:
 obj - an object to convert into a Moo.Hash instance.

Example:
 (start code)
 var hash = new Moo.Hash({a: 'hi', b: 'world', c: 'howdy'});
 hash.remove('b'); // b is removed.
 hash.set('c', 'hello');
 hash.get('c'); // returns 'hello'
 hash.length // returns 2 (a and c)
 (end)
*/

Moo.Hash = new Moo.Class({

 length: 0,

 initialize: function(obj){
 this.obj = {};
 this.extend(obj);
 },

 /*
 Property: get
 Retrieves a value from the hash.

 Arguments:
 key - The key

 Returns:
 The value
 */

 get: function(key){
 return this.obj[key];
 },

 /*
 Property: hasKey
 Check the presence of a specified key-value pair in the hash.

 Arguments:
 key - The key

 Returns:
 True if the Moo.Hash contains a value for the specified key, otherwise false
 */

 hasKey: function(key){
 return (key in this.obj);
 },

 /*
 Property: set
 Adds a key-value pair to the hash or replaces a previous value associated with the key.

 Arguments:
 key - The key
 value - The value
 */

 set: function(key, value){
 if (key in this.obj) this.length++;
 this.obj[key] = value;
 return this;
 },

 /*
 Property: remove
 Removes a key-value pair from the hash.

 Arguments:
 key - The key
 */

 remove: function(key){
 if (!(key in this.obj)) return this;
 delete this.obj[key];
 this.length--;
 return this;
 },

 /*
 Property: each
 Calls a function for each key-value pair. The first argument passed to the function will be the value, the second one will be the key, like Moo.$each.

 Arguments:
 fn - The function to call for each key-value pair
 bind - Optional, the object that will be referred to as "this" in the function
 */

 each: function(fn, bind){
 Moo.$each(this.obj, fn, bind);
 },

 /*
 Property: extend
 Extends the current hash with an object containing key-value pairs. Values for duplicate keys will be replaced by the new ones.

 Arguments:
 obj - An object containing key-value pairs
 */

 extend: function(obj){
 for (var key in obj) this.set(key, obj[key]);
 return this;
 },

 /*
 Property: empty
 Empties all hash values properties and values.
 */

 empty: function(){
 this.obj = {};
 this.length = 0;
 return this;
 },

 /*
 Property: keys
 Returns an array containing all the keys, in the same order as the values returned by <Moo.Hash.values>.

 Returns:
 An array containing all the keys of the hash
 */

 keys: function(){
 var keys = [];
 for (var property in this.obj) keys.push(property);
 return keys;
 },

 /*
 Property: values
 Returns an array containing all the values, in the same order as the keys returned by <Moo.Hash.keys>.

 Returns:
 An array containing all the values of the hash
 */

 values: function(){
 var values = [];
 for (var property in this.obj) values.push(this.obj[property]);
 return values;
 }

});

/* Section: Utility Functions */

/*
Function: Moo.$H
 Shortcut to create a Moo.Hash from an Object.
*/

Moo.$H = function(obj){
 return new Moo.Hash(obj);
};

/*
Script: Moo.Color.js
 Contains the Moo.Color class.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Color
 Creates a new Moo.Color Object, which is an array with some color specific methods.
Arguments:
 color - the hex, the RGB array or the HSB array of the color to create. For HSB colors, you need to specify the second argument.
 type - a string representing the type of the color to create. needs to be specified if you intend to create the color with HSB values, or an array of HEX values. Can be 'rgb', 'hsb' or 'hex'.

Example:
 (start code)
 var black = new Moo.Color('#000');
 var purple = new Moo.Color([255,0,255]);
 // mix black with white and purple, each time at 10% of the new color
 var darkpurple = black.mix('#fff', purple, 10);
 Moo.$('myDiv').setStyle('background-color', darkpurple);
 (end)
*/

Moo.Color = new Moo.Class({

 initialize: function(color, type){
 type = type || (color.push ? 'rgb' : 'hex');
 var rgb, hsb;
 switch(type){
 case 'rgb':
 rgb = color;
 hsb = rgb.rgbToHsb();
 break;
 case 'hsb':
 rgb = color.hsbToRgb();
 hsb = color;
 break;
 default:
 rgb = color.hexToRgb(true);
 hsb = rgb.rgbToHsb();
 }
 rgb.hsb = hsb;
 rgb.hex = rgb.rgbToHex();
 return Moo.$extend(rgb, Moo.Color.prototype);
 },

 /*
 Property: mix
 Mixes two or more colors with the Moo.Color.
 
 Arguments:
 color - a color to mix. you can use as arguments how many colors as you want to mix with the original one.
 alpha - if you use a number as the last argument, it will be threated as the amount of the color to mix.
 */

 mix: function(){
 var colors = Moo.$A(arguments);
 var alpha = (Moo.$type(colors[colors.length - 1]) == 'number') ? colors.pop() : 50;
 var rgb = this.copy();
 colors.each(function(color){
 color = new Moo.Color(color);
 for (var i = 0; i < 3; i++) rgb[i] = Math.round((rgb[i] / 100 * (100 - alpha)) + (color[i] / 100 * alpha));
 });
 return new Moo.Color(rgb, 'rgb');
 },

 /*
 Property: invert
 Inverts the Moo.Color.
 */

 invert: function(){
 return new Moo.Color(this.map(function(value){
 return 255 - value;
 }));
 },

 /*
 Property: setHue
 Modifies the hue of the Moo.Color, and returns a new one.
 
 Arguments:
 value - the hue to set
 */

 setHue: function(value){
 return new Moo.Color([value, this.hsb[1], this.hsb[2]], 'hsb');
 },

 /*
 Property: setSaturation
 Changes the saturation of the Moo.Color, and returns a new one.
 
 Arguments:
 percent - the percentage of the saturation to set
 */

 setSaturation: function(percent){
 return new Moo.Color([this.hsb[0], percent, this.hsb[2]], 'hsb');
 },

 /*
 Property: setBrightness
 Changes the brightness of the Moo.Color, and returns a new one.
 
 Arguments:
 percent - the percentage of the brightness to set
 */

 setBrightness: function(percent){
 return new Moo.Color([this.hsb[0], this.hsb[1], percent], 'hsb');
 }

});

/* Section: Utility Functions */

/*
Function: Moo.$RGB
 Shortcut to create a new color, based on red, green, blue values.

Arguments:
 r - (integer) red value (0-255)
 g - (integer) green value (0-255)
 b - (integer) blue value (0-255)

*/

Moo.$RGB = function(r, g, b){
 return new Moo.Color([r, g, b], 'rgb');
};

/*
Function: Moo.$HSB
 Shortcut to create a new color, based on hue, saturation, brightness values.

Arguments:
 h - (integer) hue value (0-100)
 s - (integer) saturation value (0-100)
 b - (integer) brightness value (0-100)
*/

Moo.$HSB = function(h, s, b){
 return new Moo.Color([h, s, b], 'hsb');
};

/*
Moo.Class: Array
 A collection of The Array Object prototype methods.
*/

Array.extend({
 
 /*
 Property: rgbToHsb
 Converts a RGB array to an HSB array.

 Returns:
 the HSB array.
 */

 rgbToHsb: function(){
 var red = this[0], green = this[1], blue = this[2];
 var hue, saturation, brightness;
 var max = Math.max(red, green, blue), min = Math.min(red, green, blue);
 var delta = max - min;
 brightness = max / 255;
 saturation = (max != 0) ? delta / max : 0;
 if (saturation == 0){
 hue = 0;
 } else {
 var rr = (max - red) / delta;
 var gr = (max - green) / delta;
 var br = (max - blue) / delta;
 if (red == max) hue = br - gr;
 else if (green == max) hue = 2 + rr - br;
 else hue = 4 + gr - rr;
 hue /= 6;
 if (hue < 0) hue++;
 }
 return [Math.round(hue * 360), Math.round(saturation * 100), Math.round(brightness * 100)];
 },

 /*
 Property: hsbToRgb
 Converts an HSB array to an RGB array.

 Returns:
 the RGB array.
 */

 hsbToRgb: function(){
 var br = Math.round(this[2] / 100 * 255);
 if (this[1] == 0){
 return [br, br, br];
 } else {
 var hue = this[0] % 360;
 var f = hue % 60;
 var p = Math.round((this[2] * (100 - this[1])) / 10000 * 255);
 var q = Math.round((this[2] * (6000 - this[1] * f)) / 600000 * 255);
 var t = Math.round((this[2] * (6000 - this[1] * (60 - f))) / 600000 * 255);
 switch(Math.floor(hue / 60)){
 case 0: return [br, t, p];
 case 1: return [q, br, p];
 case 2: return [p, br, t];
 case 3: return [p, q, br];
 case 4: return [t, p, br];
 case 5: return [br, p, q];
 }
 }
 return false;
 }

});

/*
Script: Moo.Scroller.js
 Contains the <Moo.Scroller>.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Scroller
 The Moo.Scroller is a class to scroll any element with an overflow (including the window) when the mouse cursor reaches certain buondaries of that element.
 You must call its start method to start listening to mouse movements.
 
Note:
 The Moo.Scroller requires an XHTML doctype.

Arguments:
 element - required, the element to scroll.
 options - optional, see options below, and <Moo.Fx.Base> options.

Moo.Options:
 area - integer, the necessary boundaries to make the element scroll.
 velocity - integer, velocity ratio, the modifier for the window scrolling speed.
 onChange - optionally, when the mouse reaches some boundaries, you can choose to alter some other values, instead of the scrolling offsets.
 Automatically passes as parameters x and y values.
*/

Moo.Scroller = new Moo.Class({

 options: {
 area: 20,
 velocity: 1,
 onChange: function(x, y){
 this.element.scrollTo(x, y);
 }
 },

 initialize: function(element, options){
 this.setOptions(options);
 this.element = Moo.$(element);
 this.mousemover = ([window, document].contains(element)) ? Moo.$(document.body) : this.element;
 },

 /*
 Property: start
 The scroller starts listening to mouse movements.
 */

 start: function(){
 this.coord = this.getCoords.bindWithEvent(this);
 this.mousemover.addListener('mousemove', this.coord);
 },

 /*
 Property: stop
 The scroller stops listening to mouse movements.
 */

 stop: function(){
 this.mousemover.removeListener('mousemove', this.coord);
 this.timer = Moo.$clear(this.timer);
 },

 getCoords: function(event){
 this.page = (this.element == window) ? event.client : event.page;
 if (!this.timer) this.timer = this.scroll.periodical(50, this);
 },

 scroll: function(){
 var el = this.element.getSize();
 var pos = this.element.getPosition();

 var change = {'x': 0, 'y': 0};
 for (var z in this.page){
 if (this.page[z] < (this.options.area + pos[z]) && el.scroll[z] != 0)
 change[z] = (this.page[z] - this.options.area - pos[z]) * this.options.velocity;
 else if (this.page[z] + this.options.area > (el.size[z] + pos[z]) && el.scroll[z] + el.size[z] != el.scrollSize[z])
 change[z] = (this.page[z] - el.size[z] + this.options.area - pos[z]) * this.options.velocity;
 }
 if (change.y || change.x) this.fireEvent('onChange', [el.scroll.x + change.x, el.scroll.y + change.y]);
 }

});

Moo.Scroller.implement(new Moo.Events);
Moo.Scroller.implement(new Moo.Options);

/*
Script: Moo.Slider.js
 Contains <Moo.Slider>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Slider
 Creates a slider with two elements: a knob and a container. Returns the values.
 
Note:
 The Moo.Slider requires an XHTML doctype.

Arguments:
 element - the knob container
 knob - the handle
 options - see Moo.Options below

Moo.Options:
 onChange - a function to fire when the value changes.
 onComplete - a function to fire when you're done dragging.
 onTick - optionally, you can alter the onTick behavior, for example displaying an effect of the knob moving to the desired position.
 Passes as parameter the new position.
 steps - the number of steps for your slider.
 mode - either 'horizontal' or 'vertical'. defaults to horizontal.
 offset - relative offset for knob position. default to 0.
*/

Moo.Slider = new Moo.Class({

 options: {
 onChange: Moo.Class.empty,
 onComplete: Moo.Class.empty,
 onTick: function(pos){
 this.knob.setStyle(this.p, pos);
 },
 mode: 'horizontal',
 steps: 100,
 offset: 0
 },

 initialize: function(el, knob, options){
 this.element = Moo.$(el);
 this.knob = Moo.$(knob);
 this.setOptions(options);
 this.previousChange = -1;
 this.previousEnd = -1;
 this.step = -1;
 this.element.addEvent('mousedown', this.clickedElement.bindWithEvent(this));
 var mod, offset;
 if (this.options.mode == 'horizontal'){
 this.z = 'x';
 this.p = 'left';
 mod = {'x': 'left', 'y': false};
 offset = 'offsetWidth';
 } else if (this.options.mode == 'vertical'){
 this.z = 'y';
 this.p = 'top';
 mod = {'x': false, 'y': 'top'};
 offset = 'offsetHeight';
 }
 this.max = this.element[offset] - this.knob[offset] + (this.options.offset * 2);
 this.half = this.knob[offset]/2;
 this.getPos = this.element['get' + this.p.capitalize()].bind(this.element);
 this.knob.setStyle('position', 'relative').setStyle(this.p, - this.options.offset);
 var lim = {};
 lim[this.z] = [- this.options.offset, this.max - this.options.offset];
 this.drag = new Moo.Drag.Base(this.knob, {
 limit: lim,
 modifiers: mod,
 snap: 0,
 onStart: function(){
 this.draggedKnob();
 }.bind(this),
 onDrag: function(){
 this.draggedKnob();
 }.bind(this),
 onComplete: function(){
 this.draggedKnob();
 this.end();
 }.bind(this)
 });
 if (this.options.initialize) this.options.initialize.call(this);
 },

 /*
 Property: set
 The slider will get the step you pass.

 Arguments:
 step - one integer
 */

 set: function(step){
 if (step > this.options.steps) step = this.options.steps;
 else if (step < 0) step = 0;
 this.step = step;
 this.checkStep();
 this.end();
 this.fireEvent('onTick', this.toPosition(this.step));
 return this;
 },

 clickedElement: function(event){
 var position = event.page[this.z] - this.getPos() - this.half;
 if (position > this.max - this.options.offset) position = this.max - this.options.offset;
 else if (position < - this.options.offset) position = - this.options.offset;
 this.step = this.toStep(position);
 this.checkStep();
 this.end();
 this.fireEvent('onTick', position);
 },

 draggedKnob: function(){
 this.step = this.toStep(this.drag.value.now[this.z]);
 this.checkStep();
 },

 checkStep: function(){
 if (this.previousChange != this.step){
 this.previousChange = this.step;
 this.fireEvent('onChange', this.step);
 }
 },

 end: function(){
 if (this.previousEnd !== this.step){
 this.previousEnd = this.step;
 this.fireEvent('onComplete', this.step + '');
 }
 },

 toStep: function(position){
 return Math.round((position + this.options.offset) / this.max * this.options.steps);
 },

 toPosition: function(step){
 return (this.max) * step / this.options.steps;
 }

});

Moo.Slider.implement(new Moo.Events);
Moo.Slider.implement(new Moo.Options);

/*
Script: Moo.SmoothScroll.js
 Contains <Moo.SmoothScroll>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.SmoothScroll
 Auto targets all the anchors in a page and display a smooth scrolling effect upon clicking them.
 
Note:
 Moo.SmoothScroll requires an XHTML doctype.

Arguments:
 options - the Moo.Fx.Base options (see: <Moo.Fx.Base>) plus links, a collection of elements you want your smoothscroll on. Defaults to document.links.

Example:
 >new Moo.SmoothScroll();
*/

Moo.SmoothScroll = Moo.Fx.Scroll.extend({

 initialize: function(options){
 this.parent(window, options);
 this.links = (this.options.links) ? Moo.$$(this.options.links) : Moo.$$(document.links);
 this.addEvent('onCancel', this.clearChain);
 var location = window.location.href.match(/^[^#]*/)[0] + '#';
 this.links.each(function(link){
 if (link.href.indexOf(location) != 0) return;
 var anchor = link.href.substr(location.length);
 if (anchor && Moo.$(anchor)) this.useLink(link, anchor);
 }, this);
 },

 useLink: function(link, anchor){
 link.addEvent('click', function(event){
 if (!window.khtml){
 this.clearChain();
 this.chain(function(){
 window.location.hash = anchor;
 });
 }
 this.toElement(anchor);
 event.stop();
 }.bindWithEvent(this));
 }

});

/*
Script: Moo.Sortables.js
 Contains <Moo.Sortables> Moo.Class.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Sortables
 Creates an interface for <Moo.Drag.Base> and drop, resorting of a list.
 
Note:
 The Moo.Sortables require an XHTML doctype.

Arguments:
 list - required, the list that will become sortable.
 options - an Object, see options below.

Moo.Options:
 handles - a collection of elements to be used for drag handles. defaults to the elements.
 onStart - function executed when the item starts dragging
 onComplete - function executed when the item ends dragging
*/

Moo.Sortables = new Moo.Class({

 options: {
 handles: false,
 onStart: Moo.Class.empty,
 onComplete: Moo.Class.empty,
 ghost: true,
 snap: 3,
 onDragStart: function(element, ghost){
 ghost.setStyle('opacity', 0.7);
 element.setStyle('opacity', 0.7);
 },
 onDragComplete: function(element, ghost){
 element.setStyle('opacity', 1);
 ghost.remove();
 this.trash.remove();
 }
 },

 initialize: function(list, options){
 this.setOptions(options);
 this.list = Moo.$(list);
 this.elements = this.list.getChildren();
 this.handles = (this.options.handles) ? Moo.$$(this.options.handles) : this.elements;
 this.bound = {
 'start': [],
 'moveGhost': this.moveGhost.bindWithEvent(this)
 };
 for (var i = 0, l = this.handles.length; i < l; i++){
 this.bound.start[i] = this.start.bindWithEvent(this, this.elements[i]);
 }
 this.attach();
 if (this.options.initialize) this.options.initialize.call(this);
 this.bound.move = this.move.bindWithEvent(this);
 this.bound.end = this.end.bind(this);
 },
 
 attach: function(){
 this.handles.each(function(handle, i){
 handle.addEvent('mousedown', this.bound.start[i]);
 }, this);
 },

 detach: function(){
 this.handles.each(function(handle, i){
 handle.removeEvent('mousedown', this.bound.start[i]);
 }, this);
 },

 start: function(event, el){
 this.active = el;
 this.coordinates = this.list.getCoordinates();
 if (this.options.ghost){
 var position = el.getPosition();
 this.offset = event.page.y - position.y;
 this.trash = new Moo.Element('div').inject(document.body);
 this.ghost = el.clone().inject(this.trash).setStyles({
 'position': 'absolute',
 'left': position.x,
 'top': event.page.y - this.offset
 });
 document.addListener('mousemove', this.bound.moveGhost);
 this.fireEvent('onDragStart', [el, this.ghost]);
 }
 document.addListener('mousemove', this.bound.move);
 document.addListener('mouseup', this.bound.end);
 this.fireEvent('onStart', el);
 event.stop();
 },
 
 moveGhost: function(event){
 var value = event.page.y - this.offset;
 if (value < this.coordinates.top) value = this.coordinates.top;
 else if (value + this.ghost.offsetHeight > this.coordinates.bottom) value = this.coordinates.bottom - this.ghost.offsetHeight;
 this.ghost.setStyle('top', value);
 event.stop();
 },

 move: function(event){
 this.active.active = true;
 this.previous = this.previous || event.page.y;
 this.now = event.page.y;
 var direction = ((this.previous - this.now) <= 0) ? 'down' : 'up';
 var prev = this.active.getPrevious();
 var next = this.active.getNext();
 if (prev && direction == 'up'){
 var prevPos = prev.getCoordinates();
 if (event.page.y < prevPos.bottom) this.active.injectBefore(prev);
 }
 if (next && direction == 'down'){
 var nextPos = next.getCoordinates();
 if (event.page.y > nextPos.top) this.active.injectAfter(next);
 }
 this.previous = event.page.y;
 },

 serialize: function(){
 var serial = [];
 this.list.getChildren().each(function(el, i){
 serial[i] = this.elements.indexOf(el);
 }, this);
 return serial;
 },

 end: function(){
 this.previous = null;
 document.removeListener('mousemove', this.bound.move);
 document.removeListener('mouseup', this.bound.end);
 if (this.options.ghost){
 document.removeListener('mousemove', this.bound.moveGhost);
 this.fireEvent('onDragComplete', [this.active, this.ghost]);
 }
 this.fireEvent('onComplete', this.active);
 }

});

Moo.Sortables.implement(new Moo.Events);
Moo.Sortables.implement(new Moo.Options);

/*
Script: Moo.Tips.js
 Tooltips, BubbleTips, whatever they are, they will appear on mouseover

License:
 MIT-style license.

Credits:
 The idea behind Moo.Tips.js is based on Bubble Tooltips (<http://web-graphics.com/mtarchive/001717.php>) by Alessandro Fulcitiniti <http://web-graphics.com>
*/

/*
Moo.Class: Moo.Tips
 Display a tip on any element with a title and/or href.
 
Note:
 Moo.Tips requires an XHTML doctype.

Arguments:
 elements - a collection of elements to apply the tooltips to on mouseover.
 options - an object. See options Below.

Moo.Options:
 maxTitleChars - the maximum number of characters to display in the title of the tip. defaults to 30.

 onShow - optionally you can alter the default onShow behaviour with this option (like displaying a fade in effect);
 onHide - optionally you can alter the default onHide behaviour with this option (like displaying a fade out effect);

 showDelay - the delay the onShow method is called. (defaults to 100 ms)
 hideDelay - the delay the onHide method is called. (defaults to 100 ms)

 className - the prefix for your tooltip classNames. defaults to 'tool'.
 
 the whole tooltip will have as classname: tool-tip
 
 the title will have as classname: tool-title
 
 the text will have as classname: tool-text

 offsets - the distance of your tooltip from the mouse. an Object with x/y properties.
 fixed - if set to true, the toolTip will not follow the mouse.

Example:
 (start code)
 <img src="/images/i.png" title="The body of the tooltip is stored in the title" class="toolTipImg"/>
 <script>
 var myTips = new Moo.Tips(Moo.$$('.toolTipImg'), {
 maxTitleChars: 50 //I like my captions a little long
 });
 </script>
 (end)

Note:
 The title of the element will always be used as the tooltip body. If you put :: on your title, the text before :: will become the tooltip title.
*/

Moo.Tips = new Moo.Class({

 options: {
 onShow: function(tip){
 tip.setStyle('visibility', 'visible');
 },
 onHide: function(tip){
 tip.setStyle('visibility', 'hidden');
 },
 maxTitleChars: 30,
 showDelay: 100,
 hideDelay: 100,
 className: 'tool',
 offsets: {'x': 16, 'y': 16},
 fixed: false
 },

 initialize: function(elements, options){
 this.setOptions(options);
 this.toolTip = new Moo.Element('div', {
 'class': this.options.className + '-tip',
 'styles': {
 'position': 'absolute',
 'top': '0',
 'left': '0',
 'visibility': 'hidden'
 }
 }).inject(document.body);
 this.wrapper = new Moo.Element('div').inject(this.toolTip);
 Moo.$each(elements, function(el){
 this.build(Moo.$(el));
 }, this);
 if (this.options.initialize) this.options.initialize.call(this);
 },

 build: function(el){
 el.$.myTitle = (el.href && el.getTag() == 'a') ? el.href.replace('http://', '') : (el.rel || false);
 if (el.title){
 var dual = el.title.split('::');
 if (dual.length > 1) {
 el.$.myTitle = dual[0].trim();
 el.$.myText = dual[1].trim();
 } else {
 el.$.myText = el.title;
 }
 el.removeAttribute('title');
 } else {
 el.$.myText = false;
 }
 if (el.$.myTitle && el.$.myTitle.length > this.options.maxTitleChars) el.$.myTitle = el.$.myTitle.substr(0, this.options.maxTitleChars - 1) + "&hellip;";
 el.addEvent('mouseenter', function(event){
 this.start(el);
 if (!this.options.fixed) this.locate(event);
 else this.position(el);
 }.bind(this));
 if (!this.options.fixed) el.addEvent('mousemove', this.locate.bindWithEvent(this));
 el.addEvent('mouseleave', this.end.bind(this));
 },

 start: function(el){
 this.wrapper.empty();
 if (el.$.myTitle){
 this.title = new Moo.Element('span').inject(
 new Moo.Element('div', {'class': this.options.className + '-title'}).inject(this.wrapper)
 ).setHTML(el.$.myTitle);
 }
 if (el.$.myText){
 this.text = new Moo.Element('span').inject(
 new Moo.Element('div', {'class': this.options.className + '-text'}).inject(this.wrapper)
 ).setHTML(el.$.myText);
 }
 Moo.$clear(this.timer);
 this.timer = this.show.delay(this.options.showDelay, this);
 },

 end: function(event){
 Moo.$clear(this.timer);
 this.timer = this.hide.delay(this.options.hideDelay, this);
 },

 position: function(element){
 var pos = element.getPosition();
 this.toolTip.setStyles({
 'left': pos.x + this.options.offsets.x,
 'top': pos.y + this.options.offsets.y
 });
 },

 locate: function(event){
 var win = {'x': window.getWidth(), 'y': window.getHeight()};
 var scroll = {'x': window.getScrollLeft(), 'y': window.getScrollTop()};
 var tip = {'x': this.toolTip.offsetWidth, 'y': this.toolTip.offsetHeight};
 var prop = {'x': 'left', 'y': 'top'};
 for (var z in prop){
 var pos = event.page[z] + this.options.offsets[z];
 if ((pos + tip[z] - scroll[z]) > win[z]) pos = event.page[z] - this.options.offsets[z] - tip[z];
 this.toolTip.setStyle(prop[z], pos);
 };
 },

 show: function(){
 this.fireEvent('onShow', [this.toolTip]);
 },

 hide: function(){
 this.fireEvent('onHide', [this.toolTip]);
 }

});

Moo.Tips.implement(new Moo.Events);
Moo.Tips.implement(new Moo.Options);

/*
Script: Moo.Group.js
 For Grouping Classes or Moo.Elements Moo.Events. The Moo.Event added to the Moo.Group will fire when all of the events of the items of the group are fired.

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Group
 An "Utility" Moo.Class.
*/

Moo.Group = new Moo.Class({

 initialize: function(){
 this.instances = Moo.$A(arguments);
 this.events = {};
 this.checker = {};
 },

 addEvent: function(type, fn){
 this.checker[type] = this.checker[type] || {};
 this.events[type] = this.events[type] || [];
 if (this.events[type].contains(fn)) return false;
 else this.events[type].push(fn);
 this.instances.each(function(instance, i){
 instance.addEvent(type, this.check.bind(this, [type, instance, i]));
 }, this);
 return this;
 },

 check: function(type, instance, i){
 this.checker[type][i] = true;
 var every = this.instances.every(function(current, j){
 return this.checker[type][j] || false;
 }, this);
 if (!every) return;
 this.instances.each(function(current, j){
 this.checker[type][j] = false;
 }, this);
 this.events[type].each(function(event){
 event.call(this, this.instances, instance);
 }, this);
 }

});

/*
Script: Moo.Accordion.js
 Contains <Moo.Accordion>

License:
 MIT-style license.
*/

/*
Moo.Class: Moo.Accordion
 The Moo.Accordion class creates a group of elements that are toggled when their handles are clicked. When one elements toggles in, the others toggles back.
 
Note:
 The Moo.Accordion requires an XHTML doctype.

Arguments:
 togglers - required, a collection of elements, the elements handlers that will be clickable.
 elements - required, a collection of elements the transitions will be applied to.
 options - optional, see options below, and <Moo.Fx.Base> options.

Moo.Options:
 show - integer, the Index of the element to show at start.
 display - integer, the Index of the element to show at start (with a transition). defaults to 0.
 fixedHeight - integer, if you want the elements to have a fixed height. defaults to false.
 fixedWidth - integer, if you want the elements to have a fixed width. defaults to false.
 onActive - function to execute when an element starts to show
 onBackground - function to execute when an element starts to hide
 height - boolean, will add a height transition to the accordion if true. defaults to true.
 opacity - boolean, will add an opacity transition to the accordion if true. defaults to true.
 width - boolean, will add a width transition to the accordion if true. defaults to false, css mastery is required to make this work!
 alwaysHide - boolean, will allow to hide all elements if true, instead of always keeping one element shown. defaults to false.
*/

Moo.Accordion = Moo.Fx.Elements.extend({

 options: {
 onActive: Moo.Class.empty,
 onBackground: Moo.Class.empty,
 display: 0,
 show: false,
 height: true,
 width: false,
 opacity: true,
 fixedHeight: false,
 fixedWidth: false,
 wait: false,
 alwaysHide: false
 },

 initialize: function(){
 var options, togglers, elements, container;
 Moo.$each(arguments, function(argument, i){
 switch(Moo.$type(argument)){
 case 'object': options = argument; break;
 case 'element': container = Moo.$(argument); break;
 default:
 var temp = Moo.$$(argument);
 if (!togglers) togglers = temp;
 else elements = temp;
 }
 });
 this.togglers = togglers || [];
 this.elements = elements || [];
 this.container = Moo.$(container);
 this.setOptions(options);
 this.previous = -1;
 if (this.options.alwaysHide) this.options.wait = true;
 if (Moo.$chk(this.options.show)){
 this.options.display = false;
 this.previous = this.options.show;
 }
 if (this.options.start){
 this.options.display = false;
 this.options.show = false;
 }
 this.effects = {};
 if (this.options.opacity) this.effects.opacity = 'fullOpacity';
 if (this.options.width) this.effects.width = this.options.fixedWidth ? 'fullWidth' : 'offsetWidth';
 if (this.options.height) this.effects.height = this.options.fixedHeight ? 'fullHeight' : 'scrollHeight';
 for (var i = 0, l = this.togglers.length; i < l; i++) this.addSection(this.togglers[i], this.elements[i]);
 this.elements.each(function(el, i){
 if (this.options.show === i) this.fireEvent('onActive', [this.togglers[i], el]);
 else for (var fx in this.effects) el.setStyle(fx, 0);
 }, this);
 this.parent(this.elements, this.options);
 if (Moo.$chk(this.options.display)) this.display(this.options.display);
 },

 addSection: function(toggler, element, pos){
 toggler = Moo.$(toggler);
 element = Moo.$(element);
 var test = this.togglers.contains(toggler);
 var len = this.togglers.length;
 this.togglers.include(toggler);
 this.elements.include(element);
 if (len && (!test || pos)){
 pos = Moo.$pick(pos, len - 1);
 toggler.injectBefore(this.togglers[pos]);
 element.injectAfter(toggler);
 } else if (this.container && !test){
 toggler.inject(this.container);
 element.inject(this.container);
 }
 var idx = this.togglers.indexOf(toggler);
 toggler.addEvent('click', this.display.bind(this, idx));
 if (this.options.height) element.setStyles({'padding-top': 0, 'border-top': 'none', 'padding-bottom': 0, 'border-bottom': 'none'});
 if (this.options.width) element.setStyles({'padding-left': 0, 'border-left': 'none', 'padding-right': 0, 'border-right': 'none'});
 element.fullOpacity = 1;
 if (this.options.fixedWidth) element.fullWidth = this.options.fixedWidth;
 if (this.options.fixedHeight) element.fullHeight = this.options.fixedHeight;
 element.setStyle('overflow', 'hidden');
 if (!test) for (var fx in this.effects) element.setStyle(fx, 0);
 return this;
 },

 /*
 Property: display
 Shows a specific section and hides all others. Useful when triggering an accordion from outside.

 Arguments:
 index - integer, the index of the item to show, or the actual element to show.
 */

 display: function(index){
 index = (Moo.$type(index) == 'element') ? this.elements.indexOf(index) : index;
 if ((this.timer && this.options.wait) || (index === this.previous && !this.options.alwaysHide)) return this;
 this.previous = index;
 var obj = {};
 this.elements.each(function(el, i){
 obj[i] = {};
 if ((i != index) || (this.options.alwaysHide && (el.offsetHeight > 0))){
 this.fireEvent('onBackground', [this.togglers[i], el]);
 for (var fx in this.effects) obj[i][fx] = 0;
 } else {
 this.fireEvent('onActive', [this.togglers[i], el]);
 for (var fx in this.effects) obj[i][fx] = el[this.effects[fx]];
 }
 }, this);
 return this.start(obj);
 },

 showThisHideOpen: function(index){return this.display(index)}

});

Moo.Fx.Accordion = Moo.Accordion;
/*
 This file is part of JonDesign's SmoothGallery v1.2.

 JonDesign's SmoothGallery is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 JonDesign's SmoothGallery is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with JonDesign's SmoothGallery; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

 Main Developer: Jonathan Schemoul (JonDesign: http://www.jondesign.net/)
 Contributed code by:
 - Christian Ehret (bugfix)
 - Nitrix (bugfix)
 - Valerio from Mad4Milk for his great help with the carousel scrolling and many other things.
 - Archie Cowan for helping me find a bugfix on carousel inner width problem.
 Many thanks to:
 - The mootools team for the great mootools lib, and it's help and support throughout the project.
*/


// declaring the class
var gallery = new Moo.Class({
 initialize: function(element, options) {
 this.setOptions({
 showArrows: true,
 showCarousel: true,
 showInfopane: true,
 thumbHeight: 75,
 thumbWidth: 100,
 thumbSpacing: 10,
 embedLinks: true,
 fadeDuration: 500,
 timed: false,
 delay: 9000,
 preloader: true,
 /* Data retrieval */
 manualData: [],
 populateFrom: false,
 populateData: true,
 destroyAfterPopulate: true,
 elementSelector: "div.imageElement",
 titleSelector: "h3",
 subtitleSelector: "p",
 linkSelector: "a.open",
 imageSelector: "img.full",
 thumbnailSelector: "img.thumbnail",
 /* InfoPane options */
 slideInfoZoneOpacity: 0.7,
 slideInfoZoneSlide: true,
 /* Carousel options */
 carouselMinimizedOpacity: 0.4,
 carouselMinimizedHeight: 20,
 carouselMaximizedOpacity: 0.7,
 textShowCarousel: 'Pictures',
 showCarouselLabel: true,
 useThumbGenerator: false,
 thumbGenerator: 'resizer.php',
 useExternalCarousel: false,
 carouselElement: false,
 activateCarouselScroller: true,
 /* CSS Classes */
 baseClass: 'jdGallery',
 withArrowsClass: 'withArrows',
 /* Plugins: HistoryManager */
 useHistoryManager: false,
 customHistoryKey: false
 }, options);
 this.fireEvent('onInit');
 this.currentIter = 0;
 this.lastIter = 0;
 this.maxIter = 0;
 this.galleryElement = element;
 this.galleryData = this.options.manualData;
 this.galleryInit = 1;
 this.galleryElements = Array();
 this.thumbnailElements = Array();
 this.galleryElement.addClass(this.options.baseClass);
 
 this.populateFrom = element;
 if (this.options.populateFrom)
 this.populateFrom = this.options.populateFrom; 
 if (this.options.populateData)
 this.populateData();
 element.style.display="block";
 
 if (this.options.useHistoryManager)
 this.initHistory();
 
 if (this.options.embedLinks)
 {
 this.currentLink = new Moo.Element('a').addClass('open').setProperties({
 href: '#',
 title: ''
 }).injectInside(element);
 if ((!this.options.showArrows) && (!this.options.showCarousel))
 this.galleryElement = element = this.currentLink;
 else
 this.currentLink.setStyle('display', 'none');
 }
 
 this.constructElements();
 if ((this.galleryData.length>1)&&(this.options.showArrows))
 {
 var leftArrow = new Moo.Element('a').addClass('left').addEvent(
 'click',
 this.prevItem.bind(this)
 ).injectInside(element);
 var rightArrow = new Moo.Element('a').addClass('right').addEvent(
 'click',
 this.nextItem.bind(this)
 ).injectInside(element);
 this.galleryElement.addClass(this.options.withArrowsClass);
 }
 this.loadingElement = new Moo.Element('div').addClass('loadingElement').injectInside(element);
 if (this.options.showInfopane) this.initInfoSlideshow();
 if (this.options.showCarousel) this.initCarousel();
 this.doSlideShow(1);
 },
 populateData: function() {
 currentArrayPlace = this.galleryData.length;
 options = this.options;
 var data = this.galleryData;
 this.populateFrom.getElements(options.elementSelector).each(function(el) {
 elementDict = {
 image: el.getElement(options.imageSelector).getProperty('src'),
 number: currentArrayPlace
 };
 if ((options.showInfopane) | (options.showCarousel))
 Object.extend(elementDict, {
 title: el.getElement(options.titleSelector).innerHTML,
 description: el.getElement(options.subtitleSelector).innerHTML
 });
 if (options.embedLinks)
 Object.extend(elementDict, {
 link: el.getElement(options.linkSelector).href||false,
 linkTitle: el.getElement(options.linkSelector).title||false
 });
 if ((!options.useThumbGenerator) && (options.showCarousel))
 Object.extend(elementDict, {
 thumbnail: el.getElement(options.thumbnailSelector).src
 });
 else if (options.useThumbGenerator)
 Object.extend(elementDict, {
 thumbnail: options.thumbGenerator + '?imgfile=' + elementDict.image + '&max_width=' + options.thumbWidth + '&max_height=' + options.thumbHeight
 });
 
 data[currentArrayPlace] = elementDict;
 currentArrayPlace++;
 if (this.options.destroyAfterPopulate)
 el.remove();
 });
 this.galleryData = data;
 this.fireEvent('onPopulated');
 },
 constructElements: function() {
 el = this.galleryElement;
 this.maxIter = this.galleryData.length;
 var currentImg;
 for(i=0;i<this.galleryData.length;i++)
 {
 var currentImg = new Moo.Fx.Style(
 new Moo.Element('div').addClass('slideElement').setStyles({
 'position':'absolute',
 'left':'0px',
 'right':'0px',
 'margin':'0px',
 'padding':'0px',
 'backgroundImage':"url('" + this.galleryData[i].image + "')",
 'backgroundPosition':"center center",
 'opacity':'0'
 }).injectInside(el),
 'opacity',
 {duration: this.options.fadeDuration}
 );
 this.galleryElements[parseInt(i)] = currentImg;
 }
 },
 destroySlideShow: function(element) {
 var myClassName = element.className;
 var newElement = new Moo.Element('div').addClass('myClassName');
 element.parentNode.replaceChild(newElement, element);
 },
 startSlideShow: function() {
 this.fireEvent('onStart');
 this.loadingElement.style.display = "none";
 this.lastIter = this.maxIter - 1;
 this.currentIter = 0;
 this.galleryInit = 0;
 this.galleryElements[parseInt(this.currentIter)].set(1);
 if (this.options.showInfopane)
 this.showInfoSlideShow.delay(1000, this);
 this.prepareTimer();
 if (this.options.embedLinks)
 this.makeLink(this.currentIter);
 },
 nextItem: function() {
 this.fireEvent('onNextCalled');
 this.nextIter = this.currentIter+1;
 if (this.nextIter >= this.maxIter)
 this.nextIter = 0;
 this.galleryInit = 0;
 this.goTo(this.nextIter);
 },
 prevItem: function() {
 this.fireEvent('onPreviousCalled');
 this.nextIter = this.currentIter-1;
 if (this.nextIter <= -1)
 this.nextIter = this.maxIter - 1;
 this.galleryInit = 0;
 this.goTo(this.nextIter);
 },
 goTo: function(num) {
 this.clearTimer();
 if (this.options.embedLinks)
 this.clearLink();
 if (this.options.showInfopane)
 {
 this.slideInfoZone.clearChain();
 this.hideInfoSlideShow().chain(this.changeItem.pass(num, this));
 } else
 this.changeItem.delay(500, this, num);
 if (this.options.embedLinks)
 this.makeLink(num);
 this.prepareTimer();
 /*if (this.options.showCarousel)
 this.clearThumbnailsHighlights();*/
 },
 changeItem: function(num) {
 this.fireEvent('onStartChanging');
 this.galleryInit = 0;
 if (this.currentIter != num)
 {
 for(i=0;i<this.maxIter;i++)
 {
 if ((i != this.currentIter)) this.galleryElements[i].set(0);
 }
 if (num > this.currentIter) this.galleryElements[num].custom(1);
 else
 {
 this.galleryElements[num].set(1);
 this.galleryElements[this.currentIter].custom(0);
 }
 this.currentIter = num;
 }
 this.doSlideShow.bind(this)();
 this.fireEvent('onChanged');
 },
 clearTimer: function() {
 if (this.options.timed)
 Moo.$clear(this.timer);
 },
 prepareTimer: function() {
 if (this.options.timed)
 this.timer = this.nextItem.delay(this.options.delay, this);
 },
 doSlideShow: function(position) {
 if (this.galleryInit == 1)
 {
 imgPreloader = new Image();
 imgPreloader.onload=function(){
 this.startSlideShow.delay(10, this);
 }.bind(this);
 imgPreloader.src = this.galleryData[0].image;
 } else {
 if (this.options.showInfopane)
 {
 if (this.options.showInfopane)
 {
 this.showInfoSlideShow.delay((500 + this.options.fadeDuration), this);
 } else
 if ((this.options.showCarousel)&&(this.options.activateCarouselScroller))
 this.centerCarouselOn(position);
 }
 }
 },
 initCarousel: function () {
 var carouselElement;
 if (!this.options.useExternalCarousel)
 {
 var carouselContainerElement = new Moo.Element('div').addClass('carouselContainer').injectInside(this.galleryElement);
 this.carouselContainer = new Moo.Fx.Styles(carouselContainerElement, {transition: Moo.Fx.Transitions.expoOut});
 this.carouselContainer.normalHeight = carouselContainerElement.offsetHeight;
 this.carouselContainer.set({'opacity': this.options.carouselMinimizedOpacity, 'top': (this.options.carouselMinimizedHeight - this.carouselContainer.normalHeight)});
 this.carouselBtn = new Moo.Element('a').addClass('carouselBtn').setProperties({
 title: this.options.textShowCarousel
 }).setHTML(this.options.textShowCarousel).injectInside(carouselContainerElement);
 
 this.carouselBtn.addEvent(
 'click',
 function () {
 this.carouselContainer.clearTimer();
 this.toggleCarousel();
 }.bind(this)
 );
 this.carouselActive = false;
 
 carouselElement = new Moo.Element('div').addClass('carousel').injectInside(carouselContainerElement);
 this.carousel = new Moo.Fx.Styles(carouselElement);
 } else {
 carouselElement = this.options.carouselElement.addClass('jdExtCarousel');
 }
 if (this.options.showCarouselLabel)
 this.carouselLabel = new Moo.Element('p').addClass('label').injectInside(carouselElement);
 this.carouselWrapper = new Moo.Element('div').addClass('carouselWrapper').injectInside(carouselElement);
 this.carouselInner = new Moo.Element('div').addClass('carouselInner').injectInside(this.carouselWrapper);
 if (this.options.activateCarouselScroller)
 {
 this.carouselWrapper.scroller = new Moo.Scroller(this.carouselWrapper, {
 area: 100,
 velocity: 0.2
 })
 
 this.carouselWrapper.elementScroller = new Moo.Fx.Scroll(this.carouselWrapper, {
 duration: 400,
 onStart: this.carouselWrapper.scroller.stop.bind(this.carouselWrapper.scroller),
 onComplete: this.carouselWrapper.scroller.start.bind(this.carouselWrapper.scroller)
 });
 }
 this.constructThumbnails();

 this.carouselInner.style.width = ((this.maxIter * (this.options.thumbWidth + this.options.thumbSpacing + 2))+this.options.thumbSpacing) + "px";
 },
 toggleCarousel: function() {
 if (this.carouselActive)
 this.hideCarousel();
 else
 this.showCarousel();
 },
 showCarousel: function () {
 this.fireEvent('onShowCarousel');
 this.carouselContainer.custom({
 'opacity': this.options.carouselMaximizedOpacity,
 'top': 0
 }).addEvent('onComplete', function() { this.carouselActive = true; this.carouselWrapper.scroller.start(); }.bind(this));
 },
 hideCarousel: function () {
 this.fireEvent('onHideCarousel');
 this.carouselContainer.custom({
 'opacity': this.options.carouselMinimizedOpacity,
 'top': (this.options.carouselMinimizedHeight - this.carouselContainer.normalHeight)
 }).addEvent('onComplete', function() { this.carouselActive = false; this.carouselWrapper.scroller.stop(); }.bind(this));
 },
 constructThumbnails: function () {
 element = this.carouselInner;
 for(i=0;i<this.galleryData.length;i++)
 {
 var currentImg = new Moo.Fx.Style(new Moo.Element ('div').addClass("thumbnail").setStyles({
 backgroundImage: "url('" + this.galleryData[i].thumbnail + "')",
 backgroundPosition: "center center",
 backgroundRepeat: 'no-repeat',
 marginLeft: this.options.thumbSpacing + "px",
 width: this.options.thumbWidth + "px",
 height: this.options.thumbHeight + "px"
 }).injectInside(element), "opacity", {duration: 200}).set(0.2);
 currentImg.element.addEvents({
 'mouseover': function (myself) {
 myself.clearTimer();
 myself.custom(0.99);
 if (this.options.showCarouselLabel)
 Moo.$(this.carouselLabel).setHTML('<span class="number">' + (myself.relatedImage.number + 1) + "/" + this.maxIter + ":</span> " + myself.relatedImage.title);
 }.pass(currentImg, this),
 'mouseout': function (myself) {
 myself.clearTimer();
 myself.custom(0.2);
 }.pass(currentImg, this),
 'click': function (myself) {
 this.goTo(myself.relatedImage.number);
 }.pass(currentImg, this)
 });
 
 currentImg.relatedImage = this.galleryData[i];
 this.thumbnailElements[parseInt(i)] = currentImg;
 }
 },
 clearThumbnailsHighlights: function()
 {
 for(i=0;i<this.galleryData.length;i++)
 {
 this.thumbnailElements[i].clearTimer();
 this.thumbnailElements[i].custom(0.2);
 }
 },
 centerCarouselOn: function(num) {
 var carouselElement = this.thumbnailElements[num];
 var position = carouselElement.element.offsetLeft + (carouselElement.element.offsetWidth / 2);
 var carouselWidth = this.carouselWrapper.offsetWidth;
 var carouselInnerWidth = this.carouselInner.offsetWidth;
 var diffWidth = carouselWidth / 2;
 var scrollPos = position-diffWidth;
 this.carouselWrapper.elementScroller.scrollTo(scrollPos,0);
 },
 initInfoSlideshow: function() {
 /*if (this.slideInfoZone.element)
 this.slideInfoZone.element.remove();*/
 this.slideInfoZone = new Moo.Fx.Styles(new Moo.Element('div').addClass('slideInfoZone').injectInside(Moo.$(this.galleryElement))).set({'opacity':0});
 var slideInfoZoneTitle = new Moo.Element('h2').injectInside(this.slideInfoZone.element);
 var slideInfoZoneDescription = new Moo.Element('p').injectInside(this.slideInfoZone.element);
 this.slideInfoZone.normalHeight = this.slideInfoZone.element.offsetHeight;
 this.slideInfoZone.element.setStyle('opacity',0);
 },
 changeInfoSlideShow: function()
 {
 this.hideInfoSlideShow.delay(10, this);
 this.showInfoSlideShow.delay(500, this);
 },
 showInfoSlideShow: function() {
 this.fireEvent('onShowInfopane');
 this.slideInfoZone.clearTimer();
 element = this.slideInfoZone.element;
 element.getElement('h2').setHTML(this.galleryData[this.currentIter].title);
 element.getElement('p').setHTML(this.galleryData[this.currentIter].description);
 if(this.options.slideInfoZoneSlide)
 this.slideInfoZone.custom({'opacity': [0, this.options.slideInfoZoneOpacity], 'height': [0, this.slideInfoZone.normalHeight]});
 else
 this.slideInfoZone.custom({'opacity': [0, this.options.slideInfoZoneOpacity]});
 if (this.options.showCarousel)
 this.slideInfoZone.chain(this.centerCarouselOn.pass(this.currentIter, this));
 return this.slideInfoZone;
 },
 hideInfoSlideShow: function() {
 this.fireEvent('onHideInfopane');
 this.slideInfoZone.clearTimer();
 if(this.options.slideInfoZoneSlide)
 this.slideInfoZone.custom({'opacity': 0, 'height': 0});
 else
 this.slideInfoZone.custom({'opacity': 0});
 return this.slideInfoZone;
 },
 makeLink: function(num) {
 this.currentLink.setProperties({
 href: this.galleryData[num].link,
 title: this.galleryData[num].linkTitle
 })
 if (!((this.options.embedLinks) && (!this.options.showArrows) && (!this.options.showCarousel)))
 this.currentLink.setStyle('display', 'block');
 },
 clearLink: function() {
 this.currentLink.setProperties({href: '', title: ''});
 if (!((this.options.embedLinks) && (!this.options.showArrows) && (!this.options.showCarousel)))
 this.currentLink.setStyle('display', 'none');
 },
 /* Plugins: HistoryManager */
 initHistory: function() {
 this.historyKey = this.galleryElement.id + '-picture';
 if (this.options.customHistoryKey)
 this.historyKey = this.options.customHistoryKey();
 this.history = HistoryManager.register(
 this.historyKey,
 [1],
 function(values) {
 if (parseInt(values[0])-1 < this.maxIter)
 this.goTo(parseInt(values[0])-1);
 }.bind(this),
 function(values) {
 return [this.historyKey, '(', values[0], ')'].join('');
 }.bind(this),
 this.historyKey + '\\((\\d+)\\)');
 this.addEvent('onChanged', function(){
 this.history.setValue(0, this.currentIter+1);
 }.bind(this));
 }
});
gallery.implement(new Moo.Events);
gallery.implement(new Moo.Options);

/* All code copyright 2006 Jonathan Schemoul */
/*
* Really easy field validation with Prototype
* http://tetlaw.id.au/view/javascript/really-easy-field-validation
* Andrew Tetlaw
* Version 1.5.4.1 (2007-01-05)
*
* Copyright (c) 2007 Andrew Tetlaw
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
var Validator = Class.create();

Validator.prototype = {
 initialize : function(className, error, test, options) {
 if(typeof test == 'function'){
 this.options = $H(options);
 this._test = test;
 } else {
 this.options = $H(test);
 this._test = function(){return true};
 }
 this.error = error || 'Validation failed.';
 this.className = className;
 },
 test : function(v, elm) {
 return (this._test(v,elm) && this.options.all(function(p){
 return Validator.methods[p.key] ? Validator.methods[p.key](v,elm,p.value) : true;
 }));
 }
}
Validator.methods = {
 pattern : function(v,elm,opt) {return Validation.get('IsEmpty').test(v) || opt.test(v)},
 minLength : function(v,elm,opt) {return v.length >= opt},
 maxLength : function(v,elm,opt) {return v.length <= opt},
 min : function(v,elm,opt) {return v >= parseFloat(opt)},
 max : function(v,elm,opt) {return v <= parseFloat(opt)},
 notOneOf : function(v,elm,opt) {return $A(opt).all(function(value) {
 return v != value;
 })},
 oneOf : function(v,elm,opt) {return $A(opt).any(function(value) {
 return v == value;
 })},
 is : function(v,elm,opt) {return v == opt},
 isNot : function(v,elm,opt) {return v != opt},
 equalToField : function(v,elm,opt) {return v == $F(opt)},
 notEqualToField : function(v,elm,opt) {return v != $F(opt)},
 include : function(v,elm,opt) {return $A(opt).all(function(value) {
 return Validation.get(value).test(v,elm);
 })}
}

var Validation = Class.create();
Validation.defaultOptions = {
 onSubmit : true,
 stopOnFirst : false,
 immediate : false,
 focusOnError : true,
 useTitles : false,
 addClassNameToContainer: false,
 containerClassName: '.input-box',
 onFormValidate : function(result, form) {},
 onElementValidate : function(result, elm) {}
};

Validation.prototype = {
 initialize : function(form, options){
 this.form = $(form);
 if (!this.form) {
 return;
 }
 this.options = Object.extend({
 onSubmit : Validation.defaultOptions.onSubmit,
 stopOnFirst : Validation.defaultOptions.stopOnFirst,
 immediate : Validation.defaultOptions.immediate,
 focusOnError : Validation.defaultOptions.focusOnError,
 useTitles : Validation.defaultOptions.useTitles,
 onFormValidate : Validation.defaultOptions.onFormValidate,
 onElementValidate : Validation.defaultOptions.onElementValidate
 }, options || {});
 if(this.options.onSubmit) Event.observe(this.form,'submit',this.onSubmit.bind(this),false);
 if(this.options.immediate) {
 Form.getElements(this.form).each(function(input) { // Thanks Mike! 
 if (input.tagName.toLowerCase() == 'select') {
 Event.observe(input, 'blur', this.onChange.bindAsEventListener(this));
 }
 Event.observe(input, 'change', this.onChange.bindAsEventListener(this));
 }, this);
 }
 },
 onChange : function (ev) {
 Validation.isOnChange = true;
 Validation.validate(Event.element(ev),{
 useTitle : this.options.useTitles, 
 onElementValidate : this.options.onElementValidate
 });
 Validation.isOnChange = false; 
 },
 onSubmit : function(ev){
 if(!this.validate()) Event.stop(ev);
 },
 validate : function() {
 var result = false;
 var useTitles = this.options.useTitles;
 var callback = this.options.onElementValidate;
 try {
 if(this.options.stopOnFirst) {
 result = Form.getElements(this.form).all(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); });
 } else {
 result = Form.getElements(this.form).collect(function(elm) { return Validation.validate(elm,{useTitle : useTitles, onElementValidate : callback}); }).all();
 }
 } catch (e) {

 }
 if(!result && this.options.focusOnError) {
 try{
 Form.getElements(this.form).findAll(function(elm){return $(elm).hasClassName('validation-failed')}).first().focus()
 }
 catch(e){

 }
 }
 this.options.onFormValidate(result, this.form);
 return result;
 },
 reset : function() {
 Form.getElements(this.form).each(Validation.reset);
 }
}

Object.extend(Validation, {
 validate : function(elm, options){
 options = Object.extend({
 useTitle : false,
 onElementValidate : function(result, elm) {}
 }, options || {});
 elm = $(elm);

 var cn = $w(elm.className);
 return result = cn.all(function(value) {
 var test = Validation.test(value,elm,options.useTitle);
 options.onElementValidate(test, elm);
 return test;
 });
 },
 insertAdvice : function(elm, advice){
 var container = $(elm).up('.field-row');
 if(container){
 Element.insert(container, {after: advice});
 } else if (elm.up('td.value')) {
 elm.up('td.value').insert({bottom: advice});
 } else if (elm.advaiceContainer && $(elm.advaiceContainer)) {
 $(elm.advaiceContainer).update(advice);
 }
 else {
 switch (elm.type.toLowerCase()) {
 case 'checkbox':
 case 'radio':
 var p = elm.parentNode;
 if(p) {
 Element.insert(p, {'bottom': advice});
 } else {
 Element.insert(elm, {'after': advice});
 }
 break;
 default:
 Element.insert(elm, {'after': advice});
 }
 }
 },
 showAdvice : function(elm, advice, adviceName){
 if(!elm.advices){
 elm.advices = new Hash();
 }
 else{
 elm.advices.each(function(pair){
 this.hideAdvice(elm, pair.value);
 }.bind(this));
 }
 elm.advices.set(adviceName, advice);
 if(typeof Effect == 'undefined') {
 advice.style.display = 'block';
 } else {
 if(!advice._adviceAbsolutize) {
 new Effect.Appear(advice, {duration : 1 });
 } else {
 Position.absolutize(advice);
 advice.show();
 advice.setStyle({
 'top':advice._adviceTop,
 'left': advice._adviceLeft,
 'width': advice._adviceWidth,
 'z-index': 1000
 });
 advice.addClassName('advice-absolute');
 }
 }
 },
 hideAdvice : function(elm, advice){
 if(advice != null) advice.hide();
 },
 updateCallback : function(elm, status) {
 if (typeof elm.callbackFunction != 'undefined') {
 eval(elm.callbackFunction+'(\''+elm.id+'\',\''+status+'\')');
 }
 },
 ajaxError : function(elm, errorMsg) {
 var name = 'validate-ajax';
 var advice = Validation.getAdvice(name, elm);
 if (advice == null) {
 advice = this.createAdvice(name, elm, false, errorMsg);
 }
 this.showAdvice(elm, advice, 'validate-ajax');
 this.updateCallback(elm, 'failed');

 elm.addClassName('validation-failed');
 elm.addClassName('validate-ajax');
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container && this.allowContainerClassName(elm)) {
 container.removeClassName('validation-passed');
 container.addClassName('validation-error');
 }
 }
 },
 allowContainerClassName: function (elm) {
 if (elm.type == 'radio' || elm.type == 'checkbox') {
 return elm.hasClassName('change-container-classname');
 }
 
 return true;
 },
 test : function(name, elm, useTitle) {
 var v = Validation.get(name);
 var prop = '__advice'+name.camelize();
 try {
 if(Validation.isVisible(elm) && !v.test($F(elm), elm)) {
 //if(!elm[prop]) {
 var advice = Validation.getAdvice(name, elm);
 if (advice == null) {
 advice = this.createAdvice(name, elm, useTitle);
 }
 this.showAdvice(elm, advice, name);
 this.updateCallback(elm, 'failed');
 //}
 elm[prop] = 1;
 if (!elm.advaiceContainer) {
 elm.removeClassName('validation-passed');
 elm.addClassName('validation-failed');
 } 
 
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container && this.allowContainerClassName(elm)) {
 container.removeClassName('validation-passed');
 container.addClassName('validation-error');
 }
 }
 return false;
 } else {
 var advice = Validation.getAdvice(name, elm);
 this.hideAdvice(elm, advice);
 this.updateCallback(elm, 'passed');
 elm[prop] = '';
 elm.removeClassName('validation-failed');
 elm.addClassName('validation-passed');
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container && !container.down('.validation-failed') && this.allowContainerClassName(elm)) {
 if (!Validation.get('IsEmpty').test(elm.value) || !this.isVisible(elm)) { 
 container.addClassName('validation-passed');
 } else {
 container.removeClassName('validation-passed');
 }
 container.removeClassName('validation-error');
 }
 }
 return true;
 }
 } catch(e) {
 throw(e)
 }
 },
 isVisible : function(elm) {
 while(elm.tagName != 'BODY') {
 if(!$(elm).visible()) return false;
 elm = elm.parentNode;
 }
 return true;
 },
 getAdvice : function(name, elm) {
 return $('advice-' + name + '-' + Validation.getElmID(elm)) || $('advice-' + Validation.getElmID(elm));
 },
 createAdvice : function(name, elm, useTitle, customError) {
 var v = Validation.get(name);
 var errorMsg = useTitle ? ((elm && elm.title) ? elm.title : v.error) : v.error;
 if (customError) {
 errorMsg = customError;
 }
 try {
 if (Translator){
 errorMsg = Translator.translate(errorMsg);
 }
 }
 catch(e){}

 advice = '<div class="validation-advice" id="advice-' + name + '-' + Validation.getElmID(elm) +'" style="display:none">' + errorMsg + '</div>'


 Validation.insertAdvice(elm, advice);
 advice = Validation.getAdvice(name, elm);
 if($(elm).hasClassName('absolute-advice')) {
 var dimensions = $(elm).getDimensions();
 var originalPosition = Position.cumulativeOffset(elm);

 advice._adviceTop = (originalPosition[1] + dimensions.height) + 'px';
 advice._adviceLeft = (originalPosition[0]) + 'px';
 advice._adviceWidth = (dimensions.width) + 'px';
 advice._adviceAbsolutize = true;
 }
 return advice;
 },
 getElmID : function(elm) {
 return elm.id ? elm.id : elm.name;
 },
 reset : function(elm) {
 elm = $(elm);
 var cn = $w(elm.className);
 cn.each(function(value) {
 var prop = '__advice'+value.camelize();
 if(elm[prop]) {
 var advice = Validation.getAdvice(value, elm);
 if (advice) {
 advice.hide();
 }
 elm[prop] = '';
 }
 elm.removeClassName('validation-failed');
 elm.removeClassName('validation-passed');
 if (Validation.defaultOptions.addClassNameToContainer && Validation.defaultOptions.containerClassName != '') {
 var container = elm.up(Validation.defaultOptions.containerClassName);
 if (container) {
 container.removeClassName('validation-passed');
 container.removeClassName('validation-error');
 }
 }
 });
 },
 add : function(className, error, test, options) {
 var nv = {};
 nv[className] = new Validator(className, error, test, options);
 Object.extend(Validation.methods, nv);
 },
 addAllThese : function(validators) {
 var nv = {};
 $A(validators).each(function(value) {
 nv[value[0]] = new Validator(value[0], value[1], value[2], (value.length > 3 ? value[3] : {}));
 });
 Object.extend(Validation.methods, nv);
 },
 get : function(name) {
 return Validation.methods[name] ? Validation.methods[name] : Validation.methods['_LikeNoIDIEverSaw_'];
 },
 methods : {
 '_LikeNoIDIEverSaw_' : new Validator('_LikeNoIDIEverSaw_','',{})
 }
});

Validation.add('IsEmpty', '', function(v) {
 return (v == '' || (v == null) || (v.length == 0) || /^\s+$/.test(v)); // || /^\s+$/.test(v));
});

Validation.addAllThese([
 ['validate-select', 'Please select an option.', function(v) {
 return ((v != "none") && (v != null) && (v.length != 0));
 }],
 ['required-entry', 'This is a required field.', function(v) {
 return !Validation.get('IsEmpty').test(v);
 }],
 ['validate-number', 'Please enter a valid number in this field.', function(v) {
 return Validation.get('IsEmpty').test(v) || (!isNaN(parseNumber(v)) && !/^\s+$/.test(parseNumber(v)));
 }],
 ['validate-digits', 'Please use numbers only in this field. please avoid spaces or other characters such as dots or commas.', function(v) {
 return Validation.get('IsEmpty').test(v) || !/[^\d]/.test(v);
 }],
 ['validate-alpha', 'Please use letters only (a-z or A-Z) in this field.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z]+$/.test(v)
 }],
 ['validate-code', 'Please use only letters (a-z), numbers (0-9) or underscore(_) in this field, first character should be a letter.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-z]+[a-z0-9_]+$/.test(v)
 }],
 ['validate-alphanum', 'Please use only letters (a-z or A-Z) or numbers (0-9) only in this field. No spaces or other characters are allowed.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z0-9]+$/.test(v) /*!/\W/.test(v)*/
 }],
 ['validate-street', 'Please use only letters (a-z or A-Z) or numbers (0-9) or spaces and # only in this field.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^[ \w]{3,}([A-Za-z]\.)?([ \w]*\#\d+)?(\r\n| )[ \w]{3,}/.test(v)
 }],
 ['validate-phoneStrict', 'Please enter a valid phone number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/.test(v);
 }],
 ['validate-phoneLax', 'Please enter a valid phone number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^((\d[-. ]?)?((\(\d{3}\))|\d{3}))?[-. ]?\d{3}[-. ]?\d{4}$/.test(v);
 }],
 ['validate-fax', 'Please enter a valid fax number. For example (123) 456-7890 or 123-456-7890.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^(\()?\d{3}(\))?(-|\s)?\d{3}(-|\s)\d{4}$/.test(v);
 }],
 ['validate-date', 'Please enter a valid date.', function(v) {
 var test = new Date(v);
 return Validation.get('IsEmpty').test(v) || !isNaN(test);
 }],
 ['validate-email', 'Please enter a valid email address. For example johndoe@domain.com.', function (v) {
 //return Validation.get('IsEmpty').test(v) || /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/.test(v)
 //return Validation.get('IsEmpty').test(v) || /^[\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9][\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9\.]{1,30}[\!\#$%\*/?|\^\{\}`~&\'\+\-=_a-z0-9]@([a-z0-9_-]{1,30}\.){1,5}[a-z]{2,4}$/i.test(v)
 return Validation.get('IsEmpty').test(v) || /^[a-z0-9,!\#\$%&'\*\+/=\?\^_`\{\|}~-]+(\.[a-z0-9,!#\$%&'\*\+/=\?\^_`\{\|}~-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*\.([a-z]{2,})/i.test(v)
 }],
 ['validate-emailSender', 'Please use only letters (a-z or A-Z), numbers (0-9) , underscore(_) or spaces in this field.', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[a-zA-Z0-9_\s]+$/.test(v)
 }],
 ['validate-password', 'Please enter 6 or more characters. Leading or trailing spaces will be ignored.', function(v) {
 var pass=v.strip(); /*strip leading and trailing spaces*/
 return !(pass.length>0 && pass.length < 6);
 }],
 ['validate-admin-password', 'Please enter 7 or more characters. Password should contain both numeric and alphabetic characters.', function(v) {
 var pass=v.strip();
 if (0 == pass.length) {
 return true;
 }
 if (!(/[a-z]/i.test(v)) || !(/[0-9]/.test(v))) {
 return false;
 }
 return !(pass.length < 7);
 }],
 ['validate-cpassword', 'Please make sure your passwords match.', function(v) {
 if ($('password')) {
 var pass = $('password');
 }
 else {
 var pass = $$('.validate-password').length ? $$('.validate-password')[0] : $$('.validate-admin-password')[0];
 }
 var conf = $('confirmation') ? $('confirmation') : $$('.validate-cpassword')[0];
 return (pass.value == conf.value);
 }],
 ['validate-url', 'Please enter a valid URL. http:// is required', function (v) {
 return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i.test(v)
 }],
 ['validate-clean-url', 'Please enter a valid URL. For example http://www.example.com or www.example.com', function (v) {
 return Validation.get('IsEmpty').test(v) || /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i.test(v) || /^(www)((\.[A-Z0-9][A-Z0-9_-]*)+.(com|org|net|dk|at|us|tv|info|uk|co.uk|biz|se)$)(:(\d+))?\/?/i.test(v)
 }],
 ['validate-identifier', 'Please enter a valid Identifier. For example example-page, example-page.html or anotherlevel/example-page', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[A-Z0-9][A-Z0-9_\/-]+(\.[A-Z0-9_-]+)*$/i.test(v)
 }],
 ['validate-xml-identifier', 'Please enter a valid XML-identifier. For example something_1, block5, id-4', function (v) {
 return Validation.get('IsEmpty').test(v) || /^[A-Z][A-Z0-9_\/-]*$/i.test(v)
 }],
 ['validate-ssn', 'Please enter a valid social security number. For example 123-45-6789.', function(v) {
 return Validation.get('IsEmpty').test(v) || /^\d{3}-?\d{2}-?\d{4}$/.test(v);
 }],
 ['validate-zip', 'Please enter a valid zip code. For example 90602 or 90602-1234.', function(v) {
 return Validation.get('IsEmpty').test(v) || /(^\d{5}$)|(^\d{5}-\d{4}$)/.test(v);
 }],
 ['validate-zip-international', 'Please enter a valid zip code.', function(v) {
 //return Validation.get('IsEmpty').test(v) || /(^[A-z0-9]{2,10}([\s]{0,1}|[\-]{0,1})[A-z0-9]{2,10}$)/.test(v);
 return true;
 }],
 ['validate-date-au', 'Please use this date format: dd/mm/yyyy. For example 17/03/2006 for the 17th of March, 2006.', function(v) {
 if(Validation.get('IsEmpty').test(v)) return true;
 var regex = /^(\d{2})\/(\d{2})\/(\d{4})$/;
 if(!regex.test(v)) return false;
 var d = new Date(v.replace(regex, '$2/$1/$3'));
 return ( parseInt(RegExp.$2, 10) == (1+d.getMonth()) ) &&
 (parseInt(RegExp.$1, 10) == d.getDate()) &&
 (parseInt(RegExp.$3, 10) == d.getFullYear() );
 }],
 ['validate-currency-dollar', 'Please enter a valid $ amount. For example $100.00.', function(v) {
 // [$]1[##][,###]+[.##]
 // [$]1###+[.##]
 // [$]0.##
 // [$].##
 return Validation.get('IsEmpty').test(v) || /^\$?\-?([1-9]{1}[0-9]{0,2}(\,[0-9]{3})*(\.[0-9]{0,2})?|[1-9]{1}\d*(\.[0-9]{0,2})?|0(\.[0-9]{0,2})?|(\.[0-9]{1,2})?)$/.test(v)
 }],
 ['validate-one-required', 'Please select one of the above options.', function (v,elm) {
 var p = elm.parentNode;
 var options = p.getElementsByTagName('INPUT');
 return $A(options).any(function(elm) {
 return $F(elm);
 });
 }],
 ['validate-one-required-by-name', 'Please select one of the options.', function (v,elm) {
 var inputs = $$('input[name="' + elm.name.replace(/([\\"])/g, '\\$1') + '"]');
 
 var error = 1;
 for(var i=0;i<inputs.length;i++) {
 if((inputs[i].type == 'checkbox' || inputs[i].type == 'radio') && inputs[i].checked == true) {
 error = 0;
 }
 
 if(Validation.isOnChange && (inputs[i].type == 'checkbox' || inputs[i].type == 'radio')) {
 Validation.reset(inputs[i]);
 }
 }

 if( error == 0 ) {
 return true;
 } else {
 return false;
 }
 }],
 ['validate-not-negative-number', 'Please enter a valid number in this field.', function(v) {
 v = parseNumber(v);
 return (!isNaN(v) && v>=0);
 }],
 ['validate-state', 'Please select State/Province.', function(v) {
 return (v!=0 || v == '');
 }],

 ['validate-new-password', 'Please enter 6 or more characters. Leading or trailing spaces will be ignored.', function(v) {
 if (!Validation.get('validate-password').test(v)) return false;
 if (Validation.get('IsEmpty').test(v) && v != '') return false;
 return true;
 }],
 ['validate-greater-than-zero', 'Please enter a number greater than 0 in this field.', function(v) {
 if(v.length)
 return parseFloat(v) > 0;
 else
 return true;
 }],
 ['validate-zero-or-greater', 'Please enter a number 0 or greater in this field.', function(v) {
 if(v.length)
 return parseFloat(v) >= 0;
 else
 return true;
 }],
 ['validate-cc-number', 'Please enter a valid credit card number.', function(v, elm) {
 // remove non-numerics
 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_number')) + '_cc_type');
 if (ccTypeContainer && typeof Validation.creditCartTypes.get(ccTypeContainer.value) != 'undefined'
 && Validation.creditCartTypes.get(ccTypeContainer.value)[2] == false) {
 if (!Validation.get('IsEmpty').test(v) && Validation.get('validate-digits').test(v)) {
 return true;
 } else {
 return false;
 }
 }
 return validateCreditCard(v);
 }],
 ['validate-cc-type', 'Credit card number doesn\'t match credit card type', function(v, elm) {
 // remove credit card number delimiters such as "-" and space
 elm.value = removeDelimiters(elm.value);
 v = removeDelimiters(v);

 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_number')) + '_cc_type');
 if (!ccTypeContainer) {
 return true;
 }
 var ccType = ccTypeContainer.value;

 if (typeof Validation.creditCartTypes.get(ccType) == 'undefined') {
 return false;
 }

 // Other card type or switch or solo card
 if (Validation.creditCartTypes.get(ccType)[0]==false) {
 return true;
 }

 // Matched credit card type
 var ccMatchedType = '';

 Validation.creditCartTypes.each(function (pair) {
 if (pair.value[0] && v.match(pair.value[0])) {
 ccMatchedType = pair.key;
 throw $break;
 }
 });

 if(ccMatchedType != ccType) {
 return false;
 }
 
 if (ccTypeContainer.hasClassName('validation-failed') && Validation.isOnChange) {
 Validation.validate(ccTypeContainer);
 }

 return true;
 }],
 ['validate-cc-type-select', 'Card type doesn\'t match credit card number', function(v, elm) {
 var ccNumberContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_type')) + '_cc_number');
 if (Validation.isOnChange && Validation.get('IsEmpty').test(ccNumberContainer.value)) {
 return true;
 }
 if (Validation.get('validate-cc-type').test(ccNumberContainer.value, ccNumberContainer)) {
 Validation.validate(ccNumberContainer);
 }
 return Validation.get('validate-cc-type').test(ccNumberContainer.value, ccNumberContainer);
 }],
 ['validate-cc-exp', 'Incorrect credit card expiration date', function(v, elm) {
 var ccExpMonth = v;
 var ccExpYear = $('ccsave_expiration_yr').value;
 var currentTime = new Date();
 var currentMonth = currentTime.getMonth() + 1;
 var currentYear = currentTime.getFullYear();
 if (ccExpMonth < currentMonth && ccExpYear == currentYear) {
 return false;
 }
 return true;
 }],
 ['validate-cc-cvn', 'Please enter a valid credit card verification number.', function(v, elm) {
 var ccTypeContainer = $(elm.id.substr(0,elm.id.indexOf('_cc_cid')) + '_cc_type');
 if (!ccTypeContainer) {
 return true;
 }
 var ccType = ccTypeContainer.value;

 if (typeof Validation.creditCartTypes.get(ccType) == 'undefined') {
 return false;
 }

 var re = Validation.creditCartTypes.get(ccType)[1];

 if (v.match(re)) {
 return true;
 }

 return false;
 }],
 ['validate-ajax', '', function(v, elm) { return true; }],
 ['validate-data', 'Please use only letters (a-z or A-Z), numbers (0-9) or underscore(_) in this field, first character should be a letter.', function (v) {
 if(v != '' && v) {
 return /^[A-Za-z]+[A-Za-z0-9_]+$/.test(v);
 }
 return true;
 }],
 ['validate-css-length', 'Please input a valid CSS-length. For example 100px or 77pt or 20em or .5ex or 50%', function (v) {
 if (v != '' && v) {
 return /^[0-9\.]+(px|pt|em|ex|%)?$/.test(v) && (!(/\..*\./.test(v))) && !(/\.$/.test(v));
 }
 return true;
 }],
 ['validate-length', 'Maximum length exceeded.', function (v, elm) {
 var re = new RegExp(/^maximum-length-[0-9]+$/);
 var result = true;
 $w(elm.className).each(function(name, index) {
 if (name.match(re) && result) {
 var length = name.split('-')[2];
 result = (v.length <= length);
 }
 });
 return result;
 }]
]);


// Credit Card Validation Javascript
// copyright 12th May 2003, by Stephen Chapman, Felgall Pty Ltd

// You have permission to copy and use this javascript provided that
// the content of the script is not changed in any way.

function validateCreditCard(s) {
 // remove non-numerics
 var v = "0123456789";
 var w = "";
 for (i=0; i < s.length; i++) {
 x = s.charAt(i);
 if (v.indexOf(x,0) != -1)
 w += x;
 }
 // validate number
 j = w.length / 2;
 k = Math.floor(j);
 m = Math.ceil(j) - k;
 c = 0;
 for (i=0; i<k; i++) {
 a = w.charAt(i*2+m) * 2;
 c += a > 9 ? Math.floor(a/10 + a%10) : a;
 }
 for (i=0; i<k+m; i++) c += w.charAt(i*2+1-m) * 1;
 return (c%10 == 0);
}

function removeDelimiters (v) {
 v = v.replace(/\s/g, '');
 v = v.replace(/\-/g, '');
 return v;
}

function parseNumber(v)
{
 if (typeof v != 'string') {
 return parseFloat(v);
 }

 var isDot = v.indexOf('.');
 var isComa = v.indexOf(',');

 if (isDot != -1 && isComa != -1) {
 if (isComa > isDot) {
 v = v.replace('.', '').replace(',', '.');
 }
 else {
 v = v.replace(',', '');
 }
 }
 else if (isComa != -1) {
 v = v.replace(',', '.');
 }

 return parseFloat(v);
}

/**
 * Hash with credit card types wich can be simply extended in payment modules
 * 0 - regexp for card number
 * 1 - regexp for cvn
 * 2 - check or not credit card number trough Luhn algorithm by
 * function validateCreditCard wich you can find above in this file
 */
Validation.creditCartTypes = $H({
 'VI': [new RegExp('^4[0-9]{12}([0-9]{3})?$'), new RegExp('^[0-9]{3}$'), true],
 'MC': [new RegExp('^5[1-5][0-9]{14}$'), new RegExp('^[0-9]{3}$'), true],
 'AE': [new RegExp('^3[47][0-9]{13}$'), new RegExp('^[0-9]{4}$'), true],
 'DI': [new RegExp('^6011[0-9]{12}$'), new RegExp('^[0-9]{3}$'), true],
 'SS': [new RegExp('^((6759[0-9]{12})|(49[013][1356][0-9]{13})|(633[34][0-9]{12})|(633110[0-9]{10})|(564182[0-9]{10}))([0-9]{2,3})?$'), new RegExp('^([0-9]{3}|[0-9]{4})?$'), true],
 'OT': [false, new RegExp('^([0-9]{3}|[0-9]{4})?$'), false]
});

// script.aculo.us builder.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Builder = {
 NODEMAP: {
 AREA: 'map',
 CAPTION: 'table',
 COL: 'table',
 COLGROUP: 'table',
 LEGEND: 'fieldset',
 OPTGROUP: 'select',
 OPTION: 'select',
 PARAM: 'object',
 TBODY: 'table',
 TD: 'table',
 TFOOT: 'table',
 TH: 'table',
 THEAD: 'table',
 TR: 'table'
 },
 // note: For Firefox < 1.5, OPTION and OPTGROUP tags are currently broken,
 // due to a Firefox bug
 node: function(elementName) {
 elementName = elementName.toUpperCase();
 
 // try innerHTML approach
 var parentTag = this.NODEMAP[elementName] || 'div';
 var parentElement = document.createElement(parentTag);
 try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
 } catch(e) {}
 var element = parentElement.firstChild || null;
 
 // see if browser added wrapping tags
 if(element && (element.tagName.toUpperCase() != elementName))
 element = element.getElementsByTagName(elementName)[0];
 
 // fallback to createElement approach
 if(!element) element = document.createElement(elementName);
 
 // abort if nothing could be created
 if(!element) return;

 // attributes (or text)
 if(arguments[1])
 if(this._isStringOrNumber(arguments[1]) ||
 (arguments[1] instanceof Array) ||
 arguments[1].tagName) {
 this._children(element, arguments[1]);
 } else {
 var attrs = this._attributes(arguments[1]);
 if(attrs.length) {
 try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" +elementName + " " +
 attrs + "></" + elementName + ">";
 } catch(e) {}
 element = parentElement.firstChild || null;
 // workaround firefox 1.0.X bug
 if(!element) {
 element = document.createElement(elementName);
 for(attr in arguments[1]) 
 element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
 }
 if(element.tagName.toUpperCase() != elementName)
 element = parentElement.getElementsByTagName(elementName)[0];
 }
 } 

 // text, or array of children
 if(arguments[2])
 this._children(element, arguments[2]);

 return element;
 },
 _text: function(text) {
 return document.createTextNode(text);
 },

 ATTR_MAP: {
 'className': 'class',
 'htmlFor': 'for'
 },

 _attributes: function(attributes) {
 var attrs = [];
 for(attribute in attributes)
 attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
 '="' + attributes[attribute].toString().escapeHTML().gsub(/"/,'&quot;') + '"');
 return attrs.join(" ");
 },
 _children: function(element, children) {
 if(children.tagName) {
 element.appendChild(children);
 return;
 }
 if(typeof children=='object') { // array can hold nodes and text
 children.flatten().each( function(e) {
 if(typeof e=='object')
 element.appendChild(e)
 else
 if(Builder._isStringOrNumber(e))
 element.appendChild(Builder._text(e));
 });
 } else
 if(Builder._isStringOrNumber(children))
 element.appendChild(Builder._text(children));
 },
 _isStringOrNumber: function(param) {
 return(typeof param=='string' || typeof param=='number');
 },
 build: function(html) {
 var element = this.node('div');
 $(element).update(html.strip());
 return element.down();
 },
 dump: function(scope) { 
 if(typeof scope != 'object' && typeof scope != 'function') scope = window; //global scope 
 
 var tags = ("A ABBR ACRONYM ADDRESS APPLET AREA B BASE BASEFONT BDO BIG BLOCKQUOTE BODY " +
 "BR BUTTON CAPTION CENTER CITE CODE COL COLGROUP DD DEL DFN DIR DIV DL DT EM FIELDSET " +
 "FONT FORM FRAME FRAMESET H1 H2 H3 H4 H5 H6 HEAD HR HTML I IFRAME IMG INPUT INS ISINDEX "+
 "KBD LABEL LEGEND LI LINK MAP MENU META NOFRAMES NOSCRIPT OBJECT OL OPTGROUP OPTION P "+
 "PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG STYLE SUB SUP TABLE TBODY TD "+
 "TEXTAREA TFOOT TH THEAD TITLE TR TT U UL VAR").split(/\s+/);
 
 tags.each( function(tag){ 
 scope[tag] = function() { 
 return Builder.node.apply(Builder, [tag].concat($A(arguments))); 
 } 
 });
 }
}

// script.aculo.us effects.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
// Justin Palmer (http://encytemedia.com/)
// Mark Pilgrim (http://diveintomark.org/)
// Martin Bialasinki
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/ 

// converts rgb() and #xxx to #xxxxxx format, 
// returns self (or first argument) if not convertable 
String.prototype.parseColor = function() { 
 var color = '#';
 if(this.slice(0,4) == 'rgb(') { 
 var cols = this.slice(4,this.length-1).split(','); 
 var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3); 
 } else { 
 if(this.slice(0,1) == '#') { 
 if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase(); 
 if(this.length==7) color = this.toLowerCase(); 
 } 
 } 
 return(color.length==7 ? color : (arguments[0] || this)); 
}

/*--------------------------------------------------------------------------*/

Element.collectTextNodes = function(element) { 
 return $A($(element).childNodes).collect( function(node) {
 return (node.nodeType==3 ? node.nodeValue : 
 (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
 }).flatten().join('');
}

Element.collectTextNodesIgnoreClass = function(element, className) { 
 return $A($(element).childNodes).collect( function(node) {
 return (node.nodeType==3 ? node.nodeValue : 
 ((node.hasChildNodes() && !Element.hasClassName(node,className)) ? 
 Element.collectTextNodesIgnoreClass(node, className) : ''));
 }).flatten().join('');
}

Element.setContentZoom = function(element, percent) {
 element = $(element); 
 element.setStyle({fontSize: (percent/100) + 'em'}); 
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);
 return element;
}

Element.getInlineOpacity = function(element){
 return $(element).style.opacity || '';
}

Element.forceRerendering = function(element) {
 try {
 element = $(element);
 var n = document.createTextNode(' ');
 element.appendChild(n);
 element.removeChild(n);
 } catch(e) { }
};

/*--------------------------------------------------------------------------*/

Array.prototype.call = function() {
 var args = arguments;
 this.each(function(f){ f.apply(this, args) });
}

/*--------------------------------------------------------------------------*/

var Effect = {
 _elementDoesNotExistError: {
 name: 'ElementDoesNotExistError',
 message: 'The specified DOM element does not exist, but is required for this effect to operate'
 },
 tagifyText: function(element) {
 if(typeof Builder == 'undefined')
 throw("Effect.tagifyText requires including script.aculo.us' builder.js library");
 
 var tagifyStyle = 'position:relative';
 if(Prototype.Browser.IE) tagifyStyle += ';zoom:1';
 
 element = $(element);
 $A(element.childNodes).each( function(child) {
 if(child.nodeType==3) {
 child.nodeValue.toArray().each( function(character) {
 element.insertBefore(
 Builder.node('span',{style: tagifyStyle},
 character == ' ' ? String.fromCharCode(160) : character), 
 child);
 });
 Element.remove(child);
 }
 });
 },
 multiple: function(element, effect) {
 var elements;
 if(((typeof element == 'object') || 
 (typeof element == 'function')) && 
 (element.length))
 elements = element;
 else
 elements = $(element).childNodes;
 
 var options = Object.extend({
 speed: 0.1,
 delay: 0.0
 }, arguments[2] || {});
 var masterDelay = options.delay;

 $A(elements).each( function(element, index) {
 new effect(element, Object.extend(options, { delay: index * options.speed + masterDelay }));
 });
 },
 PAIRS: {
 'slide': ['SlideDown','SlideUp'],
 'blind': ['BlindDown','BlindUp'],
 'appear': ['Appear','Fade']
 },
 toggle: function(element, effect) {
 element = $(element);
 effect = (effect || 'appear').toLowerCase();
 var options = Object.extend({
 queue: { position:'end', scope:(element.id || 'global'), limit: 1 }
 }, arguments[2] || {});
 Effect[element.visible() ? 
 Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
 }
};

var Effect2 = Effect; // deprecated

/* ------------- transitions ------------- */

Effect.Transitions = {
 linear: Prototype.K,
 sinoidal: function(pos) {
 return (-Math.cos(pos*Math.PI)/2) + 0.5;
 },
 reverse: function(pos) {
 return 1-pos;
 },
 flicker: function(pos) {
 var pos = ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
 return (pos > 1 ? 1 : pos);
 },
 wobble: function(pos) {
 return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
 },
 pulse: function(pos, pulses) { 
 pulses = pulses || 5; 
 return (
 Math.round((pos % (1/pulses)) * pulses) == 0 ? 
 ((pos * pulses * 2) - Math.floor(pos * pulses * 2)) : 
 1 - ((pos * pulses * 2) - Math.floor(pos * pulses * 2))
 );
 },
 none: function(pos) {
 return 0;
 },
 full: function(pos) {
 return 1;
 }
};

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create();
Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable), {
 initialize: function() {
 this.effects = [];
 this.interval = null; 
 },
 _each: function(iterator) {
 this.effects._each(iterator);
 },
 add: function(effect) {
 var timestamp = new Date().getTime();
 
 var position = (typeof effect.options.queue == 'string') ? 
 effect.options.queue : effect.options.queue.position;
 
 switch(position) {
 case 'front':
 // move unstarted effects after this effect 
 this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
 e.startOn += effect.finishOn;
 e.finishOn += effect.finishOn;
 });
 break;
 case 'with-last':
 timestamp = this.effects.pluck('startOn').max() || timestamp;
 break;
 case 'end':
 // start effect after last queued effect has finished
 timestamp = this.effects.pluck('finishOn').max() || timestamp;
 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 = setInterval(this.loop.bind(this), 15);
 },
 remove: function(effect) {
 this.effects = this.effects.reject(function(e) { return e==effect });
 if(this.effects.length == 0) {
 clearInterval(this.interval);
 this.interval = null;
 }
 },
 loop: function() {
 var timePos = new Date().getTime();
 for(var i=0, len=this.effects.length;i<len;i++) 
 this.effects[i] && this.effects[i].loop(timePos);
 }
});

Effect.Queues = {
 instances: $H(),
 get: function(queueName) {
 if(typeof queueName != 'string') return queueName;
 
 if(!this.instances[queueName])
 this.instances[queueName] = new Effect.ScopedQueue();
 
 return this.instances[queueName];
 }
}
Effect.Queue = Effect.Queues.get('global');

Effect.DefaultOptions = {
 transition: Effect.Transitions.sinoidal,
 duration: 1.0, // seconds
 fps: 100, // 100= assume 66fps max.
 sync: false, // true for combining
 from: 0.0,
 to: 1.0,
 delay: 0.0,
 queue: 'parallel'
}

Effect.Base = function() {};
Effect.Base.prototype = {
 position: null,
 start: function(options) {
 function codeForEvent(options,eventName){
 return (
 (options[eventName+'Internal'] ? 'this.options.'+eventName+'Internal(this);' : '') +
 (options[eventName] ? 'this.options.'+eventName+'(this);' : '')
 );
 }
 if(options.transition === false) options.transition = Effect.Transitions.linear;
 this.options = Object.extend(Object.extend({},Effect.DefaultOptions), options || {});
 this.currentFrame = 0;
 this.state = 'idle';
 this.startOn = this.options.delay*1000;
 this.finishOn = this.startOn+(this.options.duration*1000);
 this.fromToDelta = this.options.to-this.options.from;
 this.totalTime = this.finishOn-this.startOn;
 this.totalFrames = this.options.fps*this.options.duration;
 
 eval('this.render = function(pos){ '+
 'if(this.state=="idle"){this.state="running";'+
 codeForEvent(options,'beforeSetup')+
 (this.setup ? 'this.setup();':'')+ 
 codeForEvent(options,'afterSetup')+
 '};if(this.state=="running"){'+
 'pos=this.options.transition(pos)*'+this.fromToDelta+'+'+this.options.from+';'+
 'this.position=pos;'+
 codeForEvent(options,'beforeUpdate')+
 (this.update ? 'this.update(pos);':'')+
 codeForEvent(options,'afterUpdate')+
 '}}');
 
 this.event('beforeStart');
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).add(this);
 },
 loop: function(timePos) {
 if(timePos >= this.startOn) {
 if(timePos >= this.finishOn) {
 this.render(1.0);
 this.cancel();
 this.event('beforeFinish');
 if(this.finish) this.finish(); 
 this.event('afterFinish');
 return; 
 }
 var pos = (timePos - this.startOn) / this.totalTime,
 frame = Math.round(pos * this.totalFrames);
 if(frame > this.currentFrame) {
 this.render(pos);
 this.currentFrame = frame;
 }
 }
 },
 cancel: function() {
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).remove(this);
 this.state = 'finished';
 },
 event: function(eventName) {
 if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
 if(this.options[eventName]) this.options[eventName](this);
 },
 inspect: function() {
 var data = $H();
 for(property in this)
 if(typeof this[property] != 'function') data[property] = this[property];
 return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
 }
}

Effect.Parallel = Class.create();
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype), {
 initialize: function(effects) {
 this.effects = effects || [];
 this.start(arguments[1]);
 },
 update: function(position) {
 this.effects.invoke('render', position);
 },
 finish: function(position) {
 this.effects.each( function(effect) {
 effect.render(1.0);
 effect.cancel();
 effect.event('beforeFinish');
 if(effect.finish) effect.finish(position);
 effect.event('afterFinish');
 });
 }
});

Effect.Event = Class.create();
Object.extend(Object.extend(Effect.Event.prototype, Effect.Base.prototype), {
 initialize: function() {
 var options = Object.extend({
 duration: 0
 }, arguments[0] || {});
 this.start(options);
 },
 update: Prototype.emptyFunction
});

Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 // make this work on IE on elements without 'layout'
 if(Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
 this.element.setStyle({zoom: 1});
 var options = Object.extend({
 from: this.element.getOpacity() || 0.0,
 to: 1.0
 }, arguments[1] || {});
 this.start(options);
 },
 update: function(position) {
 this.element.setOpacity(position);
 }
});

Effect.Move = Class.create();
Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 x: 0,
 y: 0,
 mode: 'relative'
 }, arguments[1] || {});
 this.start(options);
 },
 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) 
 this.element.makePositioned();
 this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
 this.originalTop = parseFloat(this.element.getStyle('top') || '0');
 if(this.options.mode == 'absolute') {
 // absolute movement, so we need to calc deltaX and deltaY
 this.options.x = this.options.x - this.originalLeft;
 this.options.y = this.options.y - this.originalTop;
 }
 },
 update: function(position) {
 this.element.setStyle({
 left: Math.round(this.options.x * position + this.originalLeft) + 'px',
 top: Math.round(this.options.y * position + this.originalTop) + 'px'
 });
 }
});

// for backwards compatibility
Effect.MoveBy = function(element, toTop, toLeft) {
 return new Effect.Move(element, 
 Object.extend({ x: toLeft, y: toTop }, arguments[3] || {}));
};

Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype), {
 initialize: function(element, percent) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 scaleX: true,
 scaleY: true,
 scaleContent: true,
 scaleFromCenter: false,
 scaleMode: 'box', // 'box' or 'contents' or {} with provided values
 scaleFrom: 100.0,
 scaleTo: percent
 }, arguments[2] || {});
 this.start(options);
 },
 setup: function() {
 this.restoreAfterFinish = this.options.restoreAfterFinish || false;
 this.elementPositioning = this.element.getStyle('position');
 
 this.originalStyle = {};
 ['top','left','width','height','fontSize'].each( function(k) {
 this.originalStyle[k] = this.element.style[k];
 }.bind(this));
 
 this.originalTop = this.element.offsetTop;
 this.originalLeft = this.element.offsetLeft;
 
 var fontSize = this.element.getStyle('font-size') || '100%';
 ['em','px','%','pt'].each( function(fontSizeType) {
 if(fontSize.indexOf(fontSizeType)>0) {
 this.fontSize = parseFloat(fontSize);
 this.fontSizeType = fontSizeType;
 }
 }.bind(this));
 
 this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
 
 this.dims = null;
 if(this.options.scaleMode=='box')
 this.dims = [this.element.offsetHeight, this.element.offsetWidth];
 if(/^content/.test(this.options.scaleMode))
 this.dims = [this.element.scrollHeight, this.element.scrollWidth];
 if(!this.dims)
 this.dims = [this.options.scaleMode.originalHeight,
 this.options.scaleMode.originalWidth];
 },
 update: function(position) {
 var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
 if(this.options.scaleContent && this.fontSize)
 this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
 this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
 },
 finish: function(position) {
 if(this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
 },
 setDimensions: function(height, width) {
 var d = {};
 if(this.options.scaleX) d.width = Math.round(width) + 'px';
 if(this.options.scaleY) d.height = Math.round(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';
 }
 }
 this.element.setStyle(d);
 }
});

Effect.Highlight = Class.create();
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || {});
 this.start(options);
 },
 setup: function() {
 // Prevent executing on elements not in the layout flow
 if(this.element.getStyle('display')=='none') { this.cancel(); return; }
 // Disable background image during the effect
 this.oldStyle = {};
 if (!this.options.keepBackgroundImage) {
 this.oldStyle.backgroundImage = this.element.getStyle('background-image');
 this.element.setStyle({backgroundImage: 'none'});
 }
 if(!this.options.endcolor)
 this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
 if(!this.options.restorecolor)
 this.options.restorecolor = this.element.getStyle('background-color');
 // init color calculations
 this._base = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
 this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
 },
 update: function(position) {
 this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
 return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart()); }.bind(this)) });
 },
 finish: function() {
 this.element.setStyle(Object.extend(this.oldStyle, {
 backgroundColor: this.options.restorecolor
 }));
 }
});

Effect.ScrollTo = Class.create();
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 this.start(arguments[1] || {});
 },
 setup: function() {
 Position.prepare();
 var offsets = Position.cumulativeOffset(this.element);
 if(this.options.offset) offsets[1] += this.options.offset;
 var max = window.innerHeight ? 
 window.height - window.innerHeight :
 document.body.scrollHeight - 
 (document.documentElement.clientHeight ? 
 document.documentElement.clientHeight : document.body.clientHeight);
 this.scrollStart = Position.deltaY;
 this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
 },
 update: function(position) {
 Position.prepare();
 window.scrollTo(Position.deltaX, 
 this.scrollStart + (position*this.delta));
 }
});

/* ------------- combination effects ------------- */

Effect.Fade = function(element) {
 element = $(element);
 var oldOpacity = element.getInlineOpacity();
 var options = Object.extend({
 from: element.getOpacity() || 1.0,
 to: 0.0,
 afterFinishInternal: function(effect) { 
 if(effect.options.to!=0) return;
 effect.element.hide().setStyle({opacity: oldOpacity}); 
 }}, arguments[1] || {});
 return new Effect.Opacity(element,options);
}

Effect.Appear = function(element) {
 element = $(element);
 var options = Object.extend({
 from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
 to: 1.0,
 // force Safari to render floated elements properly
 afterFinishInternal: function(effect) {
 effect.element.forceRerendering();
 },
 beforeSetup: function(effect) {
 effect.element.setOpacity(effect.options.from).show(); 
 }}, arguments[1] || {});
 return new Effect.Opacity(element,options);
}

Effect.Puff = function(element) {
 element = $(element);
 var oldStyle = { 
 opacity: element.getInlineOpacity(), 
 position: element.getStyle('position'),
 top: element.style.top,
 left: element.style.left,
 width: element.style.width,
 height: element.style.height
 };
 return new Effect.Parallel(
 [ new Effect.Scale(element, 200, 
 { sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }), 
 new Effect.Opacity(element, { sync: true, to: 0.0 } ) ], 
 Object.extend({ duration: 1.0, 
 beforeSetupInternal: function(effect) {
 Position.absolutize(effect.effects[0].element)
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.hide().setStyle(oldStyle); }
 }, arguments[1] || {})
 );
}

Effect.BlindUp = function(element) {
 element = $(element);
 element.makeClipping();
 return new Effect.Scale(element, 0,
 Object.extend({ scaleContent: false, 
 scaleX: false, 
 restoreAfterFinish: true,
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping();
 } 
 }, arguments[1] || {})
 );
}

Effect.BlindDown = function(element) {
 element = $(element);
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, 100, Object.extend({ 
 scaleContent: false, 
 scaleX: false,
 scaleFrom: 0,
 scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
 restoreAfterFinish: true,
 afterSetup: function(effect) {
 effect.element.makeClipping().setStyle({height: '0px'}).show(); 
 }, 
 afterFinishInternal: function(effect) {
 effect.element.undoClipping();
 }
 }, arguments[1] || {}));
}

Effect.SwitchOff = function(element) {
 element = $(element);
 var oldOpacity = element.getInlineOpacity();
 return new Effect.Appear(element, Object.extend({
 duration: 0.4,
 from: 0,
 transition: Effect.Transitions.flicker,
 afterFinishInternal: function(effect) {
 new Effect.Scale(effect.element, 1, { 
 duration: 0.3, scaleFromCenter: true,
 scaleX: false, scaleContent: false, restoreAfterFinish: true,
 beforeSetup: function(effect) { 
 effect.element.makePositioned().makeClipping();
 },
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().undoPositioned().setStyle({opacity: oldOpacity});
 }
 })
 }
 }, arguments[1] || {}));
}

Effect.DropOut = function(element) {
 element = $(element);
 var oldStyle = {
 top: element.getStyle('top'),
 left: element.getStyle('left'),
 opacity: element.getInlineOpacity() };
 return new Effect.Parallel(
 [ new Effect.Move(element, {x: 0, y: 100, sync: true }), 
 new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
 Object.extend(
 { duration: 0.5,
 beforeSetup: function(effect) {
 effect.effects[0].element.makePositioned(); 
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.hide().undoPositioned().setStyle(oldStyle);
 } 
 }, arguments[1] || {}));
}

Effect.Shake = function(element) {
 element = $(element);
 var oldStyle = {
 top: element.getStyle('top'),
 left: element.getStyle('left') };
 return new Effect.Move(element, 
 { x: 20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect) {
 effect.element.undoPositioned().setStyle(oldStyle);
 }}) }}) }}) }}) }}) }});
}

Effect.SlideDown = function(element) {
 element = $(element).cleanWhitespace();
 // SlideDown need to have the content of the element wrapped in a container element with fixed height!
 var oldInnerBottom = element.down().getStyle('bottom');
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, 100, Object.extend({ 
 scaleContent: false, 
 scaleX: false, 
 scaleFrom: window.opera ? 0 : 1,
 scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
 restoreAfterFinish: true,
 afterSetup: function(effect) {
 effect.element.makePositioned();
 effect.element.down().makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping().setStyle({height: '0px'}).show(); 
 },
 afterUpdateInternal: function(effect) {
 effect.element.down().setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px' }); 
 },
 afterFinishInternal: function(effect) {
 effect.element.undoClipping().undoPositioned();
 effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
 }, arguments[1] || {})
 );
}

Effect.SlideUp = function(element) {
 element = $(element).cleanWhitespace();
 var oldInnerBottom = element.down().getStyle('bottom');
 return new Effect.Scale(element, window.opera ? 0 : 1,
 Object.extend({ scaleContent: false, 
 scaleX: false, 
 scaleMode: 'box',
 scaleFrom: 100,
 restoreAfterFinish: true,
 beforeStartInternal: function(effect) {
 effect.element.makePositioned();
 effect.element.down().makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping().show();
 }, 
 afterUpdateInternal: function(effect) {
 effect.element.down().setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px' });
 },
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().undoPositioned().setStyle({bottom: oldInnerBottom});
 effect.element.down().undoPositioned();
 }
 }, arguments[1] || {})
 );
}

// Bug in opera makes the TD containing this element expand for a instance after finish 
Effect.Squish = function(element) {
 return new Effect.Scale(element, window.opera ? 1 : 0, { 
 restoreAfterFinish: true,
 beforeSetup: function(effect) {
 effect.element.makeClipping(); 
 }, 
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping(); 
 }
 });
}

Effect.Grow = function(element) {
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransition: Effect.Transitions.sinoidal,
 scaleTransition: Effect.Transitions.sinoidal,
 opacityTransition: Effect.Transitions.full
 }, arguments[1] || {});
 var oldStyle = {
 top: element.style.top,
 left: element.style.left,
 height: element.style.height,
 width: element.style.width,
 opacity: element.getInlineOpacity() };

 var dims = element.getDimensions(); 
 var initialMoveX, initialMoveY;
 var moveX, moveY;
 
 switch (options.direction) {
 case 'top-left':
 initialMoveX = initialMoveY = moveX = moveY = 0; 
 break;
 case 'top-right':
 initialMoveX = dims.width;
 initialMoveY = moveY = 0;
 moveX = -dims.width;
 break;
 case 'bottom-left':
 initialMoveX = moveX = 0;
 initialMoveY = dims.height;
 moveY = -dims.height;
 break;
 case 'bottom-right':
 initialMoveX = dims.width;
 initialMoveY = dims.height;
 moveX = -dims.width;
 moveY = -dims.height;
 break;
 case 'center':
 initialMoveX = dims.width / 2;
 initialMoveY = dims.height / 2;
 moveX = -dims.width / 2;
 moveY = -dims.height / 2;
 break;
 }
 
 return new Effect.Move(element, {
 x: initialMoveX,
 y: initialMoveY,
 duration: 0.01, 
 beforeSetup: function(effect) {
 effect.element.hide().makeClipping().makePositioned();
 },
 afterFinishInternal: function(effect) {
 new Effect.Parallel(
 [ new Effect.Opacity(effect.element, { sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition }),
 new Effect.Move(effect.element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition }),
 new Effect.Scale(effect.element, 100, {
 scaleMode: { originalHeight: dims.height, originalWidth: dims.width }, 
 sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
 ], Object.extend({
 beforeSetup: function(effect) {
 effect.effects[0].element.setStyle({height: '0px'}).show(); 
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.undoClipping().undoPositioned().setStyle(oldStyle); 
 }
 }, options)
 )
 }
 });
}

Effect.Shrink = function(element) {
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransition: Effect.Transitions.sinoidal,
 scaleTransition: Effect.Transitions.sinoidal,
 opacityTransition: Effect.Transitions.none
 }, arguments[1] || {});
 var oldStyle = {
 top: element.style.top,
 left: element.style.left,
 height: element.style.height,
 width: element.style.width,
 opacity: element.getInlineOpacity() };

 var dims = element.getDimensions();
 var moveX, moveY;
 
 switch (options.direction) {
 case 'top-left':
 moveX = moveY = 0;
 break;
 case 'top-right':
 moveX = dims.width;
 moveY = 0;
 break;
 case 'bottom-left':
 moveX = 0;
 moveY = dims.height;
 break;
 case 'bottom-right':
 moveX = dims.width;
 moveY = dims.height;
 break;
 case 'center': 
 moveX = dims.width / 2;
 moveY = dims.height / 2;
 break;
 }
 
 return new Effect.Parallel(
 [ new Effect.Opacity(element, { sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition }),
 new Effect.Scale(element, window.opera ? 1 : 0, { sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
 new Effect.Move(element, { x: moveX, y: moveY, sync: true, transition: options.moveTransition })
 ], Object.extend({ 
 beforeStartInternal: function(effect) {
 effect.effects[0].element.makePositioned().makeClipping(); 
 },
 afterFinishInternal: function(effect) {
 effect.effects[0].element.hide().undoClipping().undoPositioned().setStyle(oldStyle); }
 }, options)
 );
}

Effect.Pulsate = function(element) {
 element = $(element);
 var options = arguments[1] || {};
 var oldOpacity = element.getInlineOpacity();
 var transition = options.transition || Effect.Transitions.sinoidal;
 var reverser = function(pos){ return transition(1-Effect.Transitions.pulse(pos, options.pulses)) };
 reverser.bind(transition);
 return new Effect.Opacity(element, 
 Object.extend(Object.extend({ duration: 2.0, from: 0,
 afterFinishInternal: function(effect) { effect.element.setStyle({opacity: oldOpacity}); }
 }, options), {transition: reverser}));
}

Effect.Fold = function(element) {
 element = $(element);
 var oldStyle = {
 top: element.style.top,
 left: element.style.left,
 width: element.style.width,
 height: element.style.height };
 element.makeClipping();
 return new Effect.Scale(element, 5, Object.extend({ 
 scaleContent: false,
 scaleX: false,
 afterFinishInternal: function(effect) {
 new Effect.Scale(element, 1, { 
 scaleContent: false, 
 scaleY: false,
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().setStyle(oldStyle);
 } });
 }}, arguments[1] || {}));
};

Effect.Morph = Class.create();
Object.extend(Object.extend(Effect.Morph.prototype, Effect.Base.prototype), {
 initialize: function(element) {
 this.element = $(element);
 if(!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 style: {}
 }, arguments[1] || {});
 if (typeof options.style == 'string') {
 if(options.style.indexOf(':') == -1) {
 var cssText = '', selector = '.' + options.style;
 $A(document.styleSheets).reverse().each(function(styleSheet) {
 if (styleSheet.cssRules) cssRules = styleSheet.cssRules;
 else if (styleSheet.rules) cssRules = styleSheet.rules;
 $A(cssRules).reverse().each(function(rule) {
 if (selector == rule.selectorText) {
 cssText = rule.style.cssText;
 throw $break;
 }
 });
 if (cssText) throw $break;
 });
 this.style = cssText.parseStyle();
 options.afterFinishInternal = function(effect){
 effect.element.addClassName(effect.options.style);
 effect.transforms.each(function(transform) {
 if(transform.style != 'opacity')
 effect.element.style[transform.style] = '';
 });
 }
 } else this.style = options.style.parseStyle();
 } else this.style = $H(options.style)
 this.start(options);
 },
 setup: function(){
 function parseColor(color){
 if(!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
 color = color.parseColor();
 return $R(0,2).map(function(i){
 return parseInt( color.slice(i*2+1,i*2+3), 16 ) 
 });
 }
 this.transforms = this.style.map(function(pair){
 var property = pair[0], value = pair[1], unit = null;

 if(value.parseColor('#zzzzzz') != '#zzzzzz') {
 value = value.parseColor();
 unit = 'color';
 } else if(property == 'opacity') {
 value = parseFloat(value);
 if(Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
 this.element.setStyle({zoom: 1});
 } else if(Element.CSS_LENGTH.test(value)) {
 var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
 value = parseFloat(components[1]);
 unit = (components.length == 3) ? components[2] : null;
 }

 var originalValue = this.element.getStyle(property);
 return { 
 style: property.camelize(), 
 originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0), 
 targetValue: unit=='color' ? parseColor(value) : value,
 unit: unit
 };
 }.bind(this)).reject(function(transform){
 return (
 (transform.originalValue == transform.targetValue) ||
 (
 transform.unit != 'color' &&
 (isNaN(transform.originalValue) || isNaN(transform.targetValue))
 )
 )
 });
 },
 update: function(position) {
 var style = {}, transform, i = this.transforms.length;
 while(i--)
 style[(transform = this.transforms[i]).style] = 
 transform.unit=='color' ? '#'+
 (Math.round(transform.originalValue[0]+
 (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
 (Math.round(transform.originalValue[1]+
 (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
 (Math.round(transform.originalValue[2]+
 (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
 transform.originalValue + Math.round(
 ((transform.targetValue - transform.originalValue) * position) * 1000)/1000 + transform.unit;
 this.element.setStyle(style, true);
 }
});

Effect.Transform = Class.create();
Object.extend(Effect.Transform.prototype, {
 initialize: function(tracks){
 this.tracks = [];
 this.options = arguments[1] || {};
 this.addTracks(tracks);
 },
 addTracks: function(tracks){
 tracks.each(function(track){
 var data = $H(track).values().first();
 this.tracks.push($H({
 ids: $H(track).keys().first(),
 effect: Effect.Morph,
 options: { style: data }
 }));
 }.bind(this));
 return this;
 },
 play: function(){
 return new Effect.Parallel(
 this.tracks.map(function(track){
 var elements = [$(track.ids) || $$(track.ids)].flatten();
 return elements.map(function(e){ return new track.effect(e, Object.extend({ sync:true }, track.options)) });
 }).flatten(),
 this.options
 );
 }
});

Element.CSS_PROPERTIES = $w(
 'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' + 
 'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
 'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
 'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
 'fontSize fontWeight height left letterSpacing lineHeight ' +
 'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
 'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
 'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
 'right textIndent top width wordSpacing zIndex');
 
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.prototype.parseStyle = function(){
 var element = document.createElement('div');
 element.innerHTML = '<div style="' + this + '"></div>';
 var style = element.childNodes[0].style, styleRules = $H();
 
 Element.CSS_PROPERTIES.each(function(property){
 if(style[property]) styleRules[property] = style[property]; 
 });
 if(Prototype.Browser.IE && this.indexOf('opacity') > -1) {
 styleRules.opacity = this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1];
 }
 return styleRules;
};

Element.morph = function(element, style) {
 new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || {}));
 return element;
};

['getInlineOpacity','forceRerendering','setContentZoom',
 'collectTextNodes','collectTextNodesIgnoreClass','morph'].each( 
 function(f) { Element.Methods[f] = Element[f]; }
);

Element.Methods.visualEffect = function(element, effect, options) {
 s = effect.dasherize().camelize();
 effect_class = s.charAt(0).toUpperCase() + s.substring(1);
 new Effect[effect_class](element, options);
 return $(element);
};

Element.addMethods();
// script.aculo.us dragdrop.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2007 Sammi Williams (http://www.oriontransfer.co.nz, sammi@oriontransfer.co.nz)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(typeof Effect == 'undefined')
 throw("dragdrop.js requires including script.aculo.us' effects.js library");

var Droppables = {
 drops: [],

 remove: function(element) {
 this.drops = this.drops.reject(function(d) { return d.element==$(element) });
 },

 add: function(element) {
 element = $(element);
 var options = Object.extend({
 greedy: true,
 hoverclass: null,
 tree: false
 }, arguments[1] || {});

 // cache containers
 if(options.containment) {
 options._containers = [];
 var containment = options.containment;
 if((typeof containment == 'object') &&
 (containment.constructor == Array)) {
 containment.each( function(c) { options._containers.push($(c)) });
 } else {
 options._containers.push($(containment));
 }
 }

 if(options.accept) options.accept = [options.accept].flatten();

 Element.makePositioned(element); // fix IE
 options.element = element;

 this.drops.push(options);
 },

 findDeepestChild: function(drops) {
 deepest = drops[0];

 for (i = 1; i < drops.length; ++i)
 if (Element.isParent(drops[i].element, deepest.element))
 deepest = drops[i];

 return deepest;
 },

 isContained: function(element, drop) {
 var containmentNode;
 if(drop.tree) {
 containmentNode = element.treeNode;
 } else {
 containmentNode = element.parentNode;
 }
 return drop._containers.detect(function(c) { return containmentNode == c });
 },

 isAffected: function(point, element, drop) {
 return (
 (drop.element!=element) &&
 ((!drop._containers) ||
 this.isContained(element, drop)) &&
 ((!drop.accept) ||
 (Element.classNames(element).detect(
 function(v) { return drop.accept.include(v) } ) )) &&
 Position.within(drop.element, point[0], point[1]) );
 },

 deactivate: function(drop) {
 if(drop.hoverclass)
 Element.removeClassName(drop.element, drop.hoverclass);
 this.last_active = null;
 },

 activate: function(drop) {
 if(drop.hoverclass)
 Element.addClassName(drop.element, drop.hoverclass);
 this.last_active = drop;
 },

 show: function(point, element) {
 if(!this.drops.length) return;
 var affected = [];

 if(this.last_active) this.deactivate(this.last_active);
 this.drops.each( function(drop) {
 if(Droppables.isAffected(point, element, drop))
 affected.push(drop);
 });

 if(affected.length>0) {
 drop = Droppables.findDeepestChild(affected);
 Position.within(drop.element, point[0], point[1]);
 if(drop.onHover)
 drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));

 Droppables.activate(drop);
 }
 },

 fire: function(event, element) {
 if(!this.last_active) return;
 Position.prepare();

 if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
 if (this.last_active.onDrop) {
 this.last_active.onDrop(element, this.last_active.element, event);
 return true;
 }
 },

 reset: function() {
 if(this.last_active)
 this.deactivate(this.last_active);
 }
}

var Draggables = {
 drags: [],
 observers: [],

 register: function(draggable) {
 if(this.drags.length == 0) {
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
 this.eventKeypress = this.keyPress.bindAsEventListener(this);

 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(draggable.element, "mousemove", this.eventMouseMove);
 Event.observe(document, "keypress", this.eventKeypress);
 }
 this.drags.push(draggable);
 },

 unregister: function(draggable) {
 this.drags = this.drags.reject(function(d) { return d==draggable });
 if(this.drags.length == 0) {
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(draggable.element, "mousemove", this.eventMouseMove);
 Event.stopObserving(document, "keypress", this.eventKeypress);
 }
 },

 activate: function(draggable) {
 if(draggable.options.delay) {
 this._timeout = setTimeout(function() {
 Draggables._timeout = null;
 window.focus();
 Draggables.activeDraggable = draggable;
 }.bind(this), draggable.options.delay);
 } else {
 window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
 this.activeDraggable = draggable;
 }
 },

 deactivate: function() {
 this.activeDraggable = null;
 },

 updateDrag: function(event) {
 if(!this.activeDraggable) return;
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 // Mozilla-based browsers fire successive mousemove events with
 // the same coordinates, prevent needless redrawing (moz bug?)
 if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
 this._lastPointer = pointer;

 this.activeDraggable.updateDrag(event, pointer);
 },

 endDrag: function(event) {
 if(this._timeout) {
 clearTimeout(this._timeout);
 this._timeout = null;
 }
 if(!this.activeDraggable) return;
 this._lastPointer = null;
 this.activeDraggable.endDrag(event);
 this.activeDraggable = null;
 },

 keyPress: function(event) {
 if(this.activeDraggable)
 this.activeDraggable.keyPress(event);
 },

 addObserver: function(observer) {
 this.observers.push(observer);
 this._cacheObserverCallbacks();
 },

 removeObserver: function(element) { // element instead of observer fixes mem leaks
 this.observers = this.observers.reject( function(o) { return o.element==element });
 this._cacheObserverCallbacks();
 },

 notify: function(eventName, draggable, event) { // 'onStart', 'onEnd', 'onDrag'
 if(this[eventName+'Count'] > 0)
 this.observers.each( function(o) {
 if(o[eventName]) o[eventName](eventName, draggable, event);
 });
 if(draggable.options[eventName]) draggable.options[eventName](draggable, event);
 },

 _cacheObserverCallbacks: function() {
 ['onStart','onEnd','onDrag'].each( function(eventName) {
 Draggables[eventName+'Count'] = Draggables.observers.select(
 function(o) { return o[eventName]; }
 ).length;
 });
 }
}

/*--------------------------------------------------------------------------*/

var Draggable = Class.create();
Draggable._dragging = {};

Draggable.prototype = {
 initialize: function(element) {
 var defaults = {
 handle: false,
 reverteffect: function(element, top_offset, left_offset) {
 var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
 new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur,
 queue: {scope:'_draggable', position:'end'}
 });
 },
 endeffect: function(element) {
 var toOpacity = typeof element._opacity == 'number' ? element._opacity : 1.0;
 new Effect.Opacity(element, {duration:0.2, from:0.7, to:toOpacity,
 queue: {scope:'_draggable', position:'end'},
 afterFinish: function(){
 Draggable._dragging[element] = false
 }
 });
 },
 zindex: 1000,
 revert: false,
 quiet: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 snap: false, // false, or xy or [x,y] or function(x,y){ return [x,y] }
 delay: 0
 };

 if(!arguments[1] || typeof arguments[1].endeffect == 'undefined')
 Object.extend(defaults, {
 starteffect: function(element) {
 element._opacity = Element.getOpacity(element);
 Draggable._dragging[element] = true;
 new Effect.Opacity(element, {duration:0.2, from:element._opacity, to:0.7});
 }
 });

 var options = Object.extend(defaults, arguments[1] || {});

 this.element = $(element);

 if(options.handle && (typeof options.handle == 'string'))
 this.handle = this.element.down('.'+options.handle, 0);

 if(!this.handle) this.handle = $(options.handle);
 if(!this.handle) this.handle = this.element;

 if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML) {
 options.scroll = $(options.scroll);
 this._isScrollChild = Element.childOf(this.element, options.scroll);
 }

 Element.makePositioned(this.element); // fix IE

 this.delta = this.currentDelta();
 this.options = options;
 this.dragging = false;

 this.eventMouseDown = this.initDrag.bindAsEventListener(this);
 Event.observe(this.handle, "mousedown", this.eventMouseDown);

 Draggables.register(this);
 },

 destroy: function() {
 Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
 Draggables.unregister(this);
 },

 currentDelta: function() {
 return([
 parseInt(Element.getStyle(this.element,'left') || '0'),
 parseInt(Element.getStyle(this.element,'top') || '0')]);
 },

 initDrag: function(event) {
 if(typeof Draggable._dragging[this.element] != 'undefined' &&
 Draggable._dragging[this.element]) return;
 if(Event.isLeftClick(event)) {
 // abort on form elements, fixes a Firefox issue
 var src = Event.element(event);
 if((tag_name = src.tagName.toUpperCase()) && (
 tag_name=='INPUT' ||
 tag_name=='SELECT' ||
 tag_name=='OPTION' ||
 tag_name=='BUTTON' ||
 tag_name=='TEXTAREA')) return;

 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var pos = Position.cumulativeOffset(this.element);
 this.offset = [0,1].map( function(i) { return (pointer[i] - pos[i]) });

 Draggables.activate(this);
 Event.stop(event);
 }
 },

 startDrag: function(event) {
 this.dragging = true;

 if(this.options.zindex) {
 this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
 this.element.style.zIndex = this.options.zindex;
 }

 if(this.options.ghosting) {
 this._clone = this.element.cloneNode(true);
 Position.absolutize(this.element);
 this.element.parentNode.insertBefore(this._clone, this.element);
 }

 if(this.options.scroll) {
 if (this.options.scroll == window) {
 var where = this._getWindowScroll(this.options.scroll);
 this.originalScrollLeft = where.left;
 this.originalScrollTop = where.top;
 } else {
 this.originalScrollLeft = this.options.scroll.scrollLeft;
 this.originalScrollTop = this.options.scroll.scrollTop;
 }
 }

 Draggables.notify('onStart', this, event);

 if(this.options.starteffect) this.options.starteffect(this.element);
 },

 updateDrag: function(event, pointer) {
 if(!this.dragging) this.startDrag(event);

 if(!this.options.quiet){
 Position.prepare();
 Droppables.show(pointer, this.element);
 }

 Draggables.notify('onDrag', this, event);

 this.draw(pointer);
 if(this.options.change) this.options.change(this);

 if(this.options.scroll) {
 this.stopScrolling();

 var p;
 if (this.options.scroll == window) {
 with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
 } else {
 p = Position.page(this.options.scroll);
 p[0] += this.options.scroll.scrollLeft + Position.deltaX;
 p[1] += this.options.scroll.scrollTop + Position.deltaY;
 p.push(p[0]+this.options.scroll.offsetWidth);
 p.push(p[1]+this.options.scroll.offsetHeight);
 }
 var speed = [0,0];
 if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
 if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
 if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
 if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
 this.startScrolling(speed);
 }

 // fix AppleWebKit rendering
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);

 Event.stop(event);
 },

 finishDrag: function(event, success) {
 this.dragging = false;

 if(this.options.quiet){
 Position.prepare();
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 Droppables.show(pointer, this.element);
 }

 if(this.options.ghosting) {
 Position.relativize(this.element);
 Element.remove(this._clone);
 this._clone = null;
 }

 var dropped = false;
 if(success) {
 dropped = Droppables.fire(event, this.element);
 if (!dropped) dropped = false;
 }
 if(dropped && this.options.onDropped) this.options.onDropped(this.element);
 Draggables.notify('onEnd', this, event);

 var revert = this.options.revert;
 if(revert && typeof revert == 'function') revert = revert(this.element);

 var d = this.currentDelta();
 if(revert && this.options.reverteffect) {
 if (dropped == 0 || revert != 'failure')
 this.options.reverteffect(this.element,
 d[1]-this.delta[1], d[0]-this.delta[0]);
 } else {
 this.delta = d;
 }

 if(this.options.zindex)
 this.element.style.zIndex = this.originalZ;

 if(this.options.endeffect)
 this.options.endeffect(this.element);

 Draggables.deactivate(this);
 Droppables.reset();
 },

 keyPress: function(event) {
 if(event.keyCode!=Event.KEY_ESC) return;
 this.finishDrag(event, false);
 Event.stop(event);
 },

 endDrag: function(event) {
 if(!this.dragging) return;
 this.stopScrolling();
 this.finishDrag(event, true);
 Event.stop(event);
 },

 draw: function(point) {
 var pos = Position.cumulativeOffset(this.element);
 if(this.options.ghosting) {
 var r = Position.realOffset(this.element);
 pos[0] += r[0] - Position.deltaX; pos[1] += r[1] - Position.deltaY;
 }

 var d = this.currentDelta();
 pos[0] -= d[0]; pos[1] -= d[1];

 if(this.options.scroll && (this.options.scroll != window && this._isScrollChild)) {
 pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
 pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
 }

 var p = [0,1].map(function(i){
 return (point[i]-pos[i]-this.offset[i])
 }.bind(this));

 if(this.options.snap) {
 if(typeof this.options.snap == 'function') {
 p = this.options.snap(p[0],p[1],this);
 } else {
 if(this.options.snap instanceof Array) {
 p = p.map( function(v, i) {
 return Math.round(v/this.options.snap[i])*this.options.snap[i] }.bind(this))
 } else {
 p = p.map( function(v) {
 return Math.round(v/this.options.snap)*this.options.snap }.bind(this))
 }
 }}

 var style = this.element.style;
 if((!this.options.constraint) || (this.options.constraint=='horizontal'))
 style.left = p[0] + "px";
 if((!this.options.constraint) || (this.options.constraint=='vertical'))
 style.top = p[1] + "px";

 if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
 },

 stopScrolling: function() {
 if(this.scrollInterval) {
 clearInterval(this.scrollInterval);
 this.scrollInterval = null;
 Draggables._lastScrollPointer = null;
 }
 },

 startScrolling: function(speed) {
 if(!(speed[0] || speed[1])) return;
 this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
 this.lastScrolled = new Date();
 this.scrollInterval = setInterval(this.scroll.bind(this), 10);
 },

 scroll: function() {
 var current = new Date();
 var delta = current - this.lastScrolled;
 this.lastScrolled = current;
 if(this.options.scroll == window) {
 with (this._getWindowScroll(this.options.scroll)) {
 if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
 var d = delta / 1000;
 this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
 }
 }
 } else {
 this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
 this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
 }

 Position.prepare();
 Droppables.show(Draggables._lastPointer, this.element);
 Draggables.notify('onDrag', this);
 if (this._isScrollChild) {
 Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);
 Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
 Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
 if (Draggables._lastScrollPointer[0] < 0)
 Draggables._lastScrollPointer[0] = 0;
 if (Draggables._lastScrollPointer[1] < 0)
 Draggables._lastScrollPointer[1] = 0;
 this.draw(Draggables._lastScrollPointer);
 }

 if(this.options.change) this.options.change(this);
 },

 _getWindowScroll: function(w) {
 var T, L, W, H;
 with (w.document) {
 if (w.document.documentElement && documentElement.scrollTop) {
 T = documentElement.scrollTop;
 L = documentElement.scrollLeft;
 } else if (w.document.body) {
 T = body.scrollTop;
 L = body.scrollLeft;
 }
 if (w.innerWidth) {
 W = w.innerWidth;
 H = w.innerHeight;
 } else if (w.document.documentElement && documentElement.clientWidth) {
 W = documentElement.clientWidth;
 H = documentElement.clientHeight;
 } else {
 W = body.offsetWidth;
 H = body.offsetHeight
 }
 }
 return { top: T, left: L, width: W, height: H };
 }
}

/*--------------------------------------------------------------------------*/

var SortableObserver = Class.create();
SortableObserver.prototype = {
 initialize: function(element, observer) {
 this.element = $(element);
 this.observer = observer;
 this.lastValue = Sortable.serialize(this.element);
 },

 onStart: function() {
 this.lastValue = Sortable.serialize(this.element);
 },

 onEnd: function() {
 Sortable.unmark();
 if(this.lastValue != Sortable.serialize(this.element))
 this.observer(this.element)
 }
}

var Sortable = {
 SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,

 sortables: {},

 _findRootElement: function(element) {
 while (element.tagName.toUpperCase() != "BODY") {
 if(element.id && Sortable.sortables[element.id]) return element;
 element = element.parentNode;
 }
 },

 options: function(element) {
 element = Sortable._findRootElement($(element));
 if(!element) return;
 return Sortable.sortables[element.id];
 },

 destroy: function(element){
 var s = Sortable.options(element);

 if(s) {
 Draggables.removeObserver(s.element);
 s.droppables.each(function(d){ Droppables.remove(d) });
 s.draggables.invoke('destroy');

 delete Sortable.sortables[s.element.id];
 }
 },

 create: function(element) {
 element = $(element);
 var options = Object.extend({
 element: element,
 tag: 'li', // assumes li children, override with tag: 'tagname'
 dropOnEmpty: false,
 tree: false,
 treeTag: 'ul',
 overlap: 'vertical', // one of 'vertical', 'horizontal'
 constraint: 'vertical', // one of 'vertical', 'horizontal', false
 containment: element, // also takes array of elements (or id's); or false
 handle: false, // or a CSS class
 only: false,
 delay: 0,
 hoverclass: null,
 ghosting: false,
 quiet: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 format: this.SERIALIZE_RULE,

 // these take arrays of elements or ids and can be
 // used for better initialization performance
 elements: false,
 handles: false,

 onChange: Prototype.emptyFunction,
 onUpdate: Prototype.emptyFunction
 }, arguments[1] || {});

 // clear any old sortable with same element
 this.destroy(element);

 // build options for the draggables
 var options_for_draggable = {
 revert: true,
 quiet: options.quiet,
 scroll: options.scroll,
 scrollSpeed: options.scrollSpeed,
 scrollSensitivity: options.scrollSensitivity,
 delay: options.delay,
 ghosting: options.ghosting,
 constraint: options.constraint,
 handle: options.handle };

 if(options.starteffect)
 options_for_draggable.starteffect = options.starteffect;

 if(options.reverteffect)
 options_for_draggable.reverteffect = options.reverteffect;
 else
 if(options.ghosting) options_for_draggable.reverteffect = function(element) {
 element.style.top = 0;
 element.style.left = 0;
 };

 if(options.endeffect)
 options_for_draggable.endeffect = options.endeffect;

 if(options.zindex)
 options_for_draggable.zindex = options.zindex;

 // build options for the droppables
 var options_for_droppable = {
 overlap: options.overlap,
 containment: options.containment,
 tree: options.tree,
 hoverclass: options.hoverclass,
 onHover: Sortable.onHover
 }

 var options_for_tree = {
 onHover: Sortable.onEmptyHover,
 overlap: options.overlap,
 containment: options.containment,
 hoverclass: options.hoverclass
 }

 // fix for gecko engine
 Element.cleanWhitespace(element);

 options.draggables = [];
 options.droppables = [];

 // drop on empty handling
 if(options.dropOnEmpty || options.tree) {
 Droppables.add(element, options_for_tree);
 options.droppables.push(element);
 }

 (options.elements || this.findElements(element, options) || []).each( function(e,i) {
 var handle = options.handles ? $(options.handles[i]) :
 (options.handle ? $(e).getElementsByClassName(options.handle)[0] : e);
 options.draggables.push(
 new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
 Droppables.add(e, options_for_droppable);
 if(options.tree) e.treeNode = element;
 options.droppables.push(e);
 });

 if(options.tree) {
 (Sortable.findTreeElements(element, options) || []).each( function(e) {
 Droppables.add(e, options_for_tree);
 e.treeNode = element;
 options.droppables.push(e);
 });
 }

 // keep reference
 this.sortables[element.id] = options;

 // for onupdate
 Draggables.addObserver(new SortableObserver(element, options.onUpdate));

 },

 // return all suitable-for-sortable elements in a guaranteed order
 findElements: function(element, options) {
 return Element.findChildren(
 element, options.only, options.tree ? true : false, options.tag);
 },

 findTreeElements: function(element, options) {
 return Element.findChildren(
 element, options.only, options.tree ? true : false, options.treeTag);
 },

 onHover: function(element, dropon, overlap) {
 if(Element.isParent(dropon, element)) return;

 if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
 return;
 } else if(overlap>0.5) {
 Sortable.mark(dropon, 'before');
 if(dropon.previousSibling != element) {
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, dropon);
 if(dropon.parentNode!=oldParentNode)
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
 }
 } else {
 Sortable.mark(dropon, 'after');
 var nextElement = dropon.nextSibling || null;
 if(nextElement != element) {
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, nextElement);
 if(dropon.parentNode!=oldParentNode)
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
 }
 }
 },

 onEmptyHover: function(element, dropon, overlap) {
 var oldParentNode = element.parentNode;
 var droponOptions = Sortable.options(dropon);

 if(!Element.isParent(dropon, element)) {
 var index;

 var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
 var child = null;

 if(children) {
 var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);

 for (index = 0; index < children.length; index += 1) {
 if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
 offset -= Element.offsetSize (children[index], droponOptions.overlap);
 } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
 child = index + 1 < children.length ? children[index + 1] : null;
 break;
 } else {
 child = children[index];
 break;
 }
 }
 }

 dropon.insertBefore(element, child);

 Sortable.options(oldParentNode).onChange(element);
 droponOptions.onChange(element);
 }
 },

 unmark: function() {
 if(Sortable._marker) Sortable._marker.hide();
 },

 mark: function(dropon, position) {
 // mark on ghosting only
 var sortable = Sortable.options(dropon.parentNode);
 if(sortable && !sortable.ghosting) return;

 if(!Sortable._marker) {
 Sortable._marker =
 ($('dropmarker') || Element.extend(document.createElement('DIV'))).
 hide().addClassName('dropmarker').setStyle({position:'absolute'});
 document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
 }
 var offsets = Position.cumulativeOffset(dropon);
 Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});

 if(position=='after')
 if(sortable.overlap == 'horizontal')
 Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
 else
 Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});

 Sortable._marker.show();
 },

 _tree: function(element, options, parent) {
 var children = Sortable.findElements(element, options) || [];

 for (var i = 0; i < children.length; ++i) {
 var match = children[i].id.match(options.format);

 if (!match) continue;

 var child = {
 id: encodeURIComponent(match ? match[1] : null),
 element: element,
 parent: parent,
 children: [],
 position: parent.children.length,
 container: $(children[i]).down(options.treeTag)
 }

 /* Get the element containing the children and recurse over it */
 if (child.container)
 this._tree(child.container, options, child)

 parent.children.push (child);
 }

 return parent;
 },

 tree: function(element) {
 element = $(element);
 var sortableOptions = this.options(element);
 var options = Object.extend({
 tag: sortableOptions.tag,
 treeTag: sortableOptions.treeTag,
 only: sortableOptions.only,
 name: element.id,
 format: sortableOptions.format
 }, arguments[1] || {});

 var root = {
 id: null,
 parent: null,
 children: [],
 container: element,
 position: 0
 }

 return Sortable._tree(element, options, root);
 },

 /* Construct a [i] index for a particular node */
 _constructIndex: function(node) {
 var index = '';
 do {
 if (node.id) index = '[' + node.position + ']' + index;
 } while ((node = node.parent) != null);
 return index;
 },

 sequence: function(element) {
 element = $(element);
 var options = Object.extend(this.options(element), arguments[1] || {});

 return $(this.findElements(element, options) || []).map( function(item) {
 return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
 });
 },

 setSequence: function(element, new_sequence) {
 element = $(element);
 var options = Object.extend(this.options(element), arguments[2] || {});

 var nodeMap = {};
 this.findElements(element, options).each( function(n) {
 if (n.id.match(options.format))
 nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
 n.parentNode.removeChild(n);
 });

 new_sequence.each(function(ident) {
 var n = nodeMap[ident];
 if (n) {
 n[1].appendChild(n[0]);
 delete nodeMap[ident];
 }
 });
 },

 serialize: function(element) {
 element = $(element);
 var options = Object.extend(Sortable.options(element), arguments[1] || {});
 var name = encodeURIComponent(
 (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);

 if (options.tree) {
 return Sortable.tree(element, arguments[1]).children.map( function (item) {
 return [name + Sortable._constructIndex(item) + "[id]=" +
 encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
 }).flatten().join('&');
 } else {
 return Sortable.sequence(element, arguments[1]).map( function(item) {
 return name + "[]=" + encodeURIComponent(item);
 }).join('&');
 }
 }
}

// Returns true if child is contained within element
Element.isParent = function(child, element) {
 if (!child.parentNode || child == element) return false;
 if (child.parentNode == element) return true;
 return Element.isParent(child.parentNode, element);
}

Element.findChildren = function(element, only, recursive, tagName) {
 if(!element.hasChildNodes()) return null;
 tagName = tagName.toUpperCase();
 if(only) only = [only].flatten();
 var elements = [];
 $A(element.childNodes).each( function(e) {
 if(e.tagName && e.tagName.toUpperCase()==tagName &&
 (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
 elements.push(e);
 if(recursive) {
 var grandchildren = Element.findChildren(e, only, recursive, tagName);
 if(grandchildren) elements.push(grandchildren);
 }
 });

 return (elements.length>0 ? elements.flatten() : []);
}

Element.offsetSize = function (element, type) {
 return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
}

// script.aculo.us controls.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// (c) 2005-2007 Ivan Krstic (http://blogs.law.harvard.edu/ivan)
// (c) 2005-2007 Jon Tirsen (http://www.tirsen.com)
// Contributors:
// Richard Livsey
// Rahul Bhargava
// Rob Wills
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

// Autocompleter.Base handles all the autocompletion functionality 
// that's independent of the data source for autocompletion. This
// includes drawing the autocompletion menu, observing keyboard
// and mouse events, and similar.
//
// Specific autocompleters need to provide, at the very least, 
// a getUpdatedChoices function that will be invoked every time
// the text inside the monitored textbox changes. This method 
// should get the text for which to provide autocompletion by
// invoking this.getToken(), NOT by directly accessing
// this.element.value. This is to allow incremental tokenized
// autocompletion. Specific auto-completion logic (AJAX, etc)
// belongs in getUpdatedChoices.
//
// Tokenized incremental autocompletion is enabled automatically
// when an autocompleter is instantiated with the 'tokens' option
// in the options parameter, e.g.:
// new Ajax.Autocompleter('id','upd', '/url/', { tokens: ',' });
// will incrementally autocomplete with a comma as the token.
// Additionally, ',' in the above example can be replaced with
// a token array, e.g. { tokens: [',', '\n'] } which
// enables autocompletion on multiple tokens. This is most 
// useful when one of the tokens is \n (a newline), as it 
// allows smart autocompletion after linebreaks.

if(typeof Effect == 'undefined')
 throw("controls.js requires including script.aculo.us' effects.js library");

var Autocompleter = {}
Autocompleter.Base = function() {};
Autocompleter.Base.prototype = {
 baseInitialize: function(element, update, options) {
 element = $(element)
 this.element = element; 
 this.update = $(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';
 Position.clone(element, update, {
 setHeight: false, 
 offsetTop: element.offsetHeight
 });
 }
 Effect.Appear(update,{duration:0.15});
 };
 this.options.onHide = this.options.onHide || 
 function(element, update){ new Effect.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');

 Element.hide(this.update);

 Event.observe(this.element, 'blur', this.onBlur.bindAsEventListener(this));
 Event.observe(this.element, 'keypress', this.onKeyPress.bindAsEventListener(this));

 // Turn autocomplete back on when the user leaves the page, so that the
 // field's value will be remembered on Mozilla-based browsers.
 Event.observe(window, 'beforeunload', function(){ 
 element.setAttribute('autocomplete', 'on'); 
 });
 },

 show: function() {
 if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
 if(!this.iefix && 
 (Prototype.Browser.IE) &&
 (Element.getStyle(this.update, 'position')=='absolute')) {
 new Insertion.After(this.update, 
 '<iframe id="' + this.update.id + '_iefix" '+
 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
 this.iefix = $(this.update.id+'_iefix');
 }
 if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
 },
 
 fixIEOverlapping: function() {
 Position.clone(this.update, this.iefix, {setTop:(!this.update.style.height)});
 this.iefix.style.zIndex = 1;
 this.update.style.zIndex = 2;
 Element.show(this.iefix);
 },

 hide: function() {
 this.stopIndicator();
 if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
 if(this.iefix) Element.hide(this.iefix);
 },

 startIndicator: function() {
 if(this.options.indicator) Element.show(this.options.indicator);
 },

 stopIndicator: function() {
 if(this.options.indicator) Element.hide(this.options.indicator);
 },

 onKeyPress: function(event) {
 if(this.active)
 switch(event.keyCode) {
 case Event.KEY_TAB:
 case Event.KEY_RETURN:
 this.selectEntry();
 Event.stop(event);
 case Event.KEY_ESC:
 this.hide();
 this.active = false;
 Event.stop(event);
 return;
 case Event.KEY_LEFT:
 case Event.KEY_RIGHT:
 return;
 case Event.KEY_UP:
 this.markPrevious();
 this.render();
 if(Prototype.Browser.WebKit) Event.stop(event);
 return;
 case Event.KEY_DOWN:
 this.markNext();
 this.render();
 if(Prototype.Browser.WebKit) Event.stop(event);
 return;
 }
 else 
 if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN || 
 (Prototype.Browser.WebKit > 0 && event.keyCode == 0)) return;

 this.changed = true;
 this.hasFocus = true;

 if(this.observer) clearTimeout(this.observer);
 this.observer = 
 setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
 },

 activate: function() {
 this.changed = false;
 this.hasFocus = true;
 this.getUpdatedChoices();
 },

 onHover: function(event) {
 var element = Event.findElement(event, 'LI');
 if(this.index != element.autocompleteIndex) 
 {
 this.index = element.autocompleteIndex;
 this.render();
 }
 Event.stop(event);
 },
 
 onClick: function(event) {
 var element = Event.findElement(event, 'LI');
 this.index = element.autocompleteIndex;
 this.selectEntry();
 this.hide();
 },
 
 onBlur: function(event) {
 // needed to make click events working
 setTimeout(this.hide.bind(this), 250);
 this.hasFocus = false;
 this.active = false; 
 }, 
 
 render: function() {
 if(this.entryCount > 0) {
 for (var i = 0; i < this.entryCount; i++)
 this.index==i ? 
 Element.addClassName(this.getEntry(i),"selected") : 
 Element.removeClassName(this.getEntry(i),"selected");
 if(this.hasFocus) { 
 this.show();
 this.active = true;
 }
 } else {
 this.active = false;
 this.hide();
 }
 },
 
 markPrevious: function() {
 if(this.index > 0) this.index--
 else this.index = this.entryCount-1;
 this.getEntry(this.index).scrollIntoView(true);
 },
 
 markNext: function() {
 if(this.index < this.entryCount-1) this.index++
 else this.index = 0;
 this.getEntry(this.index).scrollIntoView(false);
 },
 
 getEntry: function(index) {
 return this.update.firstChild.childNodes[index];
 },
 
 getCurrentEntry: function() {
 return this.getEntry(this.index);
 },
 
 selectEntry: function() {
 this.active = false;
 this.updateElement(this.getCurrentEntry());
 },

 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 = Element.collectTextNodes(nodes[0], this.options.select);
 } else
 value = Element.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);
 },

 updateChoices: function(choices) {
 if(!this.changed && this.hasFocus) {
 this.update.innerHTML = choices;
 Element.cleanWhitespace(this.update);
 Element.cleanWhitespace(this.update.down());

 if(this.update.firstChild && this.update.down().childNodes) {
 this.entryCount = 
 this.update.down().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;
 
 if(this.entryCount==1 && this.options.autoSelect) {
 this.selectEntry();
 this.hide();
 } else {
 this.render();
 }
 }
 },

 addObservers: function(element) {
 Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
 Event.observe(element, "click", this.onClick.bindAsEventListener(this));
 },

 onObserverEvent: function() {
 this.changed = false; 
 if(this.getToken().length>=this.options.minChars) {
 this.getUpdatedChoices();
 } else {
 this.active = false;
 this.hide();
 }
 },

 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;
 },

 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;
 }
}

Ajax.Autocompleter = Class.create();
Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype), {
 initialize: function(element, update, url, options) {
 this.baseInitialize(element, update, options);
 this.options.asynchronous = true;
 this.options.onComplete = this.onComplete.bind(this);
 this.options.defaultParams = this.options.parameters || null;
 this.url = url;
 },

 getUpdatedChoices: function() {
 this.startIndicator();
 
 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);
 },

 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.

Autocompleter.Local = Class.create();
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(), {
 initialize: function(element, update, array, options) {
 this.baseInitialize(element, update, options);
 this.options.array = array;
 },

 getUpdatedChoices: function() {
 this.updateChoices(this.options.selector(this));
 },

 setOptions: function(options) {
 this.options = Object.extend({
 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("<li><strong>" + elem.substr(0, entry.length) + "</strong>" + 
 elem.substr(entry.length) + "</li>");
 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("<li>" + elem.substr(0, foundPos) + "<strong>" +
 elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
 foundPos + entry.length) + "</li>");
 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 "<ul>" + ret.join('') + "</ul>";
 }
 }, 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
Field.scrollFreeActivate = function(field) {
 setTimeout(function() {
 Field.activate(field);
 }, 1);
}

Ajax.InPlaceEditor = Class.create();
Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
Ajax.InPlaceEditor.prototype = {
 initialize: function(element, url, options) {
 this.url = url;
 this.element = $(element);

 this.options = Object.extend({
 paramName: "value",
 okButton: true,
 okLink: false,
 okText: "ok",
 cancelButton: false,
 cancelLink: true,
 cancelText: "cancel",
 textBeforeControls: '',
 textBetweenControls: '',
 textAfterControls: '',
 savingText: "Saving...",
 clickToEditText: "Click to edit",
 okText: "ok",
 rows: 1,
 onComplete: function(transport, element) {
 new Effect.Highlight(element, {startcolor: this.options.highlightcolor});
 },
 onFailure: function(transport) {
 alert("Error communicating with the server: " + transport.responseText.stripTags());
 },
 callback: function(form) {
 return Form.serialize(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: {},
 evalScripts: false
 }, options || {});

 if(!this.options.formId && this.element.id) {
 this.options.formId = this.element.id + "-inplaceeditor";
 if ($(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 = $(this.options.externalControl);
 }
 
 this.originalBackground = Element.getStyle(this.element, 'background-color');
 if (!this.originalBackground) {
 this.originalBackground = "transparent";
 }
 
 this.element.title = this.options.clickToEditText;
 
 this.onclickListener = this.enterEditMode.bindAsEventListener(this);
 this.mouseoverListener = this.enterHover.bindAsEventListener(this);
 this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
 Event.observe(this.element, 'click', this.onclickListener);
 Event.observe(this.element, 'mouseover', this.mouseoverListener);
 Event.observe(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl) {
 Event.observe(this.options.externalControl, 'click', this.onclickListener);
 Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
 }
 },
 enterEditMode: function(evt) {
 if (this.saving) return;
 if (this.editing) return;
 this.editing = true;
 this.onEnterEditMode();
 if (this.options.externalControl) {
 Element.hide(this.options.externalControl);
 }
 Element.hide(this.element);
 this.createForm();
 this.element.parentNode.insertBefore(this.form, this.element);
 if (!this.options.loadTextURL) Field.scrollFreeActivate(this.editField);
 // stop the event to avoid a page refresh in Safari
 if (evt) {
 Event.stop(evt);
 }
 return false;
 },
 createForm: function() {
 this.form = document.createElement("form");
 this.form.id = this.options.formId;
 Element.addClassName(this.form, this.options.formClassName)
 this.form.onsubmit = this.onSubmit.bind(this);

 this.createEditField();

 if (this.options.textarea) {
 var br = document.createElement("br");
 this.form.appendChild(br);
 }
 
 if (this.options.textBeforeControls)
 this.form.appendChild(document.createTextNode(this.options.textBeforeControls));

 if (this.options.okButton) {
 var okButton = document.createElement("input");
 okButton.type = "submit";
 okButton.value = this.options.okText;
 okButton.className = 'editor_ok_button';
 this.form.appendChild(okButton);
 }
 
 if (this.options.okLink) {
 var okLink = document.createElement("a");
 okLink.href = "#";
 okLink.appendChild(document.createTextNode(this.options.okText));
 okLink.onclick = this.onSubmit.bind(this);
 okLink.className = 'editor_ok_link';
 this.form.appendChild(okLink);
 }
 
 if (this.options.textBetweenControls && 
 (this.options.okLink || this.options.okButton) && 
 (this.options.cancelLink || this.options.cancelButton))
 this.form.appendChild(document.createTextNode(this.options.textBetweenControls));
 
 if (this.options.cancelButton) {
 var cancelButton = document.createElement("input");
 cancelButton.type = "submit";
 cancelButton.value = this.options.cancelText;
 cancelButton.onclick = this.onclickCancel.bind(this);
 cancelButton.className = 'editor_cancel_button';
 this.form.appendChild(cancelButton);
 }

 if (this.options.cancelLink) {
 var cancelLink = document.createElement("a");
 cancelLink.href = "#";
 cancelLink.appendChild(document.createTextNode(this.options.cancelText));
 cancelLink.onclick = this.onclickCancel.bind(this);
 cancelLink.className = 'editor_cancel editor_cancel_link'; 
 this.form.appendChild(cancelLink);
 }
 
 if (this.options.textAfterControls)
 this.form.appendChild(document.createTextNode(this.options.textAfterControls));
 },
 hasHTMLLineBreaks: function(string) {
 if (!this.options.handleLineBreaks) return false;
 return string.match(/<br/i) || string.match(/<p>/i);
 },
 convertHTMLLineBreaks: function(string) {
 return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
 },
 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 = this.options.paramName;
 textField.value = text;
 textField.style.backgroundColor = this.options.highlightcolor;
 textField.className = 'editor_field';
 var size = this.options.size || this.options.cols || 0;
 if (size != 0) textField.size = size;
 if (this.options.submitOnBlur)
 textField.onblur = this.onSubmit.bind(this);
 this.editField = textField;
 } else {
 this.options.textarea = true;
 var textArea = document.createElement("textarea");
 textArea.obj = this;
 textArea.name = this.options.paramName;
 textArea.value = this.convertHTMLLineBreaks(text);
 textArea.rows = this.options.rows;
 textArea.cols = this.options.cols || 40;
 textArea.className = 'editor_field'; 
 if (this.options.submitOnBlur)
 textArea.onblur = this.onSubmit.bind(this);
 this.editField = textArea;
 }
 
 if(this.options.loadTextURL) {
 this.loadExternalText();
 }
 this.form.appendChild(this.editField);
 },
 getText: function() {
 return this.element.innerHTML;
 },
 loadExternalText: function() {
 Element.addClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = true;
 new Ajax.Request(
 this.options.loadTextURL,
 Object.extend({
 asynchronous: true,
 onComplete: this.onLoadedExternalText.bind(this)
 }, this.options.ajaxOptions)
 );
 },
 onLoadedExternalText: function(transport) {
 Element.removeClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = false;
 this.editField.value = transport.responseText.stripTags();
 Field.scrollFreeActivate(this.editField);
 },
 onclickCancel: function() {
 this.onComplete();
 this.leaveEditMode();
 return false;
 },
 onFailure: function(transport) {
 this.options.onFailure(transport);
 if (this.oldInnerHTML) {
 this.element.innerHTML = this.oldInnerHTML;
 this.oldInnerHTML = null;
 }
 return false;
 },
 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've left edit mode causing Saving...
 // to be displayed indefinitely
 this.onLoading();
 
 if (this.options.evalScripts) {
 new Ajax.Request(
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this),
 asynchronous:true, 
 evalScripts:true
 }, this.options.ajaxOptions));
 } else {
 new Ajax.Updater(
 { success: this.element,
 // don't update on failure (this could be an option)
 failure: null }, 
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this)
 }, this.options.ajaxOptions));
 }
 // stop the event to avoid a page refresh in Safari
 if (arguments.length > 1) {
 Event.stop(arguments[0]);
 }
 return false;
 },
 onLoading: function() {
 this.saving = true;
 this.removeForm();
 this.leaveHover();
 this.showSaving();
 },
 showSaving: function() {
 this.oldInnerHTML = this.element.innerHTML;
 this.element.innerHTML = this.options.savingText;
 Element.addClassName(this.element, this.options.savingClassName);
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 },
 removeForm: function() {
 if(this.form) {
 if (this.form.parentNode) Element.remove(this.form);
 this.form = null;
 }
 },
 enterHover: function() {
 if (this.saving) return;
 this.element.style.backgroundColor = this.options.highlightcolor;
 if (this.effect) {
 this.effect.cancel();
 }
 Element.addClassName(this.element, this.options.hoverClassName)
 },
 leaveHover: function() {
 if (this.options.backgroundColor) {
 this.element.style.backgroundColor = this.oldBackground;
 }
 Element.removeClassName(this.element, this.options.hoverClassName)
 if (this.saving) return;
 this.effect = new Effect.Highlight(this.element, {
 startcolor: this.options.highlightcolor,
 endcolor: this.options.highlightendcolor,
 restorecolor: this.originalBackground
 });
 },
 leaveEditMode: function() {
 Element.removeClassName(this.element, this.options.savingClassName);
 this.removeForm();
 this.leaveHover();
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 if (this.options.externalControl) {
 Element.show(this.options.externalControl);
 }
 this.editing = false;
 this.saving = false;
 this.oldInnerHTML = null;
 this.onLeaveEditMode();
 },
 onComplete: function(transport) {
 this.leaveEditMode();
 this.options.onComplete.bind(this)(transport, this.element);
 },
 onEnterEditMode: function() {},
 onLeaveEditMode: function() {},
 dispose: function() {
 if (this.oldInnerHTML) {
 this.element.innerHTML = this.oldInnerHTML;
 }
 this.leaveEditMode();
 Event.stopObserving(this.element, 'click', this.onclickListener);
 Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl) {
 Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
 Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
 }
 }
};

Ajax.InPlaceCollectionEditor = Class.create();
Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
Object.extend(Ajax.InPlaceCollectionEditor.prototype, {
 createEditField: function() {
 if (!this.cached_selectTag) {
 var selectTag = document.createElement("select");
 var collection = this.options.collection || [];
 var optionTag;
 collection.each(function(e,i) {
 optionTag = document.createElement("option");
 optionTag.value = (e instanceof Array) ? e[0] : e;
 if((typeof this.options.value == 'undefined') && 
 ((e instanceof Array) ? this.element.innerHTML == e[1] : e == optionTag.value)) optionTag.selected = true;
 if(this.options.value==optionTag.value) optionTag.selected = true;
 optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
 selectTag.appendChild(optionTag);
 }.bind(this));
 this.cached_selectTag = selectTag;
 }

 this.editField = this.cached_selectTag;
 if(this.options.loadTextURL) this.loadExternalText();
 this.form.appendChild(this.editField);
 this.options.callback = function(form, value) {
 return "value=" + encodeURIComponent(value);
 }
 }
});

// Delayed observer, like Form.Element.Observer, 
// but waits for delay after last key input
// Ideal for live-search fields

Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype = {
 initialize: function(element, delay, callback) {
 this.delay = delay || 0.5;
 this.element = $(element);
 this.callback = callback;
 this.timer = null;
 this.lastValue = $F(this.element); 
 Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
 },
 delayedListener: function(event) {
 if(this.lastValue == $F(this.element)) return;
 if(this.timer) clearTimeout(this.timer);
 this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
 this.lastValue = $F(this.element);
 },
 onTimerEvent: function() {
 this.timer = null;
 this.callback(this.element, $F(this.element));
 }
};

// script.aculo.us slider.js v1.7.1_beta3, Fri May 25 17:19:41 +0200 2007

// Copyright (c) 2005-2007 Marty Haught, Thomas Fuchs
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

if(!Control) var Control = {};
Control.Slider = Class.create();

// options:
// axis: 'vertical', or 'horizontal' (default)
//
// callbacks:
// onChange(value)
// onSlide(value)
Control.Slider.prototype = {
 initialize: function(handle, track, options) {
 var slider = this;

 if(handle instanceof Array) {
 this.handles = handle.collect( function(e) { return $(e) });
 } else {
 this.handles = [$(handle)];
 }

 this.track = $(track);
 this.options = options || {};

 this.axis = this.options.axis || 'horizontal';
 this.increment = this.options.increment || 1;
 this.step = parseInt(this.options.step || '1');
 this.range = this.options.range || $R(0,1);

 this.value = 0; // assure backwards compat
 this.values = this.handles.map( function() { return 0 });
 this.spans = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;
 this.options.startSpan = $(this.options.startSpan || null);
 this.options.endSpan = $(this.options.endSpan || null);

 this.restricted = this.options.restricted || false;

 this.maximum = this.options.maximum || this.range.end;
 this.minimum = this.options.minimum || this.range.start;

 // Will be used to align the handle onto the track, if necessary
 this.alignX = parseInt(this.options.alignX || '0');
 this.alignY = parseInt(this.options.alignY || '0');

 this.trackLength = this.maximumOffset() - this.minimumOffset();

 this.handleLength = this.isVertical() ?
 (this.handles[0].offsetHeight != 0 ?
 this.handles[0].offsetHeight : this.handles[0].style.height.replace(/px$/,"")) :
 (this.handles[0].offsetWidth != 0 ? this.handles[0].offsetWidth :
 this.handles[0].style.width.replace(/px$/,""));

 this.active = false;
 this.dragging = false;
 this.disabled = false;

 if(this.options.disabled) this.setDisabled();

 // Allowed values array
 this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;
 if(this.allowedValues) {
 this.minimum = this.allowedValues.min();
 this.maximum = this.allowedValues.max();
 }

 this.eventMouseDown = this.startDrag.bindAsEventListener(this);
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.update.bindAsEventListener(this);

 // Initialize handles in reverse (make sure first handle is active)
 this.handles.each( function(h,i) {
 i = slider.handles.length-1-i;
 slider.setValue(parseFloat(
 (slider.options.sliderValue instanceof Array ?
 slider.options.sliderValue[i] : slider.options.sliderValue) ||
 slider.range.start), i);
 Element.makePositioned(h); // fix IE
 Event.observe(h, "mousedown", slider.eventMouseDown);
 });

 Event.observe(this.track, "mousedown", this.eventMouseDown);
 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(this.track.parentNode.parentNode, "mousemove", this.eventMouseMove);

 this.initialized = true;
 },
 dispose: function() {
 var slider = this;
 Event.stopObserving(this.track, "mousedown", this.eventMouseDown);
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(this.track.parentNode.parentNode, "mousemove", this.eventMouseMove);
 this.handles.each( function(h) {
 Event.stopObserving(h, "mousedown", slider.eventMouseDown);
 });
 },
 setDisabled: function(){
 this.disabled = true;
 },
 setEnabled: function(){
 this.disabled = false;
 },
 getNearestValue: function(value){
 if(this.allowedValues){
 if(value >= this.allowedValues.max()) return(this.allowedValues.max());
 if(value <= this.allowedValues.min()) return(this.allowedValues.min());

 var offset = Math.abs(this.allowedValues[0] - value);
 var newValue = this.allowedValues[0];
 this.allowedValues.each( function(v) {
 var currentOffset = Math.abs(v - value);
 if(currentOffset <= offset){
 newValue = v;
 offset = currentOffset;
 }
 });
 return newValue;
 }
 if(value > this.range.end) return this.range.end;
 if(value < this.range.start) return this.range.start;
 return value;
 },
 setValue: function(sliderValue, handleIdx){
 if(!this.active) {
 this.activeHandleIdx = handleIdx || 0;
 this.activeHandle = this.handles[this.activeHandleIdx];
 this.updateStyles();
 }
 handleIdx = handleIdx || this.activeHandleIdx || 0;
 if(this.initialized && this.restricted) {
 if((handleIdx>0) && (sliderValue<this.values[handleIdx-1]))
 sliderValue = this.values[handleIdx-1];
 if((handleIdx < (this.handles.length-1)) && (sliderValue>this.values[handleIdx+1]))
 sliderValue = this.values[handleIdx+1];
 }
 sliderValue = this.getNearestValue(sliderValue);
 this.values[handleIdx] = sliderValue;
 this.value = this.values[0]; // assure backwards compat

 this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] =
 this.translateToPx(sliderValue);

 this.drawSpans();
 if(!this.dragging || !this.event) this.updateFinished();
 },
 setValueBy: function(delta, handleIdx) {
 this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta,
 handleIdx || this.activeHandleIdx || 0);
 },
 translateToPx: function(value) {
 return Math.round(
 ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) *
 (value - this.range.start)) + "px";
 },
 translateToValue: function(offset) {
 return ((offset/(this.trackLength-this.handleLength) *
 (this.range.end-this.range.start)) + this.range.start);
 },
 getRange: function(range) {
 var v = this.values.sortBy(Prototype.K);
 range = range || 0;
 return $R(v[range],v[range+1]);
 },
 minimumOffset: function(){
 return(this.isVertical() ? this.alignY : this.alignX);
 },
 maximumOffset: function(){
 return(this.isVertical() ?
 (this.track.offsetHeight != 0 ? this.track.offsetHeight :
 this.track.style.height.replace(/px$/,"")) - this.alignY :
 (this.track.offsetWidth != 0 ? this.track.offsetWidth :
 this.track.style.width.replace(/px$/,"")) - this.alignY);
 },
 isVertical: function(){
 return (this.axis == 'vertical');
 },
 drawSpans: function() {
 var slider = this;
 if(this.spans)
 $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });
 if(this.options.startSpan)
 this.setSpan(this.options.startSpan,
 $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));
 if(this.options.endSpan)
 this.setSpan(this.options.endSpan,
 $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));
 },
 setSpan: function(span, range) {
 if(this.isVertical()) {
 span.style.top = this.translateToPx(range.start);
 span.style.height = this.translateToPx(range.end - range.start + this.range.start);
 } else {
 span.style.left = this.translateToPx(range.start);
 span.style.width = this.translateToPx(range.end - range.start + this.range.start);
 }
 },
 updateStyles: function() {
 this.handles.each( function(h){ Element.removeClassName(h, 'selected') });
 Element.addClassName(this.activeHandle, 'selected');
 },
 startDrag: function(event) {
 if(Event.isLeftClick(event)) {
 if(!this.disabled){
 this.active = true;

 var handle = Event.element(event);
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var track = handle;
 if(track==this.track) {
 var offsets = Position.cumulativeOffset(this.track);
 this.event = event;
 this.setValue(this.translateToValue(
 (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)
 ));
 var offsets = Position.cumulativeOffset(this.activeHandle);
 this.offsetX = (pointer[0] - offsets[0]);
 this.offsetY = (pointer[1] - offsets[1]);
 } else {
 // find the handle (prevents issues with Safari)
 while((this.handles.indexOf(handle) == -1) && handle.parentNode)
 handle = handle.parentNode;

 if(this.handles.indexOf(handle)!=-1) {
 this.activeHandle = handle;
 this.activeHandleIdx = this.handles.indexOf(this.activeHandle);
 this.updateStyles();

 var offsets = Position.cumulativeOffset(this.activeHandle);
 this.offsetX = (pointer[0] - offsets[0]);
 this.offsetY = (pointer[1] - offsets[1]);
 }
 }
 }
 Event.stop(event);
 }
 },
 update: function(event) {
 if(this.active) {
 if(!this.dragging) this.dragging = true;
 this.draw(event);
 if(Prototype.Browser.WebKit) window.scrollBy(0,0);
 Event.stop(event);
 }
 },
 draw: function(event) {
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var offsets = Position.cumulativeOffset(this.track);
 pointer[0] -= this.offsetX + offsets[0];
 pointer[1] -= this.offsetY + offsets[1];
 this.event = event;
 this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));
 if(this.initialized && this.options.onSlide)
 this.options.onSlide(this.values.length>1 ? this.values : this.value, this);
 },
 endDrag: function(event) {
 if(this.active && this.dragging) {
 this.finishDrag(event, true);
 Event.stop(event);
 }
 this.active = false;
 this.dragging = false;
 },
 finishDrag: function(event, success) {
 this.active = false;
 this.dragging = false;
 this.updateFinished();
 },
 updateFinished: function() {
 if(this.initialized && this.options.onChange)
 this.options.onChange(this.values.length>1 ? this.values : this.value, this);
 this.event = null;
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
function popWin(url,win,para) {
 var win = window.open(url,win,para);
 win.focus();
}

function setLocation(url){
 window.location.href = url;
}

function setPLocation(url, setFocus){
 if( setFocus ) {
 window.opener.focus();
 }
 window.opener.location.href = url;
}

function setLanguageCode(code, fromCode){
 //TODO: javascript cookies have different domain and path than php cookies
 var href = window.location.href;
 var after = '', dash;
 if (dash = href.match(/\#(.*)$/)) {
 href = href.replace(/\#(.*)$/, '');
 after = dash[0];
 }

 if (href.match(/[?]/)) {
 var re = /([?&]store=)[a-z0-9_]*/;
 if (href.match(re)) {
 href = href.replace(re, '$1'+code);
 } else {
 href += '&store='+code;
 }

 var re = /([?&]from_store=)[a-z0-9_]*/;
 if (href.match(re)) {
 href = href.replace(re, '');
 }
 } else {
 href += '?store='+code;
 }
 if (typeof(fromCode) != 'undefined') {
 href += '&from_store='+fromCode;
 }
 href += after;

 setLocation(href);
}

/**
 * Add classes to specified elements.
 * Supported classes are: 'odd', 'even', 'first', 'last'
 *
 * @param elements - array of elements to be decorated
 * [@param decorateParams] - array of classes to be set. If omitted, all available will be used
 */
function decorateGeneric(elements, decorateParams)
{
 var allSupportedParams = ['odd', 'even', 'first', 'last'];
 var _decorateParams = {};
 var total = elements.length;

 if (total) {
 // determine params called
 if (typeof(decorateParams) == 'undefined') {
 decorateParams = allSupportedParams;
 }
 if (!decorateParams.length) {
 return;
 }
 for (var k in allSupportedParams) {
 _decorateParams[allSupportedParams[k]] = false;
 }
 for (var k in decorateParams) {
 _decorateParams[decorateParams[k]] = true;
 }

 // decorate elements
 // elements[0].addClassName('first'); // will cause bug in IE (#5587)
 if (_decorateParams.first) {
 Element.addClassName(elements[0], 'first');
 }
 if (_decorateParams.last) {
 Element.addClassName(elements[total-1], 'last');
 }
 for (var i = 0; i < total; i++) {
 if ((i + 1) % 2 == 0) {
 if (_decorateParams.even) {
 Element.addClassName(elements[i], 'even');
 }
 }
 else {
 if (_decorateParams.odd) {
 Element.addClassName(elements[i], 'odd');
 }
 }
 }
 }
}

/**
 * Decorate table rows and cells, tbody etc
 * @see decorateGeneric()
 */
function decorateTable(table, options) {
 var table = $(table);
 if (table) {
 // set default options
 var _options = {
 'tbody' : false,
 'tbody tr' : ['odd', 'even', 'first', 'last'],
 'thead tr' : ['first', 'last'],
 'tfoot tr' : ['first', 'last'],
 'tr td' : ['last']
 };
 // overload options
 if (typeof(options) != 'undefined') {
 for (var k in options) {
 _options[k] = options[k];
 }
 }
 // decorate
 if (_options['tbody']) {
 decorateGeneric(table.select('tbody'), _options['tbody']);
 }
 if (_options['tbody tr']) {
 decorateGeneric(table.select('tbody tr'), _options['tbody tr']);
 }
 if (_options['thead tr']) {
 decorateGeneric(table.select('thead tr'), _options['thead tr']);
 }
 if (_options['tfoot tr']) {
 decorateGeneric(table.select('tfoot tr'), _options['tfoot tr']);
 }
 if (_options['tr td']) {
 var allRows = table.select('tr');
 if (allRows.length) {
 for (var i = 0; i < allRows.length; i++) {
 decorateGeneric(allRows[i].getElementsByTagName('TD'), _options['tr td']);
 }
 }
 }
 }
}

/**
 * Set "odd", "even" and "last" CSS classes for list items
 * @see decorateGeneric()
 */
function decorateList(list, nonRecursive) {
 if ($(list)) {
 if (typeof(nonRecursive) == 'undefined') {
 var items = $(list).select('li')
 }
 else {
 var items = $(list).childElements();
 }
 decorateGeneric(items, ['odd', 'even', 'last']);
 }
}

/**
 * Set "odd", "even" and "last" CSS classes for list items
 * @see decorateGeneric()
 */
function decorateDataList(list) {
 list = $(list);
 if (list) {
 decorateGeneric(list.select('dt'), ['odd', 'even', 'last']);
 decorateGeneric(list.select('dd'), ['odd', 'even', 'last']);
 }
}

/**
 * Formats currency using patern
 * format - JSON (pattern, decimal, decimalsDelimeter, groupsDelimeter)
 * showPlus - true (always show '+'or '-'),
 * false (never show '-' even if number is negative)
 * null (show '-' if number is negative)
 */

function formatCurrency(price, format, showPlus){
 precision = isNaN(format.precision = Math.abs(format.precision)) ? 2 : format.precision;
 requiredPrecision = isNaN(format.requiredPrecision = Math.abs(format.requiredPrecision)) ? 2 : format.requiredPrecision;

 //precision = (precision > requiredPrecision) ? precision : requiredPrecision;
 //for now we don't need this difference so precision is requiredPrecision
 precision = requiredPrecision;

 integerRequired = isNaN(format.integerRequired = Math.abs(format.integerRequired)) ? 1 : format.integerRequired;

 decimalSymbol = format.decimalSymbol == undefined ? "," : format.decimalSymbol;
 groupSymbol = format.groupSymbol == undefined ? "." : format.groupSymbol;
 groupLength = format.groupLength == undefined ? 3 : format.groupLength;

 if (showPlus == undefined || showPlus == true) {
 s = price < 0 ? "-" : ( showPlus ? "+" : "");
 } else if (showPlus == false) {
 s = '';
 }

 i = parseInt(price = Math.abs(+price || 0).toFixed(precision)) + "";
 pad = (i.length < integerRequired) ? (integerRequired - i.length) : 0;
 while (pad) { i = '0' + i; pad--; }

 j = (j = i.length) > groupLength ? j % groupLength : 0;
 re = new RegExp("(\\d{" + groupLength + "})(?=\\d)", "g");

 /**
 * replace(/-/, 0) is only for fixing Safari bug which appears
 * when Math.abs(0).toFixed() executed on "0" number.
 * Result is "0.-0" :(
 */
 r = (j ? i.substr(0, j) + groupSymbol : "") + i.substr(j).replace(re, "$1" + groupSymbol) + (precision ? decimalSymbol + Math.abs(price - i).toFixed(precision).replace(/-/, 0).slice(2) : "")

 if (format.pattern.indexOf('{sign}') == -1) {
 pattern = s + format.pattern;
 } else {
 pattern = format.pattern.replace('{sign}', s);
 }

 return pattern.replace('%s', r).replace(/^\s\s*/, '').replace(/\s\s*$/, '');
};

function expandDetails(el, childClass) {
 if (Element.hasClassName(el,'show-details')) {
 $$(childClass).each(function(item){item.hide()});
 Element.removeClassName(el,'show-details');
 }
 else {
 $$(childClass).each(function(item){item.show()});
 Element.addClassName(el,'show-details');
 }
}

// Version 1.0
var isIE = navigator.appVersion.match(/MSIE/) == "MSIE";

if (!window.Varien)
 var Varien = new Object();

Varien.showLoading = function(){
 Element.show('loading-process');
}
Varien.hideLoading = function(){
 Element.hide('loading-process');
}
Varien.GlobalHandlers = {
 onCreate: function() {
 Varien.showLoading();
 },

 onComplete: function() {
 if(Ajax.activeRequestCount == 0) {
 Varien.hideLoading();
 }
 }
};

Ajax.Responders.register(Varien.GlobalHandlers);

/**
 * Quick Search form client model
 */
Varien.searchForm = Class.create();
Varien.searchForm.prototype = {
 initialize : function(form, field, emptyText){
 this.form = $(form);
 this.field = $(field);
 this.emptyText = emptyText;

 Event.observe(this.form, 'submit', this.submit.bind(this));
 Event.observe(this.field, 'focus', this.focus.bind(this));
 Event.observe(this.field, 'blur', this.blur.bind(this));
 this.blur();
 },

 submit : function(event){
 if (this.field.value == this.emptyText || this.field.value == ''){
 Event.stop(event);
 return false;
 }
 return true;
 },

 focus : function(event){
 if(this.field.value==this.emptyText){
 this.field.value='';
 }

 },

 blur : function(event){
 if(this.field.value==''){
 this.field.value=this.emptyText;
 }
 },

 initAutocomplete : function(url, destinationElement){
 new Ajax.Autocompleter(
 this.field,
 destinationElement,
 url,
 {
 paramName: this.field.name,
 minChars: 2,
 updateElement: this._selectAutocompleteItem.bind(this),
 onShow : function(element, update) { 
 if(!update.style.position || update.style.position=='absolute') {
 update.style.position = 'absolute';
 Position.clone(element, update, {
 setHeight: false, 
 offsetTop: element.offsetHeight
 });
 }
 Effect.Appear(update,{duration:0});
 }

 }
 );
 },

 _selectAutocompleteItem : function(element){
 if(element.title){
 this.field.value = element.title;
 }
 this.form.submit();
 }
}

Varien.Tabs = Class.create();
Varien.Tabs.prototype = {
 initialize: function(selector) {
 var self=this;
 $$(selector+' a').each(this.initTab.bind(this));
 },

 initTab: function(el) {
 el.href = 'javascript:void(0)';
 if ($(el.parentNode).hasClassName('active')) {
 this.showContent(el);
 }
 el.observe('click', this.showContent.bind(this, el));
 },

 showContent: function(a) {
 var li = $(a.parentNode), ul = $(li.parentNode);
 ul.getElementsBySelector('li', 'ol').each(function(el){
 var contents = $(el.id+'_contents');
 if (el==li) {
 el.addClassName('active');
 contents.show();
 } else {
 el.removeClassName('active');
 contents.hide();
 }
 });
 }
}

Varien.DOB = Class.create();
Varien.DOB.prototype = {
 initialize: function(selector, required, format) {
 var el = $$(selector)[0];
 this.day = Element.select($(el), '.dob-day input')[0];
 this.month = Element.select($(el), '.dob-month input')[0];
 this.year = Element.select($(el), '.dob-year input')[0];
 this.dob = Element.select($(el), '.dob-full input')[0];
 this.advice = Element.select($(el), '.validation-advice')[0];
 this.required = required;
 this.format = format;

 this.day.validate = this.validate.bind(this);
 this.month.validate = this.validate.bind(this);
 this.year.validate = this.validate.bind(this);

 this.advice.hide();
 },

 validate: function() {
 var error = false;

 if (this.day.value=='' && this.month.value=='' && this.year.value=='') {
 if (this.required) {
 error = 'This date is a required value.';
 } else {
 this.dob.value = '';
 }
 } else if (this.day.value=='' || this.month.value=='' || this.year.value=='') {
 error = 'Please enter a valid full date.';
 } else {
 var date = new Date();
 if (this.day.value<1 || this.day.value>31) {
 error = 'Please enter a valid day (1-31).';
 } else if (this.month.value<1 || this.month.value>12) {
 error = 'Please enter a valid month (1-12).';
 } else if (this.year.value<1900 || this.year.value>date.getFullYear()) {
 error = 'Please enter a valid year (1900-'+date.getFullYear()+').';
 } else {
 this.dob.value = this.format.replace(/(%m|%b)/i, this.month.value).replace(/(%d|%e)/i, this.day.value).replace(/%y/i, this.year.value);
 var testDOB = this.month.value + '/' + this.day.value + '/'+ this.year.value;
 var test = new Date(testDOB);
 if (isNaN(test)) {
 error = 'Please enter a valid date.';
 }
 }
 }

 if (error !== false) {
 try {
 this.advice.innerHTML = Translator.translate(error);
 }
 catch (e) {
 this.advice.innerHTML = error;
 }
 this.advice.show();
 return false;
 }

 this.advice.hide();
 return true;
 }
}

Validation.addAllThese([
 ['validate-custom', ' ', function(v,elm) {
 return elm.validate();
 }]
]);

function truncateOptions() {
 $$('.truncated').each(function(element){
 Event.observe(element, 'mouseover', function(){
 if (element.down('div.truncated_full_value')) {
 element.down('div.truncated_full_value').addClassName('show')
 }
 });
 Event.observe(element, 'mouseout', function(){
 if (element.down('div.truncated_full_value')) {
 element.down('div.truncated_full_value').removeClassName('show')
 }
 });

 });
}
Event.observe(window, 'load', function(){
 truncateOptions();
});
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
VarienForm = Class.create();
VarienForm.prototype = {
 initialize: function(formId, firstFieldFocus){
 this.form = $(formId);
 if (!this.form) {
 return;
 }
 this.cache = $A();
 this.currLoader = false;
 this.currDataIndex = false;
 this.validator = new Validation(this.form);
 this.elementFocus = this.elementOnFocus.bindAsEventListener(this);
 this.elementBlur = this.elementOnBlur.bindAsEventListener(this);
 this.childLoader = this.onChangeChildLoad.bindAsEventListener(this);
 this.highlightClass = 'highlight';
 this.extraChildParams = '';
 this.firstFieldFocus= firstFieldFocus || false;
 this.bindElements();
 if(this.firstFieldFocus){
 try{
 Form.Element.focus(Form.findFirstElement(this.form))
 }
 catch(e){}
 }
 },

 submit : function(url){
 if(this.validator && this.validator.validate()){
 this.form.submit();
 }
 return false;
 },

 bindElements:function (){
 var elements = Form.getElements(this.form);
 for (var row in elements) {
 if (elements[row].id) {
 Event.observe(elements[row],'focus',this.elementFocus);
 Event.observe(elements[row],'blur',this.elementBlur);
 }
 }
 },

 elementOnFocus: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element){
 Element.addClassName(element, this.highlightClass);
 }
 },

 elementOnBlur: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element){
 Element.removeClassName(element, this.highlightClass);
 }
 },

 setElementsRelation: function(parent, child, dataUrl, first){
 if (parent=$(parent)) {
 // TODO: array of relation and caching
 if (!this.cache[parent.id]){
 this.cache[parent.id] = $A();
 this.cache[parent.id]['child'] = child;
 this.cache[parent.id]['dataUrl'] = dataUrl;
 this.cache[parent.id]['data'] = $A();
 this.cache[parent.id]['first'] = first || false;
 }
 Event.observe(parent,'change',this.childLoader);
 }
 },

 onChangeChildLoad: function(event){
 element = Event.element(event);
 this.elementChildLoad(element);
 },

 elementChildLoad: function(element, callback){
 this.callback = callback || false;
 if (element.value) {
 this.currLoader = element.id;
 this.currDataIndex = element.value;
 if (this.cache[element.id]['data'][element.value]) {
 this.setDataToChild(this.cache[element.id]['data'][element.value]);
 }
 else{
 new Ajax.Request(this.cache[this.currLoader]['dataUrl'],{
 method: 'post',
 parameters: {"parent":element.value},
 onComplete: this.reloadChildren.bind(this)
 });
 }
 }
 },

 reloadChildren: function(transport){
 var data = eval('(' + transport.responseText + ')');
 this.cache[this.currLoader]['data'][this.currDataIndex] = data;
 this.setDataToChild(data);
 },

 setDataToChild: function(data){
 if (data.length) {
 var child = $(this.cache[this.currLoader]['child']);
 if (child){
 var html = '<select name="'+child.name+'" id="'+child.id+'" class="'+child.className+'" title="'+child.title+'" '+this.extraChildParams+'>';
 if(this.cache[this.currLoader]['first']){
 html+= '<option value="">'+this.cache[this.currLoader]['first']+'</option>';
 }
 for (var i in data){
 if(data[i].value) {
 html+= '<option value="'+data[i].value+'"';
 if(child.value && (child.value == data[i].value || child.value == data[i].label)){
 html+= ' selected';
 }
 html+='>'+data[i].label+'</option>';
 }
 }
 html+= '</select>';
 Element.insert(child, {before: html});
 Element.remove(child);
 }
 }
 else{
 var child = $(this.cache[this.currLoader]['child']);
 if (child){
 var html = '<input type="text" name="'+child.name+'" id="'+child.id+'" class="'+child.className+'" title="'+child.title+'" '+this.extraChildParams+'>';
 Element.insert(child, {before: html});
 Element.remove(child);
 }
 }

 this.bindElements();
 if (this.callback) {
 this.callback();
 }
 }
}

RegionUpdater = Class.create();
RegionUpdater.prototype = {
 initialize: function (countryEl, regionTextEl, regionSelectEl, regions, disableAction)
 {
 this.countryEl = $(countryEl);
 this.regionTextEl = $(regionTextEl);
 this.regionSelectEl = $(regionSelectEl);
 this.regions = regions;

 this.disableAction = (typeof disableAction=='undefined') ? 'hide' : disableAction;

 if (this.regionSelectEl.options.length<=1) {
 this.update();
 }

 Event.observe(this.countryEl, 'change', this.update.bind(this));
 },

 update: function()
 {
 if (this.regions[this.countryEl.value]) {
 var i, option, region, def;

 if (this.regionTextEl) {
 def = this.regionTextEl.value.toLowerCase();
 this.regionTextEl.value = '';
 }
 if (!def) {
 def = this.regionSelectEl.getAttribute('defaultValue');
 }

 this.regionSelectEl.options.length = 1;
 for (regionId in this.regions[this.countryEl.value]) {
 region = this.regions[this.countryEl.value][regionId];

 option = document.createElement('OPTION');
 option.value = regionId;
 option.text = region.name;

 if (this.regionSelectEl.options.add) {
 this.regionSelectEl.options.add(option);
 } else {
 this.regionSelectEl.appendChild(option);
 }

 if (regionId==def || region.name.toLowerCase()==def || region.code.toLowerCase()==def) {
 this.regionSelectEl.value = regionId;
 }
 }

 if (this.disableAction=='hide') {
 if (this.regionTextEl) {
 this.regionTextEl.style.display = 'none';
 }

 this.regionSelectEl.style.display = '';
 } else if (this.disableAction=='disable') {
 if (this.regionTextEl) {
 this.regionTextEl.disabled = true;
 }
 this.regionSelectEl.disabled = false;
 }
 this.setMarkDisplay(this.regionSelectEl, true);
 } else {
 if (this.disableAction=='hide') {
 if (this.regionTextEl) {
 this.regionTextEl.style.display = '';
 }
 this.regionSelectEl.style.display = 'none';
 Validation.reset(this.regionSelectEl);
 } else if (this.disableAction=='disable') {
 if (this.regionTextEl) {
 this.regionTextEl.disabled = false;
 }
 this.regionSelectEl.disabled = true;
 } else if (this.disableAction=='nullify') {
 this.regionSelectEl.options.length = 1;
 this.regionSelectEl.value = '';
 this.regionSelectEl.selectedIndex = 0;
 this.lastCountryId = '';
 }
 this.setMarkDisplay(this.regionSelectEl, false);
 }
 },

 setMarkDisplay: function(elem, display){
 elem = $(elem);
 var labelElement = elem.up(1).down('label > span.required') || 
 elem.up(2).down('label > span.required') ||
 elem.up(1).down('label.required > em') ||
 elem.up(2).down('label.required > em');
 if(labelElement) {
 display ? labelElement.show() : labelElement.hide();
 }
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
function toggleMenu(el, over)
{
 if (over) {
 Element.addClassName(el, 'over');
 }
 else {
 Element.removeClassName(el, 'over');
 }
}

/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @category Mage
 * @package Js
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */

var Translate = Class.create();
Translate.prototype = {
 initialize: function(data){
 this.data = $H(data);
 },

 translate : function(){
 var args = arguments;
 var text = arguments[0];

 if(this.data.get(text)){
 return this.data.get(text);
 }
 return text;
 },
 add : function() {
 if (arguments.length > 1) {
 this.data.set(arguments[0], arguments[1]);
 } else if (typeof arguments[0] =='object') {
 $H(arguments[0]).each(function (pair){
 this.data.set(pair.key, pair.value);
 }.bind(this));
 }
 }
}
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
// old school cookie functions grabbed off the web

if (!window.Mage) var Mage = {};

Mage.Cookies = {};
Mage.Cookies.set = function(name, value){
 var argv = arguments;
 var argc = arguments.length;
 var expires = (argc > 2) ? argv[2] : null;
 var path = (argc > 3) ? argv[3] : '/';
 var domain = (argc > 4) ? argv[4] : null;
 var secure = (argc > 5) ? argv[5] : false;
 document.cookie = name + "=" + escape (value) +
 ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) +
 ((path == null) ? "" : ("; path=" + path)) +
 ((domain == null) ? "" : ("; domain=" + domain)) +
 ((secure == true) ? "; secure" : "");
};

Mage.Cookies.get = function(name){
 var arg = name + "=";
 var alen = arg.length;
 var clen = document.cookie.length;
 var i = 0;
 var j = 0;
 while(i < clen){
 j = i + alen;
 if (document.cookie.substring(i, j) == arg)
 return Mage.Cookies.getCookieVal(j);
 i = document.cookie.indexOf(" ", i) + 1;
 if(i == 0)
 break;
 }
 return null;
};

Mage.Cookies.clear = function(name) {
 if(Mage.Cookies.get(name)){
 document.cookie = name + "=" +
 "; expires=Thu, 01-Jan-70 00:00:01 GMT";
 }
};

Mage.Cookies.getCookieVal = function(offset){
 var endstr = document.cookie.indexOf(";", offset);
 if(endstr == -1){
 endstr = document.cookie.length;
 }
 return unescape(document.cookie.substring(offset, endstr));
};
/**
 * Magento
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Academic Free License (AFL 3.0)
 * that is bundled with this package in the file LICENSE_AFL.txt.
 * It is also available through the world-wide-web at this URL:
 * http://opensource.org/licenses/afl-3.0.php
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@magentocommerce.com so we can send you a copy immediately.
 *
 * DISCLAIMER
 *
 * Do not edit or add to this file if you wish to upgrade Magento to newer
 * versions in the future. If you wish to customize Magento for your
 * needs please refer to http://www.magentocommerce.com for more information.
 *
 * @copyright Copyright (c) 2008 Irubin Consulting Inc. DBA Varien (http://www.varien.com)
 * @license http://opensource.org/licenses/afl-3.0.php Academic Free License (AFL 3.0)
 */
if(typeof Product=='undefined') {
 var Product = {};
}

/********************* IMAGE ZOOMER ***********************/

Product.Zoom = Class.create();
/**
 * Image zoom control
 *
 * @author Magento Core Team <core@magentocommerce.com>
 */
Product.Zoom.prototype = {
 initialize: function(imageEl, trackEl, handleEl, zoomInEl, zoomOutEl, hintEl){
 this.containerEl = $(imageEl).parentNode;
 this.imageEl = $(imageEl);
 this.handleEl = $(handleEl);
 this.trackEl = $(trackEl);
 this.hintEl = $(hintEl);

 this.containerDim = Element.getDimensions(this.containerEl);
 this.imageDim = Element.getDimensions(this.imageEl);

 this.imageDim.ratio = this.imageDim.width/this.imageDim.height;

 this.floorZoom = 1;

 if (this.imageDim.width > this.imageDim.height) {
 this.ceilingZoom = this.imageDim.width / this.containerDim.width;
 } else {
 this.ceilingZoom = this.imageDim.height / this.containerDim.height;
 }

 if (this.imageDim.width <= this.containerDim.width
 && this.imageDim.height <= this.containerDim.height) {
 this.trackEl.up().hide();
 this.hintEl.hide();
 this.containerEl.removeClassName('product-image-zoom');
 return;
 }

 this.imageX = 0;
 this.imageY = 0;
 this.imageZoom = 1;

 this.sliderSpeed = 0;
 this.sliderAccel = 0;
 this.zoomBtnPressed = false;

 this.showFull = false;

 this.selects = document.getElementsByTagName('select');

 this.draggable = new Draggable(imageEl, {
 starteffect:false,
 reverteffect:false,
 endeffect:false,
 snap:this.contain.bind(this)
 });

 this.slider = new Control.Slider(handleEl, trackEl, {
 axis:'horizontal',
 minimum:0,
 maximum:Element.getDimensions(this.trackEl).width,
 alignX:0,
 increment:1,
 sliderValue:0,
 onSlide:this.scale.bind(this),
 onChange:this.scale.bind(this)
 });

 this.scale(0);

 Event.observe(this.imageEl, 'dblclick', this.toggleFull.bind(this));

 Event.observe($(zoomInEl), 'mousedown', this.startZoomIn.bind(this));
 Event.observe($(zoomInEl), 'mouseup', this.stopZooming.bind(this));
 Event.observe($(zoomInEl), 'mouseout', this.stopZooming.bind(this));

 Event.observe($(zoomOutEl), 'mousedown', this.startZoomOut.bind(this));
 Event.observe($(zoomOutEl), 'mouseup', this.stopZooming.bind(this));
 Event.observe($(zoomOutEl), 'mouseout', this.stopZooming.bind(this));
 },

 toggleFull: function () {
 this.showFull = !this.showFull;
 //TODO: hide selects for IE only

 for (i=0; i<this.selects.length; i++) {
 this.selects[i].style.visibility = this.showFull ? 'hidden' : 'visible';
 }
 val_scale = !this.showFull ? this.slider.value : 1;
 this.scale(val_scale);

 this.trackEl.style.visibility = this.showFull ? 'hidden' : 'visible';
 this.containerEl.style.overflow = this.showFull ? 'visible' : 'hidden';
 this.containerEl.style.zIndex = this.showFull ? '1000' : '9';

 return this;
 },

 scale: function (v) {

 var centerX = (this.containerDim.width*(1-this.imageZoom)/2-this.imageX)/this.imageZoom;
 var centerY = (this.containerDim.height*(1-this.imageZoom)/2-this.imageY)/this.imageZoom;

 this.imageZoom = this.floorZoom+(v*(this.ceilingZoom-this.floorZoom));

 this.imageEl.style.width = (this.imageZoom*this.containerDim.width)+'px';
 if(this.containerDim.ratio){
 this.imageEl.style.height = (this.imageZoom*this.containerDim.width*this.containerDim.ratio)+'px'; // for safari
 }

 this.imageX = this.containerDim.width*(1-this.imageZoom)/2-centerX*this.imageZoom;
 this.imageY = this.containerDim.height*(1-this.imageZoom)/2-centerY*this.imageZoom;

 this.contain(this.imageX, this.imageY, this.draggable);

 return true;
 },

 startZoomIn: function()
 {
 this.zoomBtnPressed = true;
 this.sliderAccel = .002;
 this.periodicalZoom();
 this.zoomer = new PeriodicalExecuter(this.periodicalZoom.bind(this), .05);
 return this;
 },

 startZoomOut: function()
 {
 this.zoomBtnPressed = true;
 this.sliderAccel = -.002;
 this.periodicalZoom();
 this.zoomer = new PeriodicalExecuter(this.periodicalZoom.bind(this), .05);
 return this;
 },

 stopZooming: function()
 {
 if (!this.zoomer || this.sliderSpeed==0) {
 return;
 }
 this.zoomBtnPressed = false;
 this.sliderAccel = 0;
 },

 periodicalZoom: function()
 {
 if (!this.zoomer) {
 return this;
 }

 if (this.zoomBtnPressed) {
 this.sliderSpeed += this.sliderAccel;
 } else {
 this.sliderSpeed /= 1.5;
 if (Math.abs(this.sliderSpeed)<.001) {
 this.sliderSpeed = 0;
 this.zoomer.stop();
 this.zoomer = null;
 }
 }
 this.slider.value += this.sliderSpeed;

 this.slider.setValue(this.slider.value);
 this.scale(this.slider.value);

 return this;
 },

 contain: function (x,y,draggable) {

 var dim = Element.getDimensions(draggable.element);

 var xMin = 0, xMax = this.containerDim.width-dim.width;
 var yMin = 0, yMax = this.containerDim.height-dim.height;

 x = x>xMin ? xMin : x;
 x = x<xMax ? xMax : x;
 y = y>yMin ? yMin : y;
 y = y<yMax ? yMax : y;

 this.imageX = x;
 this.imageY = y;

 this.imageEl.style.left = this.imageX+'px';
 this.imageEl.style.top = this.imageY+'px';

 return [x,y];
 }
}

/**************************** CONFIGURABLE PRODUCT **************************/
Product.Config = Class.create();
Product.Config.prototype = {
 initialize: function(config){
 this.config = config;
 this.taxConfig = this.config.taxConfig;
 this.settings = $$('.super-attribute-select');
 this.state = new Hash();
 this.priceTemplate = new Template(this.config.template);
 this.prices = config.prices;

 this.settings.each(function(element){
 Event.observe(element, 'change', this.configure.bind(this))
 }.bind(this));

 // fill state
 this.settings.each(function(element){
 var attributeId = element.id.replace(/[a-z]*/, '');
 if(attributeId && this.config.attributes[attributeId]) {
 element.config = this.config.attributes[attributeId];
 element.attributeId = attributeId;
 this.state[attributeId] = false;
 }
 }.bind(this))

 // Init settings dropdown
 var childSettings = [];
 for(var i=this.settings.length-1;i>=0;i--){
 var prevSetting = this.settings[i-1] ? this.settings[i-1] : false;
 var nextSetting = this.settings[i+1] ? this.settings[i+1] : false;
 if(i==0){
 this.fillSelect(this.settings[i])
 }
 else {
 this.settings[i].disabled=true;
 }
 $(this.settings[i]).childSettings = childSettings.clone();
 $(this.settings[i]).prevSetting = prevSetting;
 $(this.settings[i]).nextSetting = nextSetting;
 childSettings.push(this.settings[i]);
 }

 // try retireve options from url
 var separatorIndex = window.location.href.indexOf('#');
 if (separatorIndex!=-1) {
 var paramsStr = window.location.href.substr(separatorIndex+1);
 this.values = paramsStr.toQueryParams();
 this.settings.each(function(element){
 var attributeId = element.attributeId;
 element.value = this.values[attributeId];
 this.configureElement(element);
 }.bind(this));
 }
 },

 configure: function(event){
 var element = Event.element(event);
 this.configureElement(element);
 },

 configureElement : function(element) {
 this.reloadOptionLabels(element);
 if(element.value){
 this.state[element.config.id] = element.value;
 if(element.nextSetting){
 element.nextSetting.disabled = false;
 this.fillSelect(element.nextSetting);
 this.resetChildren(element.nextSetting);
 }
 }
 else {
 this.resetChildren(element);
 }
 this.reloadPrice();
// Calculator.updatePrice();
 },

 reloadOptionLabels: function(element){
 var selectedPrice;
 if(element.options[element.selectedIndex].config){
 selectedPrice = parseFloat(element.options[element.selectedIndex].config.price)
 }
 else{
 selectedPrice = 0;
 }
 for(var i=0;i<element.options.length;i++){
 if(element.options[i].config){
 element.options[i].text = this.getOptionLabel(element.options[i].config, element.options[i].config.price-selectedPrice);
 }
 }
 },

 resetChildren : function(element){
 if(element.childSettings) {
 for(var i=0;i<element.childSettings.length;i++){
 element.childSettings[i].selectedIndex = 0;
 element.childSettings[i].disabled = true;
 if(element.config){
 this.state[element.config.id] = false;
 }
 }
 }
 },

 fillSelect: function(element){
 var attributeId = element.id.replace(/[a-z]*/, '');
 var options = this.getAttributeOptions(attributeId);
 this.clearSelect(element);
 element.options[0] = new Option(this.config.chooseText, '');

 var prevConfig = false;
 if(element.prevSetting){
 prevConfig = element.prevSetting.options[element.prevSetting.selectedIndex];
 }

 if(options) {
 var index = 1;
 for(var i=0;i<options.length;i++){
 var allowedProducts = [];
 if(prevConfig) {
 for(var j=0;j<options[i].products.length;j++){
 if(prevConfig.config.allowedProducts
 && prevConfig.config.allowedProducts.indexOf(options[i].products[j])>-1){
 allowedProducts.push(options[i].products[j]);
 }
 }
 } else {
 allowedProducts = options[i].products.clone();
 }

 if(allowedProducts.size()>0){
 options[i].allowedProducts = allowedProducts;
 element.options[index] = new Option(this.getOptionLabel(options[i], options[i].price), options[i].id);
 element.options[index].config = options[i];
 index++;
 }
 }
 }
 },

 getOptionLabel: function(option, price){
 var price = parseFloat(price);
 if (this.taxConfig.includeTax) {
 var tax = price / (100 + this.taxConfig.defaultTax) * this.taxConfig.defaultTax;
 var excl = price - tax;
 var incl = excl*(1+(this.taxConfig.currentTax/100));
 } else {
 var tax = price * (this.taxConfig.currentTax / 100);
 var excl = price;
 var incl = excl + tax;
 }

 if (this.taxConfig.showIncludeTax || this.taxConfig.showBothPrices) {
 price = incl;
 } else {
 price = excl;
 }

 var str = option.label;
 if(price){
 if (this.taxConfig.showBothPrices) {
 str+= ' ' + this.formatPrice(excl, true) + ' (' + this.formatPrice(price, true) + ' ' + this.taxConfig.inclTaxTitle + ')';
 } else {
 str+= ' ' + this.formatPrice(price, true);
 }
 }
 return str;
 },

 formatPrice: function(price, showSign){
 var str = '';
 price = parseFloat(price);
 if(showSign){
 if(price<0){
 str+= '-';
 price = -price;
 }
 else{
 str+= '+';
 }
 }

 var roundedPrice = (Math.round(price*100)/100).toString();

 if (this.prices && this.prices[roundedPrice]) {
 str+= this.prices[roundedPrice];
 }
 else {
 str+= this.priceTemplate.evaluate({price:price.toFixed(2)});
 }
 return str;
 },

 clearSelect: function(element){
 for(var i=element.options.length-1;i>=0;i--){
 element.remove(i);
 }
 },

 getAttributeOptions: function(attributeId){
 if(this.config.attributes[attributeId]){
 return this.config.attributes[attributeId].options;
 }
 },

 reloadPrice: function(){
 var price = 0;
 for(var i=this.settings.length-1;i>=0;i--){
 var selected = this.settings[i].options[this.settings[i].selectedIndex];
 if(selected.config){
 price += parseFloat(selected.config.price);
 }
 }

 optionsPrice.changePrice('config', price);
 optionsPrice.reload();

 return price;

 if($('product-price-'+this.config.productId)){
 $('product-price-'+this.config.productId).innerHTML = price;
 }
 this.reloadOldPrice();
 },

 reloadOldPrice: function(){
 if ($('old-price-'+this.config.productId)) {

 var price = parseFloat(this.config.oldPrice);
 for(var i=this.settings.length-1;i>=0;i--){
 var selected = this.settings[i].options[this.settings[i].selectedIndex];
 if(selected.config){
 price+= parseFloat(selected.config.price);
 }
 }
 if (price < 0)
 price = 0;
 price = this.formatPrice(price);

 if($('old-price-'+this.config.productId)){
 $('old-price-'+this.config.productId).innerHTML = price;
 }

 }
 }
}


/**************************** SUPER PRODUCTS ********************************/

Product.Super = {};
Product.Super.Configurable = Class.create();

Product.Super.Configurable.prototype = {
 initialize: function(container, observeCss, updateUrl, updatePriceUrl, priceContainerId) {
 this.container = $(container);
 this.observeCss = observeCss;
 this.updateUrl = updateUrl;
 this.updatePriceUrl = updatePriceUrl;
 this.priceContainerId = priceContainerId;
 this.registerObservers();
 },
 registerObservers: function() {
 var elements = this.container.getElementsByClassName(this.observeCss);
 elements.each(function(element){
 Event.observe(element, 'change', this.update.bindAsEventListener(this));
 }.bind(this));
 return this;
 },
 update: function(event) {
 var elements = this.container.getElementsByClassName(this.observeCss);
 var parameters = Form.serializeElements(elements, true);

 new Ajax.Updater(this.container, this.updateUrl + '?ajax=1', {
 parameters:parameters,
 onComplete:this.registerObservers.bind(this)
 });
 var priceContainer = $(this.priceContainerId);
 if(priceContainer) {
 new Ajax.Updater(priceContainer, this.updatePriceUrl + '?ajax=1', {
 parameters:parameters
 });
 }
 }
}

/**************************** PRICE RELOADER ********************************/
Product.OptionsPrice = Class.create();
Product.OptionsPrice.prototype = {
 initialize: function(config) {
 this.productId = config.productId;
 this.priceFormat = config.priceFormat;
 this.includeTax = config.includeTax;
 this.defaultTax = config.defaultTax;
 this.currentTax = config.currentTax;
 this.productPrice = config.productPrice;
 this.showIncludeTax = config.showIncludeTax;
 this.showBothPrices = config.showBothPrices;
 this.productPrice = config.productPrice;
 this.productOldPrice = config.productOldPrice;
 this.skipCalculate = config.skipCalculate;
 this.duplicateIdSuffix = config.idSuffix;

 this.oldPlusDisposition = config.oldPlusDisposition;
 this.plusDisposition = config.plusDisposition;

 this.oldMinusDisposition = config.oldMinusDisposition;
 this.minusDisposition = config.minusDisposition;

 this.optionPrices = {};
 this.containers = {};

 this.displayZeroPrice = true;

 this.initPrices();
 },

 setDuplicateIdSuffix: function(idSuffix) {
 this.duplicateIdSuffix = idSuffix;
 },

 initPrices: function() {
 this.containers[0] = 'product-price-' + this.productId;
 this.containers[1] = 'bundle-price-' + this.productId;
 this.containers[2] = 'price-including-tax-' + this.productId;
 this.containers[3] = 'price-excluding-tax-' + this.productId;
 this.containers[4] = 'old-price-' + this.productId;
 },

 changePrice: function(key, price) {
 this.optionPrices[key] = parseFloat(price);
 },

 getOptionPrices: function() {
 var result = 0;
 var nonTaxable = 0;
 $H(this.optionPrices).each(function(pair) {
 if (pair.key == 'nontaxable') {
 nonTaxable = pair.value;
 } else {
 result += pair.value;
 }
 });
 var r = new Array(result, nonTaxable);
 return r;
 },

 reload: function() {
 var price;
 var formattedPrice;
 var optionPrices = this.getOptionPrices();
 var nonTaxable = optionPrices[1];
 optionPrices = optionPrices[0];
 $H(this.containers).each(function(pair) {
 var _productPrice;
 var _plusDisposition;
 var _minusDisposition;
 if ($(pair.value)) {
 if (pair.value == 'old-price-'+this.productId && this.productOldPrice != this.productPrice) {
 _productPrice = this.productOldPrice;
 _plusDisposition = this.oldPlusDisposition;
 _minusDisposition = this.oldMinusDisposition;
 } else {
 _productPrice = this.productPrice;
 _plusDisposition = this.plusDisposition;
 _minusDisposition = this.minusDisposition;
 }

 var price = optionPrices+parseFloat(_productPrice)
 if (this.includeTax == 'true') {
 // tax = tax included into product price by admin
 var tax = price / (100 + this.defaultTax) * this.defaultTax;
 var excl = price - tax;
 var incl = excl*(1+(this.currentTax/100));
 } else {
 var tax = price * (this.currentTax / 100);
 var excl = price;
 var incl = excl + tax;
 }

 excl += parseFloat(_plusDisposition);
 incl += parseFloat(_plusDisposition);
 excl -= parseFloat(_minusDisposition);
 incl -= parseFloat(_minusDisposition);

 //adding nontaxlable part of options
 excl += parseFloat(nonTaxable);
 incl += parseFloat(nonTaxable);

 if (pair.value == 'price-including-tax-'+this.productId) {
 price = incl;
 } else if (pair.value == 'old-price-'+this.productId) {
 if (this.showIncludeTax || this.showBothPrices) {
 price = incl;
 } else {
 price = excl;
 }
 } else {
 if (this.showIncludeTax) {
 price = incl;
 } else {
 if (!this.skipCalculate || _productPrice == 0) {
 price = excl;
 } else {
 price = optionPrices+parseFloat(_productPrice);
 }
 }
 }

 if (price < 0) price = 0;

 if (price > 0 || this.displayZeroPrice) {
 formattedPrice = this.formatPrice(price);
 } else {
 formattedPrice = '';
 }

 if ($(pair.value).select('.price')[0]) {
 $(pair.value).select('.price')[0].innerHTML = formattedPrice;
 if ($(pair.value+this.duplicateIdSuffix) && $(pair.value+this.duplicateIdSuffix).select('.price')[0]) {
 $(pair.value+this.duplicateIdSuffix).select('.price')[0].innerHTML = formattedPrice;
 }
 } else {
 $(pair.value).innerHTML = formattedPrice;
 if ($(pair.value+this.duplicateIdSuffix)) {
 $(pair.value+this.duplicateIdSuffix).innerHTML = formattedPrice;
 }
 }
 };
 }.bind(this));
 },
 formatPrice: function(price) {
 return formatCurrency(price, this.priceFormat);
 }
}