/* 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) {
 if (element._prototypeEventID) return element._prototypeEventID[0];
 arguments.callee.id = arguments.callee.id || 1;
 return element._prototypeEventID = [++arguments.callee.id];
 }

 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();/*
* 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.prototype = {
 initialize : function(form, options){
 this.form = $(form);
 if (!this.form) {
 return;
 }
 this.options = Object.extend({
 onSubmit : true,
 stopOnFirst : false,
 immediate : false,
 focusOnError : true,
 useTitles : false,
 onFormValidate : function(result, form) {},
 onElementValidate : function(result, elm) {}
 }, options || {});
 if(this.options.onSubmit) Event.observe(this.form,'submit',this.onSubmit.bind(this),false);
 if(this.options.immediate) {
 var useTitles = this.options.useTitles;
 var callback = this.options.onElementValidate;
 Form.getElements(this.form).each(function(input) { // Thanks Mike!
 Event.observe(input, 'blur', function(ev) { Validation.validate(Event.element(ev),{useTitle : useTitles, onElementValidate : callback}); });
 });
 }
 },
 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.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');
 },
 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');
 }
 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');
 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);
 advice.hide();
 elm[prop] = '';
 }
 elm.removeClassName('validation-failed');
 elm.removeClassName('validation-passed');
 });
 },
 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-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-cpassword', 'Please make sure your passwords match.', function(v) {
 var pass = $('password') ? $('password') : $$('.validate-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');
 var error = 1;
 for( i in inputs ) {
 if( inputs[i].checked == true && inputs[i].name == elm.name ) {
 error = 0;
 }
 }

 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;
 }

 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');
 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.8.1, Thu Jan 03 22:07:12 -0500 2008

// 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.8.1, Thu Jan 03 22:07:12 -0500 2008

// 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) { }
};

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

var Effect = {
 _elementDoesNotExistError: {
 name: 'ElementDoesNotExistError',
 message: 'The specified DOM element does not exist, but is required for this effect to operate'
 },
 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 (
 ((pos % (1/pulses)) * pulses).round() == 0 ? 
 ((pos * pulses * 2) - (pos * pulses * 2).floor()) : 
 1 - ((pos * pulses * 2) - (pos * pulses * 2).floor())
 );
 },
 spring: function(pos) { 
 return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6)); 
 },
 none: function(pos) {
 return 0;
 },
 full: function(pos) {
 return 1;
 }
 },
 DefaultOptions: {
 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'
 },
 tagifyText: function(element) {
 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(
 new Element('span', {style: tagifyStyle}).update(
 character == ' ' ? String.fromCharCode(160) : character), 
 child);
 });
 Element.remove(child);
 }
 });
 },
 multiple: function(element, effect) {
 var elements;
 if (((typeof element == 'object') || 
 Object.isFunction(element)) && 
 (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);
 }
};

Effect.DefaultOptions.transition = Effect.Transitions.sinoidal;

/* ------------- core effects ------------- */

Effect.ScopedQueue = Class.create(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 = Object.isString(effect.options.queue) ? 
 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 (!Object.isString(queueName)) return queueName;
 
 return this.instances.get(queueName) ||
 this.instances.set(queueName, new Effect.ScopedQueue());
 }
};
Effect.Queue = Effect.Queues.get('global');

Effect.Base = Class.create({
 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 && 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(this.options,'beforeSetup')+
 (this.setup ? 'this.setup();':'')+ 
 codeForEvent(this.options,'afterSetup')+
 '};if (this.state=="running"){'+
 'pos=this.options.transition(pos)*'+this.fromToDelta+'+'+this.options.from+';'+
 'this.position=pos;'+
 codeForEvent(this.options,'beforeUpdate')+
 (this.update ? 'this.update(pos);':'')+
 codeForEvent(this.options,'afterUpdate')+
 '}}');
 
 this.event('beforeStart');
 if (!this.options.sync)
 Effect.Queues.get(Object.isString(this.options.queue) ? 
 '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 = (pos * this.totalFrames).round();
 if (frame > this.currentFrame) {
 this.render(pos);
 this.currentFrame = frame;
 }
 }
 },
 cancel: function() {
 if (!this.options.sync)
 Effect.Queues.get(Object.isString(this.options.queue) ? 
 '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 (!Object.isFunction(this[property])) data.set(property, this[property]);
 return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
 }
});

Effect.Parallel = Class.create(Effect.Base, {
 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.Tween = Class.create(Effect.Base, {
 initialize: function(object, from, to) {
 object = Object.isString(object) ? $(object) : object;
 var args = $A(arguments), method = args.last(), 
 options = args.length == 5 ? args[3] : null;
 this.method = Object.isFunction(method) ? method.bind(object) :
 Object.isFunction(object[method]) ? object[method].bind(object) : 
 function(value) { object[method] = value };
 this.start(Object.extend({ from: from, to: to }, options || { }));
 },
 update: function(position) {
 this.method(position);
 }
});

Effect.Event = Class.create(Effect.Base, {
 initialize: function() {
 this.start(Object.extend({ duration: 0 }, arguments[0] || { }));
 },
 update: Prototype.emptyFunction
});

Effect.Opacity = Class.create(Effect.Base, {
 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(Effect.Base, {
 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() {
 this.element.makePositioned();
 this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
 this.originalTop = parseFloat(this.element.getStyle('top') || '0');
 if (this.options.mode == 'absolute') {
 this.options.x = this.options.x - this.originalLeft;
 this.options.y = this.options.y - this.originalTop;
 }
 },
 update: function(position) {
 this.element.setStyle({
 left: (this.options.x * position + this.originalLeft).round() + 'px',
 top: (this.options.y * position + this.originalTop).round() + '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(Effect.Base, {
 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 = width.round() + 'px';
 if (this.options.scaleY) d.height = height.round() + '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(Effect.Base, {
 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+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
 },
 finish: function() {
 this.element.setStyle(Object.extend(this.oldStyle, {
 backgroundColor: this.options.restorecolor
 }));
 }
});

Effect.ScrollTo = function(element) {
 var options = arguments[1] || { },
 scrollOffsets = document.viewport.getScrollOffsets(),
 elementOffsets = $(element).cumulativeOffset(),
 max = (window.height || document.body.scrollHeight) - document.viewport.getHeight(); 

 if (options.offset) elementOffsets[1] += options.offset;

 return new Effect.Tween(null,
 scrollOffsets.top,
 elementOffsets[1] > max ? max : elementOffsets[1],
 options,
 function(p){ scrollTo(scrollOffsets.left, p.round()) }
 );
};

/* ------------- 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 options = Object.extend({
 distance: 20,
 duration: 0.5
 }, arguments[1] || {});
 var distance = parseFloat(options.distance);
 var split = parseFloat(options.duration) / 10.0;
 var oldStyle = {
 top: element.getStyle('top'),
 left: element.getStyle('left') };
 return new Effect.Move(element,
 { x: distance, y: 0, duration: split, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: distance*2, y: 0, duration: split*2, afterFinishInternal: function(effect) {
 new Effect.Move(effect.element,
 { x: -distance, y: 0, duration: split, 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');
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, window.opera ? 0 : 1,
 Object.extend({ scaleContent: false, 
 scaleX: false, 
 scaleMode: 'box',
 scaleFrom: 100,
 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().show();
 }, 
 afterUpdateInternal: function(effect) {
 effect.element.down().setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px' });
 },
 afterFinishInternal: function(effect) {
 effect.element.hide().undoClipping().undoPositioned();
 effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom});
 }
 }, 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(Effect.Base, {
 initialize: function(element) {
 this.element = $(element);
 if (!this.element) throw(Effect._elementDoesNotExistError);
 var options = Object.extend({
 style: { }
 }, arguments[1] || { });
 
 if (!Object.isString(options.style)) this.style = $H(options.style);
 else {
 if (options.style.include(':'))
 this.style = options.style.parseStyle();
 else {
 this.element.addClassName(options.style);
 this.style = $H(this.element.getStyles());
 this.element.removeClassName(options.style);
 var css = this.element.getStyles();
 this.style = this.style.reject(function(style) {
 return style.value == css[style.key];
 });
 options.afterFinishInternal = function(effect) {
 effect.element.addClassName(effect.options.style);
 effect.transforms.each(function(transform) {
 effect.element.style[transform.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 +
 (transform.targetValue - transform.originalValue) * position).toFixed(3) + 
 (transform.unit === null ? '' : transform.unit);
 this.element.setStyle(style, true);
 }
});

Effect.Transform = Class.create({
 initialize: function(tracks){
 this.tracks = [];
 this.options = arguments[1] || { };
 this.addTracks(tracks);
 },
 addTracks: function(tracks){
 tracks.each(function(track){
 track = $H(track);
 var data = track.values().first();
 this.tracks.push($H({
 ids: 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 ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
 var elements = [$(ids) || $$(ids)].flatten();
 return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, 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.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function(){
 var style, styleRules = $H();
 if (Prototype.Browser.WebKit)
 style = new Element('div',{style:this}).style;
 else {
 String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
 style = String.__parseStyleElement.childNodes[0].style;
 }
 
 Element.CSS_PROPERTIES.each(function(property){
 if (style[property]) styleRules.set(property, style[property]); 
 });
 
 if (Prototype.Browser.IE && this.include('opacity'))
 styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);

 return styleRules;
};

if (document.defaultView && document.defaultView.getComputedStyle) {
 Element.getStyles = function(element) {
 var css = document.defaultView.getComputedStyle($(element), null);
 return Element.CSS_PROPERTIES.inject({ }, function(styles, property) {
 styles[property] = css[property];
 return styles;
 });
 };
} else {
 Element.getStyles = function(element) {
 element = $(element);
 var css = element.currentStyle, styles;
 styles = Element.CSS_PROPERTIES.inject({ }, function(results, property) {
 results[property] = css[property];
 return results;
 });
 if (!styles.opacity) styles.opacity = element.getOpacity();
 return styles;
 };
};

Effect.Methods = {
 morph: function(element, style) {
 element = $(element);
 new Effect.Morph(element, Object.extend({ style: style }, arguments[2] || { }));
 return element;
 },
 visualEffect: function(element, effect, options) {
 element = $(element)
 var s = effect.dasherize().camelize(), klass = s.charAt(0).toUpperCase() + s.substring(1);
 new Effect[klass](element, options);
 return element;
 },
 highlight: function(element, options) {
 element = $(element);
 new Effect.Highlight(element, options);
 return element;
 }
};

$w('fade appear grow shrink fold blindUp blindDown slideUp slideDown '+
 'pulsate shake puff squish switchOff dropOut').each(
 function(effect) { 
 Effect.Methods[effect] = function(element, options){
 element = $(element);
 Effect[effect.charAt(0).toUpperCase() + effect.substring(1)](element, options);
 return element;
 }
 }
);

$w('getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles').each( 
 function(f) { Effect.Methods[f] = Element[f]; }
);

Element.addMethods(Effect.Methods);
// script.aculo.us dragdrop.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008

// 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(Object.isUndefined(Effect))
 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(Object.isArray(containment)) {
 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 drop, affected = [];
 
 this.drops.each( function(drop) {
 if(Droppables.isAffected(point, element, drop))
 affected.push(drop);
 });
 
 if(affected.length>0)
 drop = Droppables.findDeepestChild(affected);

 if(this.last_active && this.last_active != drop) this.deactivate(this.last_active);
 if (drop) {
 Position.within(drop.element, point[0], point[1]);
 if(drop.onHover)
 drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
 
 if (drop != this.last_active) 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(document, "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(document, "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({
 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 = Object.isNumber(element._opacity) ? 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] || Object.isUndefined(arguments[1].endeffect))
 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 && Object.isString(options.handle))
 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.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(!Object.isUndefined(Draggable._dragging[this.element]) &&
 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.delta)
 this.delta = this.currentDelta();
 
 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);
 this.element._originallyAbsolute = (this.element.getStyle('position') == 'absolute');
 if (!this.element._originallyAbsolute)
 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) {
 if (!this.element._originallyAbsolute)
 Position.relativize(this.element);
 delete this.element._originallyAbsolute;
 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 && Object.isFunction(revert)) 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(Object.isFunction(this.options.snap)) {
 p = this.options.snap(p[0],p[1],this);
 } else {
 if(Object.isArray(this.options.snap)) {
 p = p.map( function(v, i) {
 return (v/this.options.snap[i]).round()*this.options.snap[i] }.bind(this))
 } else {
 p = p.map( function(v) {
 return (v/this.options.snap).round()*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 };
 }
});

Draggable._dragging = { };

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

var SortableObserver = Class.create({
 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).select('.' + 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.8.1, Thu Jan 03 22:07:12 -0500 2008

// 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 = Class.create({
 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;
 this.oldElementValue = this.element.value;

 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);
 // Force carriage returns as token delimiters anyway
 if (!this.options.tokens.include('\n'))
 this.options.tokens.push('\n');

 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, 'keydown', this.onKeyPress.bindAsEventListener(this));
 },

 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();
 Event.stop(event);
 return;
 case Event.KEY_DOWN:
 this.markNext();
 this.render();
 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 = $(selectedElement).select('.' + this.options.select) || [];
 if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
 } else
 value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
 
 var bounds = this.getTokenBounds();
 if (bounds[0] != -1) {
 var newValue = this.element.value.substr(0, bounds[0]);
 var whitespace = this.element.value.substr(bounds[0]).match(/^\s+/);
 if (whitespace)
 newValue += whitespace[0];
 this.element.value = newValue + value + this.element.value.substr(bounds[1]);
 } else {
 this.element.value = value;
 }
 this.oldElementValue = this.element.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; 
 this.tokenBounds = null;
 if(this.getToken().length>=this.options.minChars) {
 this.getUpdatedChoices();
 } else {
 this.active = false;
 this.hide();
 }
 this.oldElementValue = this.element.value;
 },

 getToken: function() {
 var bounds = this.getTokenBounds();
 return this.element.value.substring(bounds[0], bounds[1]).strip();
 },

 getTokenBounds: function() {
 if (null != this.tokenBounds) return this.tokenBounds;
 var value = this.element.value;
 if (value.strip().empty()) return [-1, 0];
 var diff = arguments.callee.getFirstDifferencePos(value, this.oldElementValue);
 var offset = (diff == this.oldElementValue.length ? 1 : 0);
 var prevTokenPos = -1, nextTokenPos = value.length;
 var tp;
 for (var index = 0, l = this.options.tokens.length; index < l; ++index) {
 tp = value.lastIndexOf(this.options.tokens[index], diff + offset - 1);
 if (tp > prevTokenPos) prevTokenPos = tp;
 tp = value.indexOf(this.options.tokens[index], diff + offset);
 if (-1 != tp && tp < nextTokenPos) nextTokenPos = tp;
 }
 return (this.tokenBounds = [prevTokenPos + 1, nextTokenPos]);
 }
});

Autocompleter.Base.prototype.getTokenBounds.getFirstDifferencePos = function(newS, oldS) {
 var boundary = Math.min(newS.length, oldS.length);
 for (var index = 0; index < boundary; ++index)
 if (newS[index] != oldS[index])
 return index;
 return boundary;
};

Ajax.Autocompleter = Class.create(Autocompleter.Base, {
 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.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 and collection editor
// Full rewrite by Christophe Porteneuve <tdd@tddsworld.com> (April 2007).

// 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({
 initialize: function(element, url, options) {
 this.url = url;
 this.element = element = $(element);
 this.prepareOptions();
 this._controls = { };
 arguments.callee.dealWithDeprecatedOptions(options); // DEPRECATION LAYER!!!
 Object.extend(this.options, options || { });
 if (!this.options.formId && this.element.id) {
 this.options.formId = this.element.id + '-inplaceeditor';
 if ($(this.options.formId))
 this.options.formId = '';
 }
 if (this.options.externalControl)
 this.options.externalControl = $(this.options.externalControl);
 if (!this.options.externalControl)
 this.options.externalControlOnly = false;
 this._originalBackground = this.element.getStyle('background-color') || 'transparent';
 this.element.title = this.options.clickToEditText;
 this._boundCancelHandler = this.handleFormCancellation.bind(this);
 this._boundComplete = (this.options.onComplete || Prototype.emptyFunction).bind(this);
 this._boundFailureHandler = this.handleAJAXFailure.bind(this);
 this._boundSubmitHandler = this.handleFormSubmission.bind(this);
 this._boundWrapperHandler = this.wrapUp.bind(this);
 this.registerListeners();
 },
 checkForEscapeOrReturn: function(e) {
 if (!this._editing || e.ctrlKey || e.altKey || e.shiftKey) return;
 if (Event.KEY_ESC == e.keyCode)
 this.handleFormCancellation(e);
 else if (Event.KEY_RETURN == e.keyCode)
 this.handleFormSubmission(e);
 },
 createControl: function(mode, handler, extraClasses) {
 var control = this.options[mode + 'Control'];
 var text = this.options[mode + 'Text'];
 if ('button' == control) {
 var btn = document.createElement('input');
 btn.type = 'submit';
 btn.value = text;
 btn.className = 'editor_' + mode + '_button';
 if ('cancel' == mode)
 btn.onclick = this._boundCancelHandler;
 this._form.appendChild(btn);
 this._controls[mode] = btn;
 } else if ('link' == control) {
 var link = document.createElement('a');
 link.href = '#';
 link.appendChild(document.createTextNode(text));
 link.onclick = 'cancel' == mode ? this._boundCancelHandler : this._boundSubmitHandler;
 link.className = 'editor_' + mode + '_link';
 if (extraClasses)
 link.className += ' ' + extraClasses;
 this._form.appendChild(link);
 this._controls[mode] = link;
 }
 },
 createEditField: function() {
 var text = (this.options.loadTextURL ? this.options.loadingText : this.getText());
 var fld;
 if (1 >= this.options.rows && !/\r|\n/.test(this.getText())) {
 fld = document.createElement('input');
 fld.type = 'text';
 var size = this.options.size || this.options.cols || 0;
 if (0 < size) fld.size = size;
 } else {
 fld = document.createElement('textarea');
 fld.rows = (1 >= this.options.rows ? this.options.autoRows : this.options.rows);
 fld.cols = this.options.cols || 40;
 }
 fld.name = this.options.paramName;
 fld.value = text; // No HTML breaks conversion anymore
 fld.className = 'editor_field';
 if (this.options.submitOnBlur)
 fld.onblur = this._boundSubmitHandler;
 this._controls.editor = fld;
 if (this.options.loadTextURL)
 this.loadExternalText();
 this._form.appendChild(this._controls.editor);
 },
 createForm: function() {
 var ipe = this;
 function addText(mode, condition) {
 var text = ipe.options['text' + mode + 'Controls'];
 if (!text || condition === false) return;
 ipe._form.appendChild(document.createTextNode(text));
 };
 this._form = $(document.createElement('form'));
 this._form.id = this.options.formId;
 this._form.addClassName(this.options.formClassName);
 this._form.onsubmit = this._boundSubmitHandler;
 this.createEditField();
 if ('textarea' == this._controls.editor.tagName.toLowerCase())
 this._form.appendChild(document.createElement('br'));
 if (this.options.onFormCustomization)
 this.options.onFormCustomization(this, this._form);
 addText('Before', this.options.okControl || this.options.cancelControl);
 this.createControl('ok', this._boundSubmitHandler);
 addText('Between', this.options.okControl && this.options.cancelControl);
 this.createControl('cancel', this._boundCancelHandler, 'editor_cancel');
 addText('After', this.options.okControl || this.options.cancelControl);
 },
 destroy: function() {
 if (this._oldInnerHTML)
 this.element.innerHTML = this._oldInnerHTML;
 this.leaveEditMode();
 this.unregisterListeners();
 },
 enterEditMode: function(e) {
 if (this._saving || this._editing) return;
 this._editing = true;
 this.triggerCallback('onEnterEditMode');
 if (this.options.externalControl)
 this.options.externalControl.hide();
 this.element.hide();
 this.createForm();
 this.element.parentNode.insertBefore(this._form, this.element);
 if (!this.options.loadTextURL)
 this.postProcessEditField();
 if (e) Event.stop(e);
 },
 enterHover: function(e) {
 if (this.options.hoverClassName)
 this.element.addClassName(this.options.hoverClassName);
 if (this._saving) return;
 this.triggerCallback('onEnterHover');
 },
 getText: function() {
 return this.element.innerHTML;
 },
 handleAJAXFailure: function(transport) {
 this.triggerCallback('onFailure', transport);
 if (this._oldInnerHTML) {
 this.element.innerHTML = this._oldInnerHTML;
 this._oldInnerHTML = null;
 }
 },
 handleFormCancellation: function(e) {
 this.wrapUp();
 if (e) Event.stop(e);
 },
 handleFormSubmission: function(e) {
 var form = this._form;
 var value = $F(this._controls.editor);
 this.prepareSubmission();
 var params = this.options.callback(form, value) || '';
 if (Object.isString(params))
 params = params.toQueryParams();
 params.editorId = this.element.id;
 if (this.options.htmlResponse) {
 var options = Object.extend({ evalScripts: true }, this.options.ajaxOptions);
 Object.extend(options, {
 parameters: params,
 onComplete: this._boundWrapperHandler,
 onFailure: this._boundFailureHandler
 });
 new Ajax.Updater({ success: this.element }, this.url, options);
 } else {
 var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
 Object.extend(options, {
 parameters: params,
 onComplete: this._boundWrapperHandler,
 onFailure: this._boundFailureHandler
 });
 new Ajax.Request(this.url, options);
 }
 if (e) Event.stop(e);
 },
 leaveEditMode: function() {
 this.element.removeClassName(this.options.savingClassName);
 this.removeForm();
 this.leaveHover();
 this.element.style.backgroundColor = this._originalBackground;
 this.element.show();
 if (this.options.externalControl)
 this.options.externalControl.show();
 this._saving = false;
 this._editing = false;
 this._oldInnerHTML = null;
 this.triggerCallback('onLeaveEditMode');
 },
 leaveHover: function(e) {
 if (this.options.hoverClassName)
 this.element.removeClassName(this.options.hoverClassName);
 if (this._saving) return;
 this.triggerCallback('onLeaveHover');
 },
 loadExternalText: function() {
 this._form.addClassName(this.options.loadingClassName);
 this._controls.editor.disabled = true;
 var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
 Object.extend(options, {
 parameters: 'editorId=' + encodeURIComponent(this.element.id),
 onComplete: Prototype.emptyFunction,
 onSuccess: function(transport) {
 this._form.removeClassName(this.options.loadingClassName);
 var text = transport.responseText;
 if (this.options.stripLoadedTextTags)
 text = text.stripTags();
 this._controls.editor.value = text;
 this._controls.editor.disabled = false;
 this.postProcessEditField();
 }.bind(this),
 onFailure: this._boundFailureHandler
 });
 new Ajax.Request(this.options.loadTextURL, options);
 },
 postProcessEditField: function() {
 var fpc = this.options.fieldPostCreation;
 if (fpc)
 $(this._controls.editor)['focus' == fpc ? 'focus' : 'activate']();
 },
 prepareOptions: function() {
 this.options = Object.clone(Ajax.InPlaceEditor.DefaultOptions);
 Object.extend(this.options, Ajax.InPlaceEditor.DefaultCallbacks);
 [this._extraDefaultOptions].flatten().compact().each(function(defs) {
 Object.extend(this.options, defs);
 }.bind(this));
 },
 prepareSubmission: function() {
 this._saving = true;
 this.removeForm();
 this.leaveHover();
 this.showSaving();
 },
 registerListeners: function() {
 this._listeners = { };
 var listener;
 $H(Ajax.InPlaceEditor.Listeners).each(function(pair) {
 listener = this[pair.value].bind(this);
 this._listeners[pair.key] = listener;
 if (!this.options.externalControlOnly)
 this.element.observe(pair.key, listener);
 if (this.options.externalControl)
 this.options.externalControl.observe(pair.key, listener);
 }.bind(this));
 },
 removeForm: function() {
 if (!this._form) return;
 this._form.remove();
 this._form = null;
 this._controls = { };
 },
 showSaving: function() {
 this._oldInnerHTML = this.element.innerHTML;
 this.element.innerHTML = this.options.savingText;
 this.element.addClassName(this.options.savingClassName);
 this.element.style.backgroundColor = this._originalBackground;
 this.element.show();
 },
 triggerCallback: function(cbName, arg) {
 if ('function' == typeof this.options[cbName]) {
 this.options[cbName](this, arg);
 }
 },
 unregisterListeners: function() {
 $H(this._listeners).each(function(pair) {
 if (!this.options.externalControlOnly)
 this.element.stopObserving(pair.key, pair.value);
 if (this.options.externalControl)
 this.options.externalControl.stopObserving(pair.key, pair.value);
 }.bind(this));
 },
 wrapUp: function(transport) {
 this.leaveEditMode();
 // Can't use triggerCallback due to backward compatibility: requires
 // binding + direct element
 this._boundComplete(transport, this.element);
 }
});

Object.extend(Ajax.InPlaceEditor.prototype, {
 dispose: Ajax.InPlaceEditor.prototype.destroy
});

Ajax.InPlaceCollectionEditor = Class.create(Ajax.InPlaceEditor, {
 initialize: function($super, element, url, options) {
 this._extraDefaultOptions = Ajax.InPlaceCollectionEditor.DefaultOptions;
 $super(element, url, options);
 },

 createEditField: function() {
 var list = document.createElement('select');
 list.name = this.options.paramName;
 list.size = 1;
 this._controls.editor = list;
 this._collection = this.options.collection || [];
 if (this.options.loadCollectionURL)
 this.loadCollection();
 else
 this.checkForExternalText();
 this._form.appendChild(this._controls.editor);
 },

 loadCollection: function() {
 this._form.addClassName(this.options.loadingClassName);
 this.showLoadingText(this.options.loadingCollectionText);
 var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
 Object.extend(options, {
 parameters: 'editorId=' + encodeURIComponent(this.element.id),
 onComplete: Prototype.emptyFunction,
 onSuccess: function(transport) {
 var js = transport.responseText.strip();
 if (!/^\[.*\]$/.test(js)) // TODO: improve sanity check
 throw 'Server returned an invalid collection representation.';
 this._collection = eval(js);
 this.checkForExternalText();
 }.bind(this),
 onFailure: this.onFailure
 });
 new Ajax.Request(this.options.loadCollectionURL, options);
 },

 showLoadingText: function(text) {
 this._controls.editor.disabled = true;
 var tempOption = this._controls.editor.firstChild;
 if (!tempOption) {
 tempOption = document.createElement('option');
 tempOption.value = '';
 this._controls.editor.appendChild(tempOption);
 tempOption.selected = true;
 }
 tempOption.update((text || '').stripScripts().stripTags());
 },

 checkForExternalText: function() {
 this._text = this.getText();
 if (this.options.loadTextURL)
 this.loadExternalText();
 else
 this.buildOptionList();
 },

 loadExternalText: function() {
 this.showLoadingText(this.options.loadingText);
 var options = Object.extend({ method: 'get' }, this.options.ajaxOptions);
 Object.extend(options, {
 parameters: 'editorId=' + encodeURIComponent(this.element.id),
 onComplete: Prototype.emptyFunction,
 onSuccess: function(transport) {
 this._text = transport.responseText.strip();
 this.buildOptionList();
 }.bind(this),
 onFailure: this.onFailure
 });
 new Ajax.Request(this.options.loadTextURL, options);
 },

 buildOptionList: function() {
 this._form.removeClassName(this.options.loadingClassName);
 this._collection = this._collection.map(function(entry) {
 return 2 === entry.length ? entry : [entry, entry].flatten();
 });
 var marker = ('value' in this.options) ? this.options.value : this._text;
 var textFound = this._collection.any(function(entry) {
 return entry[0] == marker;
 }.bind(this));
 this._controls.editor.update('');
 var option;
 this._collection.each(function(entry, index) {
 option = document.createElement('option');
 option.value = entry[0];
 option.selected = textFound ? entry[0] == marker : 0 == index;
 option.appendChild(document.createTextNode(entry[1]));
 this._controls.editor.appendChild(option);
 }.bind(this));
 this._controls.editor.disabled = false;
 Field.scrollFreeActivate(this._controls.editor);
 }
});

//**** DEPRECATION LAYER FOR InPlace[Collection]Editor! ****
//**** This only exists for a while, in order to let ****
//**** users adapt to the new API. Read up on the new ****
//**** API and convert your code to it ASAP! ****

Ajax.InPlaceEditor.prototype.initialize.dealWithDeprecatedOptions = function(options) {
 if (!options) return;
 function fallback(name, expr) {
 if (name in options || expr === undefined) return;
 options[name] = expr;
 };
 fallback('cancelControl', (options.cancelLink ? 'link' : (options.cancelButton ? 'button' :
 options.cancelLink == options.cancelButton == false ? false : undefined)));
 fallback('okControl', (options.okLink ? 'link' : (options.okButton ? 'button' :
 options.okLink == options.okButton == false ? false : undefined)));
 fallback('highlightColor', options.highlightcolor);
 fallback('highlightEndColor', options.highlightendcolor);
};

Object.extend(Ajax.InPlaceEditor, {
 DefaultOptions: {
 ajaxOptions: { },
 autoRows: 3, // Use when multi-line w/ rows == 1
 cancelControl: 'link', // 'link'|'button'|false
 cancelText: 'cancel',
 clickToEditText: 'Click to edit',
 externalControl: null, // id|elt
 externalControlOnly: false,
 fieldPostCreation: 'activate', // 'activate'|'focus'|false
 formClassName: 'inplaceeditor-form',
 formId: null, // id|elt
 highlightColor: '#ffff99',
 highlightEndColor: '#ffffff',
 hoverClassName: '',
 htmlResponse: true,
 loadingClassName: 'inplaceeditor-loading',
 loadingText: 'Loading...',
 okControl: 'button', // 'link'|'button'|false
 okText: 'ok',
 paramName: 'value',
 rows: 1, // If 1 and multi-line, uses autoRows
 savingClassName: 'inplaceeditor-saving',
 savingText: 'Saving...',
 size: 0,
 stripLoadedTextTags: false,
 submitOnBlur: false,
 textAfterControls: '',
 textBeforeControls: '',
 textBetweenControls: ''
 },
 DefaultCallbacks: {
 callback: function(form) {
 return Form.serialize(form);
 },
 onComplete: function(transport, element) {
 // For backward compatibility, this one is bound to the IPE, and passes
 // the element directly. It was too often customized, so we don't break it.
 new Effect.Highlight(element, {
 startcolor: this.options.highlightColor, keepBackgroundImage: true });
 },
 onEnterEditMode: null,
 onEnterHover: function(ipe) {
 ipe.element.style.backgroundColor = ipe.options.highlightColor;
 if (ipe._effect)
 ipe._effect.cancel();
 },
 onFailure: function(transport, ipe) {
 alert('Error communication with the server: ' + transport.responseText.stripTags());
 },
 onFormCustomization: null, // Takes the IPE and its generated form, after editor, before controls.
 onLeaveEditMode: null,
 onLeaveHover: function(ipe) {
 ipe._effect = new Effect.Highlight(ipe.element, {
 startcolor: ipe.options.highlightColor, endcolor: ipe.options.highlightEndColor,
 restorecolor: ipe._originalBackground, keepBackgroundImage: true
 });
 }
 },
 Listeners: {
 click: 'enterEditMode',
 keydown: 'checkForEscapeOrReturn',
 mouseover: 'enterHover',
 mouseout: 'leaveHover'
 }
});

Ajax.InPlaceCollectionEditor.DefaultOptions = {
 loadingCollectionText: 'Loading options...'
};

// Delayed observer, like Form.Element.Observer, 
// but waits for delay after last key input
// Ideal for live-search fields

Form.Element.DelayedObserver = Class.create({
 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.8.1, Thu Jan 03 22:07:12 -0500 2008

// 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 = { };

// options:
// axis: 'vertical', or 'horizontal' (default)
//
// callbacks:
// onChange(value)
// onSlide(value)
Control.Slider = Class.create({
 initialize: function(handle, track, options) {
 var slider = this;
 
 if (Object.isArray(handle)) {
 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(
 (Object.isArray(slider.options.sliderValue) ? 
 slider.options.sliderValue[i] : slider.options.sliderValue) || 
 slider.range.start), i);
 h.makePositioned().observe("mousedown", slider.eventMouseDown);
 });
 
 this.track.observe("mousedown", this.eventMouseDown);
 document.observe("mouseup", this.eventMouseUp);
 document.observe("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(document, "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.alignX);
 }, 
 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)
 }
 );
 },

 _selectAutocompleteItem : function(element){
 if(element.title){
 this.field.value = element.title;
 }
 this.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) {
 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.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.month.value+'/'+this.day.value+'/'+this.year.value;
 var test = new Date(this.dob.value);
 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.className){
 Element.addClassName(element, this.highlightClass);
 }
 },

 elementOnBlur: function(event){
 var element = Event.findElement(event, 'fieldset');
 if(element && element.className){
 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){
 if(elem.parentNode){
 var marks = Element.select(elem.parentNode, '.required');
 if(marks[0]){
 display ? marks[0].show() : marks[0].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 Cookies.getCookieVal(j);
 i = document.cookie.indexOf(" ", i) + 1;
 if(i == 0)
 break;
 }
 return null;
};

Mage.Cookies.clear = function(name) {
 if(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));
};(function(){
/*
 * jQuery 1.2.6 - New Wave Javascript
 *
 * Copyright (c) 2008 John Resig (jquery.com)
 * Dual licensed under the MIT (MIT-LICENSE.txt)
 * and GPL (GPL-LICENSE.txt) licenses.
 *
 * $Date: 2008-05-24 14:22:17 -0400 (Sat, 24 May 2008) $
 * $Rev: 5685 $
 */

// Map over jQuery in case of overwrite
var _jQuery = window.jQuery,
// Map over the $ in case of overwrite
 _$ = window.$;

var jQuery = window.jQuery = window.$ = function( selector, context ) {
 // The jQuery object is actually just the init constructor 'enhanced'
 return new jQuery.fn.init( selector, context );
};

// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/,

// Is it a simple selector
 isSimple = /^.[^:#\[\.]*$/,

// Will speed up references to undefined, and allows munging its name.
 undefined;

jQuery.fn = jQuery.prototype = {
 init: function( selector, context ) {
 // Make sure that a selection was provided
 selector = selector || document;

 // Handle $(DOMElement)
 if ( selector.nodeType ) {
 this[0] = selector;
 this.length = 1;
 return this;
 }
 // Handle HTML strings
 if ( typeof selector == "string" ) {
 // Are we dealing with HTML string or an ID?
 var match = quickExpr.exec( selector );

 // Verify a match, and that no context was specified for #id
 if ( match && (match[1] || !context) ) {

 // HANDLE: $(html) -> $(array)
 if ( match[1] )
 selector = jQuery.clean( [ match[1] ], context );

 // HANDLE: $("#id")
 else {
 var elem = document.getElementById( match[3] );

 // Make sure an element was located
 if ( elem ){
 // Handle the case where IE and Opera return items
 // by name instead of ID
 if ( elem.id != match[3] )
 return jQuery().find( selector );

 // Otherwise, we inject the element directly into the jQuery object
 return jQuery( elem );
 }
 selector = [];
 }

 // HANDLE: $(expr, [context])
 // (which is just equivalent to: $(content).find(expr)
 } else
 return jQuery( context ).find( selector );

 // HANDLE: $(function)
 // Shortcut for document ready
 } else if ( jQuery.isFunction( selector ) )
 return jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );

 return this.setArray(jQuery.makeArray(selector));
 },

 // The current version of jQuery being used
 jquery: "1.2.6",

 // The number of elements contained in the matched element set
 size: function() {
 return this.length;
 },

 // The number of elements contained in the matched element set
 length: 0,

 // Get the Nth element in the matched element set OR
 // Get the whole matched element set as a clean array
 get: function( num ) {
 return num == undefined ?

 // Return a 'clean' array
 jQuery.makeArray( this ) :

 // Return just the object
 this[ num ];
 },

 // Take an array of elements and push it onto the stack
 // (returning the new matched element set)
 pushStack: function( elems ) {
 // Build a new jQuery matched element set
 var ret = jQuery( elems );

 // Add the old object onto the stack (as a reference)
 ret.prevObject = this;

 // Return the newly-formed element set
 return ret;
 },

 // Force the current matched set of elements to become
 // the specified array of elements (destroying the stack in the process)
 // You should use pushStack() in order to do this, but maintain the stack
 setArray: function( elems ) {
 // Resetting the length to 0, then using the native Array push
 // is a super-fast way to populate an object with array-like properties
 this.length = 0;
 Array.prototype.push.apply( this, elems );

 return this;
 },

 // Execute a callback for every element in the matched set.
 // (You can seed the arguments with an array of args, but this is
 // only used internally.)
 each: function( callback, args ) {
 return jQuery.each( this, callback, args );
 },

 // Determine the position of an element within
 // the matched set of elements
 index: function( elem ) {
 var ret = -1;

 // Locate the position of the desired element
 return jQuery.inArray(
 // If it receives a jQuery object, the first element is used
 elem && elem.jquery ? elem[0] : elem
 , this );
 },

 attr: function( name, value, type ) {
 var options = name;

 // Look for the case where we're accessing a style value
 if ( name.constructor == String )
 if ( value === undefined )
 return this[0] && jQuery[ type || "attr" ]( this[0], name );

 else {
 options = {};
 options[ name ] = value;
 }

 // Check to see if we're setting style values
 return this.each(function(i){
 // Set all the styles
 for ( name in options )
 jQuery.attr(
 type ?
 this.style :
 this,
 name, jQuery.prop( this, options[ name ], type, i, name )
 );
 });
 },

 css: function( key, value ) {
 // ignore negative width and height values
 if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
 value = undefined;
 return this.attr( key, value, "curCSS" );
 },

 text: function( text ) {
 if ( typeof text != "object" && text != null )
 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );

 var ret = "";

 jQuery.each( text || this, function(){
 jQuery.each( this.childNodes, function(){
 if ( this.nodeType != 8 )
 ret += this.nodeType != 1 ?
 this.nodeValue :
 jQuery.fn.text( [ this ] );
 });
 });

 return ret;
 },

 wrapAll: function( html ) {
 if ( this[0] )
 // The elements to wrap the target around
 jQuery( html, this[0].ownerDocument )
 .clone()
 .insertBefore( this[0] )
 .map(function(){
 var elem = this;

 while ( elem.firstChild )
 elem = elem.firstChild;

 return elem;
 })
 .append(this);

 return this;
 },

 wrapInner: function( html ) {
 return this.each(function(){
 jQuery( this ).contents().wrapAll( html );
 });
 },

 wrap: function( html ) {
 return this.each(function(){
 jQuery( this ).wrapAll( html );
 });
 },

 append: function() {
 return this.domManip(arguments, true, false, function(elem){
 if (this.nodeType == 1)
 this.appendChild( elem );
 });
 },

 prepend: function() {
 return this.domManip(arguments, true, true, function(elem){
 if (this.nodeType == 1)
 this.insertBefore( elem, this.firstChild );
 });
 },

 before: function() {
 return this.domManip(arguments, false, false, function(elem){
 this.parentNode.insertBefore( elem, this );
 });
 },

 after: function() {
 return this.domManip(arguments, false, true, function(elem){
 this.parentNode.insertBefore( elem, this.nextSibling );
 });
 },

 end: function() {
 return this.prevObject || jQuery( [] );
 },

 find: function( selector ) {
 var elems = jQuery.map(this, function(elem){
 return jQuery.find( selector, elem );
 });

 return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
 jQuery.unique( elems ) :
 elems );
 },

 clone: function( events ) {
 // Do the clone
 var ret = this.map(function(){
 if ( jQuery.browser.msie && !jQuery.isXMLDoc(this) ) {
 // IE copies events bound via attachEvent when
 // using cloneNode. Calling detachEvent on the
 // clone will also remove the events from the orignal
 // In order to get around this, we use innerHTML.
 // Unfortunately, this means some modifications to
 // attributes in IE that are actually only stored
 // as properties will not be copied (such as the
 // the name attribute on an input).
 var clone = this.cloneNode(true),
 container = document.createElement("div");
 container.appendChild(clone);
 return jQuery.clean([container.innerHTML])[0];
 } else
 return this.cloneNode(true);
 });

 // Need to set the expando to null on the cloned set if it exists
 // removeData doesn't work here, IE removes it from the original as well
 // this is primarily for IE but the data expando shouldn't be copied over in any browser
 var clone = ret.find("*").andSelf().each(function(){
 if ( this[ expando ] != undefined )
 this[ expando ] = null;
 });

 // Copy the events from the original to the clone
 if ( events === true )
 this.find("*").andSelf().each(function(i){
 if (this.nodeType == 3)
 return;
 var events = jQuery.data( this, "events" );

 for ( var type in events )
 for ( var handler in events[ type ] )
 jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
 });

 // Return the cloned set
 return ret;
 },

 filter: function( selector ) {
 return this.pushStack(
 jQuery.isFunction( selector ) &&
 jQuery.grep(this, function(elem, i){
 return selector.call( elem, i );
 }) ||

 jQuery.multiFilter( selector, this ) );
 },

 not: function( selector ) {
 if ( selector.constructor == String )
 // test special case where just one selector is passed in
 if ( isSimple.test( selector ) )
 return this.pushStack( jQuery.multiFilter( selector, this, true ) );
 else
 selector = jQuery.multiFilter( selector, this );

 var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
 return this.filter(function() {
 return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
 });
 },

 add: function( selector ) {
 return this.pushStack( jQuery.unique( jQuery.merge(
 this.get(),
 typeof selector == 'string' ?
 jQuery( selector ) :
 jQuery.makeArray( selector )
 )));
 },

 is: function( selector ) {
 return !!selector && jQuery.multiFilter( selector, this ).length > 0;
 },

 hasClass: function( selector ) {
 return this.is( "." + selector );
 },

 val: function( value ) {
 if ( value == undefined ) {

 if ( this.length ) {
 var elem = this[0];

 // We need to handle select boxes special
 if ( jQuery.nodeName( elem, "select" ) ) {
 var index = elem.selectedIndex,
 values = [],
 options = elem.options,
 one = elem.type == "select-one";

 // Nothing was selected
 if ( index < 0 )
 return null;

 // Loop through all the selected options
 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
 var option = options[ i ];

 if ( option.selected ) {
 // Get the specifc value for the option
 value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;

 // We don't need an array for one selects
 if ( one )
 return value;

 // Multi-Selects return an array
 values.push( value );
 }
 }

 return values;

 // Everything else, we just grab the value
 } else
 return (this[0].value || "").replace(/\r/g, "");

 }

 return undefined;
 }

 if( value.constructor == Number )
 value += '';

 return this.each(function(){
 if ( this.nodeType != 1 )
 return;

 if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
 this.checked = (jQuery.inArray(this.value, value) >= 0 ||
 jQuery.inArray(this.name, value) >= 0);

 else if ( jQuery.nodeName( this, "select" ) ) {
 var values = jQuery.makeArray(value);

 jQuery( "option", this ).each(function(){
 this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
 jQuery.inArray( this.text, values ) >= 0);
 });

 if ( !values.length )
 this.selectedIndex = -1;

 } else
 this.value = value;
 });
 },

 html: function( value ) {
 return value == undefined ?
 (this[0] ?
 this[0].innerHTML :
 null) :
 this.empty().append( value );
 },

 replaceWith: function( value ) {
 return this.after( value ).remove();
 },

 eq: function( i ) {
 return this.slice( i, i + 1 );
 },

 slice: function() {
 return this.pushStack( Array.prototype.slice.apply( this, arguments ) );
 },

 map: function( callback ) {
 return this.pushStack( jQuery.map(this, function(elem, i){
 return callback.call( elem, i, elem );
 }));
 },

 andSelf: function() {
 return this.add( this.prevObject );
 },

 data: function( key, value ){
 var parts = key.split(".");
 parts[1] = parts[1] ? "." + parts[1] : "";

 if ( value === undefined ) {
 var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);

 if ( data === undefined && this.length )
 data = jQuery.data( this[0], key );

 return data === undefined && parts[1] ?
 this.data( parts[0] ) :
 data;
 } else
 return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
 jQuery.data( this, key, value );
 });
 },

 removeData: function( key ){
 return this.each(function(){
 jQuery.removeData( this, key );
 });
 },

 domManip: function( args, table, reverse, callback ) {
 var clone = this.length > 1, elems;

 return this.each(function(){
 if ( !elems ) {
 elems = jQuery.clean( args, this.ownerDocument );

 if ( reverse )
 elems.reverse();
 }

 var obj = this;

 if ( table && jQuery.nodeName( this, "table" ) && jQuery.nodeName( elems[0], "tr" ) )
 obj = this.getElementsByTagName("tbody")[0] || this.appendChild( this.ownerDocument.createElement("tbody") );

 var scripts = jQuery( [] );

 jQuery.each(elems, function(){
 var elem = clone ?
 jQuery( this ).clone( true )[0] :
 this;

 // execute all scripts after the elements have been injected
 if ( jQuery.nodeName( elem, "script" ) )
 scripts = scripts.add( elem );
 else {
 // Remove any inner scripts for later evaluation
 if ( elem.nodeType == 1 )
 scripts = scripts.add( jQuery( "script", elem ).remove() );

 // Inject the elements into the document
 callback.call( obj, elem );
 }
 });

 scripts.each( evalScript );
 });
 }
};

// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;

function evalScript( i, elem ) {
 if ( elem.src )
 jQuery.ajax({
 url: elem.src,
 async: false,
 dataType: "script"
 });

 else
 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );

 if ( elem.parentNode )
 elem.parentNode.removeChild( elem );
}

function now(){
 return +new Date;
}

jQuery.extend = jQuery.fn.extend = function() {
 // copy reference to target object
 var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;

 // Handle a deep copy situation
 if ( target.constructor == Boolean ) {
 deep = target;
 target = arguments[1] || {};
 // skip the boolean and the target
 i = 2;
 }

 // Handle case when target is a string or something (possible in deep copy)
 if ( typeof target != "object" && typeof target != "function" )
 target = {};

 // extend jQuery itself if only one argument is passed
 if ( length == i ) {
 target = this;
 --i;
 }

 for ( ; i < length; i++ )
 // Only deal with non-null/undefined values
 if ( (options = arguments[ i ]) != null )
 // Extend the base object
 for ( var name in options ) {
 var src = target[ name ], copy = options[ name ];

 // Prevent never-ending loop
 if ( target === copy )
 continue;

 // Recurse if we're merging object values
 if ( deep && copy && typeof copy == "object" && !copy.nodeType )
 target[ name ] = jQuery.extend( deep, 
 // Never move original objects, clone them
 src || ( copy.length != null ? [ ] : { } )
 , copy );

 // Don't bring in undefined values
 else if ( copy !== undefined )
 target[ name ] = copy;

 }

 // Return the modified object
 return target;
};

var expando = "jQuery" + now(), uuid = 0, windowData = {},
 // exclude the following css properties to add px
 exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
 // cache defaultView
 defaultView = document.defaultView || {};

jQuery.extend({
 noConflict: function( deep ) {
 window.$ = _$;

 if ( deep )
 window.jQuery = _jQuery;

 return jQuery;
 },

 // See test/unit/core.js for details concerning this function.
 isFunction: function( fn ) {
 return !!fn && typeof fn != "string" && !fn.nodeName &&
 fn.constructor != Array && /^[\s[]?function/.test( fn + "" );
 },

 // check if an element is in a (or is an) XML document
 isXMLDoc: function( elem ) {
 return elem.documentElement && !elem.body ||
 elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;
 },

 // Evalulates a script in a global context
 globalEval: function( data ) {
 data = jQuery.trim( data );

 if ( data ) {
 // Inspired by code by Andrea Giammarchi
 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
 var head = document.getElementsByTagName("head")[0] || document.documentElement,
 script = document.createElement("script");

 script.type = "text/javascript";
 if ( jQuery.browser.msie )
 script.text = data;
 else
 script.appendChild( document.createTextNode( data ) );

 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
 // This arises when a base node is used (#2709).
 head.insertBefore( script, head.firstChild );
 head.removeChild( script );
 }
 },

 nodeName: function( elem, name ) {
 return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
 },

 cache: {},

 data: function( elem, name, data ) {
 elem = elem == window ?
 windowData :
 elem;

 var id = elem[ expando ];

 // Compute a unique ID for the element
 if ( !id )
 id = elem[ expando ] = ++uuid;

 // Only generate the data cache if we're
 // trying to access or manipulate it
 if ( name && !jQuery.cache[ id ] )
 jQuery.cache[ id ] = {};

 // Prevent overriding the named cache with undefined values
 if ( data !== undefined )
 jQuery.cache[ id ][ name ] = data;

 // Return the named cache data, or the ID for the element
 return name ?
 jQuery.cache[ id ][ name ] :
 id;
 },

 removeData: function( elem, name ) {
 elem = elem == window ?
 windowData :
 elem;

 var id = elem[ expando ];

 // If we want to remove a specific section of the element's data
 if ( name ) {
 if ( jQuery.cache[ id ] ) {
 // Remove the section of cache data
 delete jQuery.cache[ id ][ name ];

 // If we've removed all the data, remove the element's cache
 name = "";

 for ( name in jQuery.cache[ id ] )
 break;

 if ( !name )
 jQuery.removeData( elem );
 }

 // Otherwise, we want to remove all of the element's data
 } else {
 // Clean up the element expando
 try {
 delete elem[ expando ];
 } catch(e){
 // IE has trouble directly removing the expando
 // but it's ok with using removeAttribute
 if ( elem.removeAttribute )
 elem.removeAttribute( expando );
 }

 // Completely remove the data cache
 delete jQuery.cache[ id ];
 }
 },

 // args is for internal usage only
 each: function( object, callback, args ) {
 var name, i = 0, length = object.length;

 if ( args ) {
 if ( length == undefined ) {
 for ( name in object )
 if ( callback.apply( object[ name ], args ) === false )
 break;
 } else
 for ( ; i < length; )
 if ( callback.apply( object[ i++ ], args ) === false )
 break;

 // A special, fast, case for the most common use of each
 } else {
 if ( length == undefined ) {
 for ( name in object )
 if ( callback.call( object[ name ], name, object[ name ] ) === false )
 break;
 } else
 for ( var value = object[0];
 i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
 }

 return object;
 },

 prop: function( elem, value, type, i, name ) {
 // Handle executable functions
 if ( jQuery.isFunction( value ) )
 value = value.call( elem, i );

 // Handle passing in a number to a CSS property
 return value && value.constructor == Number && type == "curCSS" && !exclude.test( name ) ?
 value + "px" :
 value;
 },

 className: {
 // internal only, use addClass("class")
 add: function( elem, classNames ) {
 jQuery.each((classNames || "").split(/\s+/), function(i, className){
 if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
 elem.className += (elem.className ? " " : "") + className;
 });
 },

 // internal only, use removeClass("class")
 remove: function( elem, classNames ) {
 if (elem.nodeType == 1)
 elem.className = classNames != undefined ?
 jQuery.grep(elem.className.split(/\s+/), function(className){
 return !jQuery.className.has( classNames, className );
 }).join(" ") :
 "";
 },

 // internal only, use hasClass("class")
 has: function( elem, className ) {
 return jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;
 }
 },

 // A method for quickly swapping in/out CSS properties to get correct calculations
 swap: function( elem, options, callback ) {
 var old = {};
 // Remember the old values, and insert the new ones
 for ( var name in options ) {
 old[ name ] = elem.style[ name ];
 elem.style[ name ] = options[ name ];
 }

 callback.call( elem );

 // Revert the old values
 for ( var name in options )
 elem.style[ name ] = old[ name ];
 },

 css: function( elem, name, force ) {
 if ( name == "width" || name == "height" ) {
 var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];

 function getWH() {
 val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
 var padding = 0, border = 0;
 jQuery.each( which, function() {
 padding += parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
 border += parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
 });
 val -= Math.round(padding + border);
 }

 if ( jQuery(elem).is(":visible") )
 getWH();
 else
 jQuery.swap( elem, props, getWH );

 return Math.max(0, val);
 }

 return jQuery.curCSS( elem, name, force );
 },

 curCSS: function( elem, name, force ) {
 var ret, style = elem.style;

 // A helper method for determining if an element's values are broken
 function color( elem ) {
 if ( !jQuery.browser.safari )
 return false;

 // defaultView is cached
 var ret = defaultView.getComputedStyle( elem, null );
 return !ret || ret.getPropertyValue("color") == "";
 }

 // We need to handle opacity special in IE
 if ( name == "opacity" && jQuery.browser.msie ) {
 ret = jQuery.attr( style, "opacity" );

 return ret == "" ?
 "1" :
 ret;
 }
 // Opera sometimes will give the wrong display answer, this fixes it, see #2037
 if ( jQuery.browser.opera && name == "display" ) {
 var save = style.outline;
 style.outline = "0 solid black";
 style.outline = save;
 }

 // Make sure we're using the right name for getting the float value
 if ( name.match( /float/i ) )
 name = styleFloat;

 if ( !force && style && style[ name ] )
 ret = style[ name ];

 else if ( defaultView.getComputedStyle ) {

 // Only "float" is needed here
 if ( name.match( /float/i ) )
 name = "float";

 name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();

 var computedStyle = defaultView.getComputedStyle( elem, null );

 if ( computedStyle && !color( elem ) )
 ret = computedStyle.getPropertyValue( name );

 // If the element isn't reporting its values properly in Safari
 // then some display: none elements are involved
 else {
 var swap = [], stack = [], a = elem, i = 0;

 // Locate all of the parent display: none elements
 for ( ; a && color(a); a = a.parentNode )
 stack.unshift(a);

 // Go through and make them visible, but in reverse
 // (It would be better if we knew the exact display type that they had)
 for ( ; i < stack.length; i++ )
 if ( color( stack[ i ] ) ) {
 swap[ i ] = stack[ i ].style.display;
 stack[ i ].style.display = "block";
 }

 // Since we flip the display style, we have to handle that
 // one special, otherwise get the value
 ret = name == "display" && swap[ stack.length - 1 ] != null ?
 "none" :
 ( computedStyle && computedStyle.getPropertyValue( name ) ) || "";

 // Finally, revert the display styles back
 for ( i = 0; i < swap.length; i++ )
 if ( swap[ i ] != null )
 stack[ i ].style.display = swap[ i ];
 }

 // We should always get a number back from opacity
 if ( name == "opacity" && ret == "" )
 ret = "1";

 } else if ( elem.currentStyle ) {
 var camelCase = name.replace(/\-(\w)/g, function(all, letter){
 return letter.toUpperCase();
 });

 ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];

 // From the awesome hack by Dean Edwards
 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

 // If we're not dealing with a regular pixel number
 // but a number that has a weird ending, we need to convert it to pixels
 if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
 // Remember the original values
 var left = style.left, rsLeft = elem.runtimeStyle.left;

 // Put in the new values to get a computed value out
 elem.runtimeStyle.left = elem.currentStyle.left;
 style.left = ret || 0;
 ret = style.pixelLeft + "px";

 // Revert the changed values
 style.left = left;
 elem.runtimeStyle.left = rsLeft;
 }
 }

 return ret;
 },

 clean: function( elems, context ) {
 var ret = [];
 context = context || document;
 // !context.createElement fails in IE with an error but returns typeof 'object'
 if (typeof context.createElement == 'undefined')
 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;

 jQuery.each(elems, function(i, elem){
 if ( !elem )
 return;

 if ( elem.constructor == Number )
 elem += '';

 // Convert html string into DOM nodes
 if ( typeof elem == "string" ) {
 // Fix "XHTML"-style tags in all browsers
 elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
 return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
 all :
 front + "></" + tag + ">";
 });

 // Trim whitespace, otherwise indexOf won't work as expected
 var tags = jQuery.trim( elem ).toLowerCase(), div = context.createElement("div");

 var wrap =
 // option or optgroup
 !tags.indexOf("<opt") &&
 [ 1, "<select multiple='multiple'>", "</select>" ] ||

 !tags.indexOf("<leg") &&
 [ 1, "<fieldset>", "</fieldset>" ] ||

 tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
 [ 1, "<table>", "</table>" ] ||

 !tags.indexOf("<tr") &&
 [ 2, "<table><tbody>", "</tbody></table>" ] ||

 // <thead> matched above
 (!tags.indexOf("<td") || !tags.indexOf("<th")) &&
 [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||

 !tags.indexOf("<col") &&
 [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||

 // IE can't serialize <link> and <script> tags normally
 jQuery.browser.msie &&
 [ 1, "div<div>", "</div>" ] ||

 [ 0, "", "" ];

 // Go to html and back, then peel off extra wrappers
 div.innerHTML = wrap[1] + elem + wrap[2];

 // Move to the right depth
 while ( wrap[0]-- )
 div = div.lastChild;

 // Remove IE's autoinserted <tbody> from table fragments
 if ( jQuery.browser.msie ) {

 // String was a <table>, *may* have spurious <tbody>
 var tbody = !tags.indexOf("<table") && tags.indexOf("<tbody") < 0 ?
 div.firstChild && div.firstChild.childNodes :

 // String was a bare <thead> or <tfoot>
 wrap[1] == "<table>" && tags.indexOf("<tbody") < 0 ?
 div.childNodes :
 [];

 for ( var j = tbody.length - 1; j >= 0 ; --j )
 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
 tbody[ j ].parentNode.removeChild( tbody[ j ] );

 // IE completely kills leading whitespace when innerHTML is used
 if ( /^\s/.test( elem ) )
 div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );

 }

 elem = jQuery.makeArray( div.childNodes );
 }

 if ( elem.length === 0 && (!jQuery.nodeName( elem, "form" ) && !jQuery.nodeName( elem, "select" )) )
 return;

 if ( elem[0] == undefined || jQuery.nodeName( elem, "form" ) || elem.options )
 ret.push( elem );

 else
 ret = jQuery.merge( ret, elem );

 });

 return ret;
 },

 attr: function( elem, name, value ) {
 // don't set attributes on text and comment nodes
 if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
 return undefined;

 var notxml = !jQuery.isXMLDoc( elem ),
 // Whether we are setting (or getting)
 set = value !== undefined,
 msie = jQuery.browser.msie;

 // Try to normalize/fix the name
 name = notxml && jQuery.props[ name ] || name;

 // Only do all the following if this is a node (faster for style)
 // IE elem.getAttribute passes even for style
 if ( elem.tagName ) {

 // These attributes require special treatment
 var special = /href|src|style/.test( name );

 // Safari mis-reports the default selected property of a hidden option
 // Accessing the parent's selectedIndex property fixes it
 if ( name == "selected" && jQuery.browser.safari )
 elem.parentNode.selectedIndex;

 // If applicable, access the attribute via the DOM 0 way
 if ( name in elem && notxml && !special ) {
 if ( set ){
 // We can't allow the type property to be changed (since it causes problems in IE)
 if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
 throw "type property can't be changed";

 elem[ name ] = value;
 }

 // browsers index elements by id/name on forms, give priority to attributes.
 if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
 return elem.getAttributeNode( name ).nodeValue;

 return elem[ name ];
 }

 if ( msie && notxml && name == "style" )
 return jQuery.attr( elem.style, "cssText", value );

 if ( set )
 // convert the value to a string (all browsers do this but IE) see #1070
 elem.setAttribute( name, "" + value );

 var attr = msie && notxml && special
 // Some attributes require a special call on IE
 ? elem.getAttribute( name, 2 )
 : elem.getAttribute( name );

 // Non-existent attributes return null, we normalize to undefined
 return attr === null ? undefined : attr;
 }

 // elem is actually elem.style ... set the style

 // IE uses filters for opacity
 if ( msie && name == "opacity" ) {
 if ( set ) {
 // IE has trouble with opacity if it does not have layout
 // Force it by setting the zoom level
 elem.zoom = 1;

 // Set the alpha filter to set the opacity
 elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
 (parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
 }

 return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
 (parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
 "";
 }

 name = name.replace(/-([a-z])/ig, function(all, letter){
 return letter.toUpperCase();
 });

 if ( set )
 elem[ name ] = value;

 return elem[ name ];
 },

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

 makeArray: function( array ) {
 var ret = [];

 if( array != null ){
 var i = array.length;
 //the window, strings and functions also have 'length'
 if( i == null || array.split || array.setInterval || array.call )
 ret[0] = array;
 else
 while( i )
 ret[--i] = array[i];
 }

 return ret;
 },

 inArray: function( elem, array ) {
 for ( var i = 0, length = array.length; i < length; i++ )
 // Use === because on IE, window == document
 if ( array[ i ] === elem )
 return i;

 return -1;
 },

 merge: function( first, second ) {
 // We have to loop this way because IE & Opera overwrite the length
 // expando of getElementsByTagName
 var i = 0, elem, pos = first.length;
 // Also, we need to make sure that the correct elements are being returned
 // (IE returns comment nodes in a '*' query)
 if ( jQuery.browser.msie ) {
 while ( elem = second[ i++ ] )
 if ( elem.nodeType != 8 )
 first[ pos++ ] = elem;

 } else
 while ( elem = second[ i++ ] )
 first[ pos++ ] = elem;

 return first;
 },

 unique: function( array ) {
 var ret = [], done = {};

 try {

 for ( var i = 0, length = array.length; i < length; i++ ) {
 var id = jQuery.data( array[ i ] );

 if ( !done[ id ] ) {
 done[ id ] = true;
 ret.push( array[ i ] );
 }
 }

 } catch( e ) {
 ret = array;
 }

 return ret;
 },

 grep: function( elems, callback, inv ) {
 var ret = [];

 // Go through the array, only saving the items
 // that pass the validator function
 for ( var i = 0, length = elems.length; i < length; i++ )
 if ( !inv != !callback( elems[ i ], i ) )
 ret.push( elems[ i ] );

 return ret;
 },

 map: function( elems, callback ) {
 var ret = [];

 // Go through the array, translating each of the items to their
 // new value (or values).
 for ( var i = 0, length = elems.length; i < length; i++ ) {
 var value = callback( elems[ i ], i );

 if ( value != null )
 ret[ ret.length ] = value;
 }

 return ret.concat.apply( [], ret );
 }
});

var userAgent = navigator.userAgent.toLowerCase();

// Figure out what browser is being used
jQuery.browser = {
 version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
 safari: /webkit/.test( userAgent ),
 opera: /opera/.test( userAgent ),
 msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
 mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};

var styleFloat = jQuery.browser.msie ?
 "styleFloat" :
 "cssFloat";

jQuery.extend({
 // Check to see if the W3C box model is being used
 boxModel: !jQuery.browser.msie || document.compatMode == "CSS1Compat",

 props: {
 "for": "htmlFor",
 "class": "className",
 "float": styleFloat,
 cssFloat: styleFloat,
 styleFloat: styleFloat,
 readonly: "readOnly",
 maxlength: "maxLength",
 cellspacing: "cellSpacing"
 }
});

jQuery.each({
 parent: function(elem){return elem.parentNode;},
 parents: function(elem){return jQuery.dir(elem,"parentNode");},
 next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
 prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
 nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
 prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
 siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
 children: function(elem){return jQuery.sibling(elem.firstChild);},
 contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
}, function(name, fn){
 jQuery.fn[ name ] = function( selector ) {
 var ret = jQuery.map( this, fn );

 if ( selector && typeof selector == "string" )
 ret = jQuery.multiFilter( selector, ret );

 return this.pushStack( jQuery.unique( ret ) );
 };
});

jQuery.each({
 appendTo: "append",
 prependTo: "prepend",
 insertBefore: "before",
 insertAfter: "after",
 replaceAll: "replaceWith"
}, function(name, original){
 jQuery.fn[ name ] = function() {
 var args = arguments;

 return this.each(function(){
 for ( var i = 0, length = args.length; i < length; i++ )
 jQuery( args[ i ] )[ original ]( this );
 });
 };
});

jQuery.each({
 removeAttr: function( name ) {
 jQuery.attr( this, name, "" );
 if (this.nodeType == 1)
 this.removeAttribute( name );
 },

 addClass: function( classNames ) {
 jQuery.className.add( this, classNames );
 },

 removeClass: function( classNames ) {
 jQuery.className.remove( this, classNames );
 },

 toggleClass: function( classNames ) {
 jQuery.className[ jQuery.className.has( this, classNames ) ? "remove" : "add" ]( this, classNames );
 },

 remove: function( selector ) {
 if ( !selector || jQuery.filter( selector, [ this ] ).r.length ) {
 // Prevent memory leaks
 jQuery( "*", this ).add(this).each(function(){
 jQuery.event.remove(this);
 jQuery.removeData(this);
 });
 if (this.parentNode)
 this.parentNode.removeChild( this );
 }
 },

 empty: function() {
 // Remove element nodes and prevent memory leaks
 jQuery( ">*", this ).remove();

 // Remove any remaining nodes
 while ( this.firstChild )
 this.removeChild( this.firstChild );
 }
}, function(name, fn){
 jQuery.fn[ name ] = function(){
 return this.each( fn, arguments );
 };
});

jQuery.each([ "Height", "Width" ], function(i, name){
 var type = name.toLowerCase();

 jQuery.fn[ type ] = function( size ) {
 // Get window width or height
 return this[0] == window ?
 // Opera reports document.body.client[Width/Height] properly in both quirks and standards
 jQuery.browser.opera && document.body[ "client" + name ] ||

 // Safari reports inner[Width/Height] just fine (Mozilla and Opera include scroll bar widths)
 jQuery.browser.safari && window[ "inner" + name ] ||

 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
 document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :

 // Get document width or height
 this[0] == document ?
 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
 Math.max(
 Math.max(document.body["scroll" + name], document.documentElement["scroll" + name]),
 Math.max(document.body["offset" + name], document.documentElement["offset" + name])
 ) :

 // Get or set width or height on the element
 size == undefined ?
 // Get width or height on the element
 (this.length ? jQuery.css( this[0], type ) : null) :

 // Set the width or height on the element (default to pixels if value is unitless)
 this.css( type, size.constructor == String ? size : size + "px" );
 };
});

// Helper function used by the dimensions and offset modules
function num(elem, prop) {
 return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
}var chars = jQuery.browser.safari && parseInt(jQuery.browser.version) < 417 ?
 "(?:[\\w*_-]|\\\\.)" :
 "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)",
 quickChild = new RegExp("^>\\s*(" + chars + "+)"),
 quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)"),
 quickClass = new RegExp("^([#.]?)(" + chars + "*)");

jQuery.extend({
 expr: {
 "": function(a,i,m){return m[2]=="*"||jQuery.nodeName(a,m[2]);},
 "#": function(a,i,m){return a.getAttribute("id")==m[2];},
 ":": {
 // Position Checks
 lt: function(a,i,m){return i<m[3]-0;},
 gt: function(a,i,m){return i>m[3]-0;},
 nth: function(a,i,m){return m[3]-0==i;},
 eq: function(a,i,m){return m[3]-0==i;},
 first: function(a,i){return i==0;},
 last: function(a,i,m,r){return i==r.length-1;},
 even: function(a,i){return i%2==0;},
 odd: function(a,i){return i%2;},

 // Child Checks
 "first-child": function(a){return a.parentNode.getElementsByTagName("*")[0]==a;},
 "last-child": function(a){return jQuery.nth(a.parentNode.lastChild,1,"previousSibling")==a;},
 "only-child": function(a){return !jQuery.nth(a.parentNode.lastChild,2,"previousSibling");},

 // Parent Checks
 parent: function(a){return a.firstChild;},
 empty: function(a){return !a.firstChild;},

 // Text Check
 contains: function(a,i,m){return (a.textContent||a.innerText||jQuery(a).text()||"").indexOf(m[3])>=0;},

 // Visibility
 visible: function(a){return "hidden"!=a.type&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden";},
 hidden: function(a){return "hidden"==a.type||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden";},

 // Form attributes
 enabled: function(a){return !a.disabled;},
 disabled: function(a){return a.disabled;},
 checked: function(a){return a.checked;},
 selected: function(a){return a.selected||jQuery.attr(a,"selected");},

 // Form elements
 text: function(a){return "text"==a.type;},
 radio: function(a){return "radio"==a.type;},
 checkbox: function(a){return "checkbox"==a.type;},
 file: function(a){return "file"==a.type;},
 password: function(a){return "password"==a.type;},
 submit: function(a){return "submit"==a.type;},
 image: function(a){return "image"==a.type;},
 reset: function(a){return "reset"==a.type;},
 button: function(a){return "button"==a.type||jQuery.nodeName(a,"button");},
 input: function(a){return /input|select|textarea|button/i.test(a.nodeName);},

 // :has()
 has: function(a,i,m){return jQuery.find(m[3],a).length;},

 // :header
 header: function(a){return /h\d/i.test(a.nodeName);},

 // :animated
 animated: function(a){return jQuery.grep(jQuery.timers,function(fn){return a==fn.elem;}).length;}
 }
 },

 // The regular expressions that power the parsing engine
 parse: [
 // Match: [@value='test'], [@foo]
 /^(\[) *@?([\w-]+) *([!*$^~=]*) *('?"?)(.*?)\4 *\]/,

 // Match: :contains('foo')
 /^(:)([\w-]+)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/,

 // Match: :even, :last-child, #id, .class
 new RegExp("^([:.#]*)(" + chars + "+)")
 ],

 multiFilter: function( expr, elems, not ) {
 var old, cur = [];

 while ( expr && expr != old ) {
 old = expr;
 var f = jQuery.filter( expr, elems, not );
 expr = f.t.replace(/^\s*,\s*/, "" );
 cur = not ? elems = f.r : jQuery.merge( cur, f.r );
 }

 return cur;
 },

 find: function( t, context ) {
 // Quickly handle non-string expressions
 if ( typeof t != "string" )
 return [ t ];

 // check to make sure context is a DOM element or a document
 if ( context && context.nodeType != 1 && context.nodeType != 9)
 return [ ];

 // Set the correct context (if none is provided)
 context = context || document;

 // Initialize the search
 var ret = [context], done = [], last, nodeName;

 // Continue while a selector expression exists, and while
 // we're no longer looping upon ourselves
 while ( t && last != t ) {
 var r = [];
 last = t;

 t = jQuery.trim(t);

 var foundToken = false,

 // An attempt at speeding up child selectors that
 // point to a specific element tag
 re = quickChild,

 m = re.exec(t);

 if ( m ) {
 nodeName = m[1].toUpperCase();

 // Perform our own iteration and filter
 for ( var i = 0; ret[i]; i++ )
 for ( var c = ret[i].firstChild; c; c = c.nextSibling )
 if ( c.nodeType == 1 && (nodeName == "*" || c.nodeName.toUpperCase() == nodeName) )
 r.push( c );

 ret = r;
 t = t.replace( re, "" );
 if ( t.indexOf(" ") == 0 ) continue;
 foundToken = true;
 } else {
 re = /^([>+~])\s*(\w*)/i;

 if ( (m = re.exec(t)) != null ) {
 r = [];

 var merge = {};
 nodeName = m[2].toUpperCase();
 m = m[1];

 for ( var j = 0, rl = ret.length; j < rl; j++ ) {
 var n = m == "~" || m == "+" ? ret[j].nextSibling : ret[j].firstChild;
 for ( ; n; n = n.nextSibling )
 if ( n.nodeType == 1 ) {
 var id = jQuery.data(n);

 if ( m == "~" && merge[id] ) break;

 if (!nodeName || n.nodeName.toUpperCase() == nodeName ) {
 if ( m == "~" ) merge[id] = true;
 r.push( n );
 }

 if ( m == "+" ) break;
 }
 }

 ret = r;

 // And remove the token
 t = jQuery.trim( t.replace( re, "" ) );
 foundToken = true;
 }
 }

 // See if there's still an expression, and that we haven't already
 // matched a token
 if ( t && !foundToken ) {
 // Handle multiple expressions
 if ( !t.indexOf(",") ) {
 // Clean the result set
 if ( context == ret[0] ) ret.shift();

 // Merge the result sets
 done = jQuery.merge( done, ret );

 // Reset the context
 r = ret = [context];

 // Touch up the selector string
 t = " " + t.substr(1,t.length);

 } else {
 // Optimize for the case nodeName#idName
 var re2 = quickID;
 var m = re2.exec(t);

 // Re-organize the results, so that they're consistent
 if ( m ) {
 m = [ 0, m[2], m[3], m[1] ];

 } else {
 // Otherwise, do a traditional filter check for
 // ID, class, and element selectors
 re2 = quickClass;
 m = re2.exec(t);
 }

 m[2] = m[2].replace(/\\/g, "");

 var elem = ret[ret.length-1];

 // Try to do a global search by ID, where we can
 if ( m[1] == "#" && elem && elem.getElementById && !jQuery.isXMLDoc(elem) ) {
 // Optimization for HTML document case
 var oid = elem.getElementById(m[2]);

 // Do a quick check for the existence of the actual ID attribute
 // to avoid selecting by the name attribute in IE
 // also check to insure id is a string to avoid selecting an element with the name of 'id' inside a form
 if ( (jQuery.browser.msie||jQuery.browser.opera) && oid && typeof oid.id == "string" && oid.id != m[2] )
 oid = jQuery('[@id="'+m[2]+'"]', elem)[0];

 // Do a quick check for node name (where applicable) so
 // that div#foo searches will be really fast
 ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];
 } else {
 // We need to find all descendant elements
 for ( var i = 0; ret[i]; i++ ) {
 // Grab the tag name being searched for
 var tag = m[1] == "#" && m[3] ? m[3] : m[1] != "" || m[0] == "" ? "*" : m[2];

 // Handle IE7 being really dumb about <object>s
 if ( tag == "*" && ret[i].nodeName.toLowerCase() == "object" )
 tag = "param";

 r = jQuery.merge( r, ret[i].getElementsByTagName( tag ));
 }

 // It's faster to filter by class and be done with it
 if ( m[1] == "." )
 r = jQuery.classFilter( r, m[2] );

 // Same with ID filtering
 if ( m[1] == "#" ) {
 var tmp = [];

 // Try to find the element with the ID
 for ( var i = 0; r[i]; i++ )
 if ( r[i].getAttribute("id") == m[2] ) {
 tmp = [ r[i] ];
 break;
 }

 r = tmp;
 }

 ret = r;
 }

 t = t.replace( re2, "" );
 }

 }

 // If a selector string still exists
 if ( t ) {
 // Attempt to filter it
 var val = jQuery.filter(t,r);
 ret = r = val.r;
 t = jQuery.trim(val.t);
 }
 }

 // An error occurred with the selector;
 // just return an empty set instead
 if ( t )
 ret = [];

 // Remove the root context
 if ( ret && context == ret[0] )
 ret.shift();

 // And combine the results
 done = jQuery.merge( done, ret );

 return done;
 },

 classFilter: function(r,m,not){
 m = " " + m + " ";
 var tmp = [];
 for ( var i = 0; r[i]; i++ ) {
 var pass = (" " + r[i].className + " ").indexOf( m ) >= 0;
 if ( !not && pass || not && !pass )
 tmp.push( r[i] );
 }
 return tmp;
 },

 filter: function(t,r,not) {
 var last;

 // Look for common filter expressions
 while ( t && t != last ) {
 last = t;

 var p = jQuery.parse, m;

 for ( var i = 0; p[i]; i++ ) {
 m = p[i].exec( t );

 if ( m ) {
 // Remove what we just matched
 t = t.substring( m[0].length );

 m[2] = m[2].replace(/\\/g, "");
 break;
 }
 }

 if ( !m )
 break;

 // :not() is a special case that can be optimized by
 // keeping it out of the expression list
 if ( m[1] == ":" && m[2] == "not" )
 // optimize if only one selector found (most common case)
 r = isSimple.test( m[3] ) ?
 jQuery.filter(m[3], r, true).r :
 jQuery( r ).not( m[3] );

 // We can get a big speed boost by filtering by class here
 else if ( m[1] == "." )
 r = jQuery.classFilter(r, m[2], not);

 else if ( m[1] == "[" ) {
 var tmp = [], type = m[3];

 for ( var i = 0, rl = r.length; i < rl; i++ ) {
 var a = r[i], z = a[ jQuery.props[m[2]] || m[2] ];

 if ( z == null || /href|src|selected/.test(m[2]) )
 z = jQuery.attr(a,m[2]) || '';

 if ( (type == "" && !!z ||
 type == "=" && z == m[5] ||
 type == "!=" && z != m[5] ||
 type == "^=" && z && !z.indexOf(m[5]) ||
 type == "$=" && z.substr(z.length - m[5].length) == m[5] ||
 (type == "*=" || type == "~=") && z.indexOf(m[5]) >= 0) ^ not )
 tmp.push( a );
 }

 r = tmp;

 // We can get a speed boost by handling nth-child here
 } else if ( m[1] == ":" && m[2] == "nth-child" ) {
 var merge = {}, tmp = [],
 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
 test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
 m[3] == "even" && "2n" || m[3] == "odd" && "2n+1" ||
 !/\D/.test(m[3]) && "0n+" + m[3] || m[3]),
 // calculate the numbers (first)n+(last) including if they are negative
 first = (test[1] + (test[2] || 1)) - 0, last = test[3] - 0;

 // loop through all the elements left in the jQuery object
 for ( var i = 0, rl = r.length; i < rl; i++ ) {
 var node = r[i], parentNode = node.parentNode, id = jQuery.data(parentNode);

 if ( !merge[id] ) {
 var c = 1;

 for ( var n = parentNode.firstChild; n; n = n.nextSibling )
 if ( n.nodeType == 1 )
 n.nodeIndex = c++;

 merge[id] = true;
 }

 var add = false;

 if ( first == 0 ) {
 if ( node.nodeIndex == last )
 add = true;
 } else if ( (node.nodeIndex - last) % first == 0 && (node.nodeIndex - last) / first >= 0 )
 add = true;

 if ( add ^ not )
 tmp.push( node );
 }

 r = tmp;

 // Otherwise, find the expression to execute
 } else {
 var fn = jQuery.expr[ m[1] ];
 if ( typeof fn == "object" )
 fn = fn[ m[2] ];

 if ( typeof fn == "string" )
 fn = eval("false||function(a,i){return " + fn + ";}");

 // Execute it against the current filter
 r = jQuery.grep( r, function(elem, i){
 return fn(elem, i, m, r);
 }, not );
 }
 }

 // Return an array of filtered elements (r)
 // and the modified expression string (t)
 return { r: r, t: t };
 },

 dir: function( elem, dir ){
 var matched = [],
 cur = elem[dir];
 while ( cur && cur != document ) {
 if ( cur.nodeType == 1 )
 matched.push( cur );
 cur = cur[dir];
 }
 return matched;
 },

 nth: function(cur,result,dir,elem){
 result = result || 1;
 var num = 0;

 for ( ; cur; cur = cur[dir] )
 if ( cur.nodeType == 1 && ++num == result )
 break;

 return cur;
 },

 sibling: function( n, elem ) {
 var r = [];

 for ( ; n; n = n.nextSibling ) {
 if ( n.nodeType == 1 && n != elem )
 r.push( n );
 }

 return r;
 }
});
/*
 * A number of helper functions used for managing events.
 * Many of the ideas behind this code orignated from
 * Dean Edwards' addEvent library.
 */
jQuery.event = {

 // Bind an event to an element
 // Original by Dean Edwards
 add: function(elem, types, handler, data) {
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return;

 // For whatever reason, IE has trouble passing the window object
 // around, causing it to be cloned in the process
 if ( jQuery.browser.msie && elem.setInterval )
 elem = window;

 // Make sure that the function being executed has a unique ID
 if ( !handler.guid )
 handler.guid = this.guid++;

 // if data is passed, bind to handler
 if( data != undefined ) {
 // Create temporary function pointer to original handler
 var fn = handler;

 // Create unique handler function, wrapped around original handler
 handler = this.proxy( fn, function() {
 // Pass arguments and context to original handler
 return fn.apply(this, arguments);
 });

 // Store data in unique handler
 handler.data = data;
 }

 // Init the element's event structure
 var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
 handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
 // Handle the second event of a trigger and when
 // an event is called after a page has unloaded
 if ( typeof jQuery != "undefined" && !jQuery.event.triggered )
 return jQuery.event.handle.apply(arguments.callee.elem, arguments);
 });
 // Add elem as a property of the handle function
 // This is to prevent a memory leak with non-native
 // event in IE.
 handle.elem = elem;

 // Handle multiple events separated by a space
 // jQuery(...).bind("mouseover mouseout", fn);
 jQuery.each(types.split(/\s+/), function(index, type) {
 // Namespaced event handlers
 var parts = type.split(".");
 type = parts[0];
 handler.type = parts[1];

 // Get the current list of functions bound to this event
 var handlers = events[type];

 // Init the event handler queue
 if (!handlers) {
 handlers = events[type] = {};

 // Check for a special event handler
 // Only use addEventListener/attachEvent if the special
 // events handler returns false
 if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem) === false ) {
 // Bind the global event handler to the element
 if (elem.addEventListener)
 elem.addEventListener(type, handle, false);
 else if (elem.attachEvent)
 elem.attachEvent("on" + type, handle);
 }
 }

 // Add the function to the element's handler list
 handlers[handler.guid] = handler;

 // Keep track of which events have been used, for global triggering
 jQuery.event.global[type] = true;
 });

 // Nullify elem to prevent memory leaks in IE
 elem = null;
 },

 guid: 1,
 global: {},

 // Detach an event or set of events from an element
 remove: function(elem, types, handler) {
 // don't do events on text and comment nodes
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return;

 var events = jQuery.data(elem, "events"), ret, index;

 if ( events ) {
 // Unbind all events for the element
 if ( types == undefined || (typeof types == "string" && types.charAt(0) == ".") )
 for ( var type in events )
 this.remove( elem, type + (types || "") );
 else {
 // types is actually an event object here
 if ( types.type ) {
 handler = types.handler;
 types = types.type;
 }

 // Handle multiple events seperated by a space
 // jQuery(...).unbind("mouseover mouseout", fn);
 jQuery.each(types.split(/\s+/), function(index, type){
 // Namespaced event handlers
 var parts = type.split(".");
 type = parts[0];

 if ( events[type] ) {
 // remove the given handler for the given type
 if ( handler )
 delete events[type][handler.guid];

 // remove all handlers for the given type
 else
 for ( handler in events[type] )
 // Handle the removal of namespaced events
 if ( !parts[1] || events[type][handler].type == parts[1] )
 delete events[type][handler];

 // remove generic event handler if no more handlers exist
 for ( ret in events[type] ) break;
 if ( !ret ) {
 if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem) === false ) {
 if (elem.removeEventListener)
 elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
 else if (elem.detachEvent)
 elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
 }
 ret = null;
 delete events[type];
 }
 }
 });
 }

 // Remove the expando if it's no longer used
 for ( ret in events ) break;
 if ( !ret ) {
 var handle = jQuery.data( elem, "handle" );
 if ( handle ) handle.elem = null;
 jQuery.removeData( elem, "events" );
 jQuery.removeData( elem, "handle" );
 }
 }
 },

 trigger: function(type, data, elem, donative, extra) {
 // Clone the incoming data, if any
 data = jQuery.makeArray(data);

 if ( type.indexOf("!") >= 0 ) {
 type = type.slice(0, -1);
 var exclusive = true;
 }

 // Handle a global trigger
 if ( !elem ) {
 // Only trigger if we've ever bound an event for it
 if ( this.global[type] )
 jQuery("*").add([window, document]).trigger(type, data);

 // Handle triggering a single element
 } else {
 // don't do events on text and comment nodes
 if ( elem.nodeType == 3 || elem.nodeType == 8 )
 return undefined;

 var val, ret, fn = jQuery.isFunction( elem[ type ] || null ),
 // Check to see if we need to provide a fake event, or not
 event = !data[0] || !data[0].preventDefault;

 // Pass along a fake event
 if ( event ) {
 data.unshift({
 type: type,
 target: elem,
 preventDefault: function(){},
 stopPropagation: function(){},
 timeStamp: now()
 });
 data[0][expando] = true; // no need to fix fake event
 }

 // Enforce the right trigger type
 data[0].type = type;
 if ( exclusive )
 data[0].exclusive = true;

 // Trigger the event, it is assumed that "handle" is a function
 var handle = jQuery.data(elem, "handle");
 if ( handle )
 val = handle.apply( elem, data );

 // Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
 if ( (!fn || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
 val = false;

 // Extra functions don't get the custom event object
 if ( event )
 data.shift();

 // Handle triggering of extra function
 if ( extra && jQuery.isFunction( extra ) ) {
 // call the extra function and tack the current return value on the end for possible inspection
 ret = extra.apply( elem, val == null ? data : data.concat( val ) );
 // if anything is returned, give it precedence and have it overwrite the previous value
 if (ret !== undefined)
 val = ret;
 }

 // Trigger the native events (except for clicks on links)
 if ( fn && donative !== false && val !== false && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
 this.triggered = true;
 try {
 elem[ type ]();
 // prevent IE from throwing an error for some hidden elements
 } catch (e) {}
 }

 this.triggered = false;
 }

 return val;
 },

 handle: function(event) {
 // returned undefined or false
 var val, ret, namespace, all, handlers;

 event = arguments[0] = jQuery.event.fix( event || window.event );

 // Namespaced event handlers
 namespace = event.type.split(".");
 event.type = namespace[0];
 namespace = namespace[1];
 // Cache this now, all = true means, any handler
 all = !namespace && !event.exclusive;

 handlers = ( jQuery.data(this, "events") || {} )[event.type];

 for ( var j in handlers ) {
 var handler = handlers[j];

 // Filter the functions by class
 if ( all || handler.type == namespace ) {
 // Pass in a reference to the handler function itself
 // So that we can later remove it
 event.handler = handler;
 event.data = handler.data;

 ret = handler.apply( this, arguments );

 if ( val !== false )
 val = ret;

 if ( ret === false ) {
 event.preventDefault();
 event.stopPropagation();
 }
 }
 }

 return val;
 },

 fix: function(event) {
 if ( event[expando] == true )
 return event;

 // store a copy of the original event object
 // and "clone" to set read-only properties
 var originalEvent = event;
 event = { originalEvent: originalEvent };
 var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target timeStamp toElement type view wheelDelta which".split(" ");
 for ( var i=props.length; i; i-- )
 event[ props[i] ] = originalEvent[ props[i] ];

 // Mark it as fixed
 event[expando] = true;

 // add preventDefault and stopPropagation since
 // they will not work on the clone
 event.preventDefault = function() {
 // if preventDefault exists run it on the original event
 if (originalEvent.preventDefault)
 originalEvent.preventDefault();
 // otherwise set the returnValue property of the original event to false (IE)
 originalEvent.returnValue = false;
 };
 event.stopPropagation = function() {
 // if stopPropagation exists run it on the original event
 if (originalEvent.stopPropagation)
 originalEvent.stopPropagation();
 // otherwise set the cancelBubble property of the original event to true (IE)
 originalEvent.cancelBubble = true;
 };

 // Fix timeStamp
 event.timeStamp = event.timeStamp || now();

 // Fix target property, if necessary
 if ( !event.target )
 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either

 // check if target is a textnode (safari)
 if ( event.target.nodeType == 3 )
 event.target = event.target.parentNode;

 // Add relatedTarget, if necessary
 if ( !event.relatedTarget && event.fromElement )
 event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;

 // Calculate pageX/Y if missing and clientX/Y available
 if ( event.pageX == null && event.clientX != null ) {
 var doc = document.documentElement, body = document.body;
 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
 }

 // Add which for key events
 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
 event.which = event.charCode || event.keyCode;

 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
 if ( !event.metaKey && event.ctrlKey )
 event.metaKey = event.ctrlKey;

 // Add which for click: 1 == left; 2 == middle; 3 == right
 // Note: button is not normalized, so don't use it
 if ( !event.which && event.button )
 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));

 return event;
 },

 proxy: function( fn, proxy ){
 // Set the guid of unique handler to the same of original handler, so it can be removed
 proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
 // So proxy can be declared as an argument
 return proxy;
 },

 special: {
 ready: {
 setup: function() {
 // Make sure the ready event is setup
 bindReady();
 return;
 },

 teardown: function() { return; }
 },

 mouseenter: {
 setup: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).bind("mouseover", jQuery.event.special.mouseenter.handler);
 return true;
 },

 teardown: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).unbind("mouseover", jQuery.event.special.mouseenter.handler);
 return true;
 },

 handler: function(event) {
 // If we actually just moused on to a sub-element, ignore it
 if ( withinElement(event, this) ) return true;
 // Execute the right handlers by setting the event type to mouseenter
 event.type = "mouseenter";
 return jQuery.event.handle.apply(this, arguments);
 }
 },

 mouseleave: {
 setup: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).bind("mouseout", jQuery.event.special.mouseleave.handler);
 return true;
 },

 teardown: function() {
 if ( jQuery.browser.msie ) return false;
 jQuery(this).unbind("mouseout", jQuery.event.special.mouseleave.handler);
 return true;
 },

 handler: function(event) {
 // If we actually just moused on to a sub-element, ignore it
 if ( withinElement(event, this) ) return true;
 // Execute the right handlers by setting the event type to mouseleave
 event.type = "mouseleave";
 return jQuery.event.handle.apply(this, arguments);
 }
 }
 }
};

jQuery.fn.extend({
 bind: function( type, data, fn ) {
 return type == "unload" ? this.one(type, data, fn) : this.each(function(){
 jQuery.event.add( this, type, fn || data, fn && data );
 });
 },

 one: function( type, data, fn ) {
 var one = jQuery.event.proxy( fn || data, function(event) {
 jQuery(this).unbind(event, one);
 return (fn || data).apply( this, arguments );
 });
 return this.each(function(){
 jQuery.event.add( this, type, one, fn && data);
 });
 },

 unbind: function( type, fn ) {
 return this.each(function(){
 jQuery.event.remove( this, type, fn );
 });
 },

 trigger: function( type, data, fn ) {
 return this.each(function(){
 jQuery.event.trigger( type, data, this, true, fn );
 });
 },

 triggerHandler: function( type, data, fn ) {
 return this[0] && jQuery.event.trigger( type, data, this[0], false, fn );
 },

 toggle: function( fn ) {
 // Save reference to arguments for access in closure
 var args = arguments, i = 1;

 // link all the functions, so any of them can unbind this click handler
 while( i < args.length )
 jQuery.event.proxy( fn, args[i++] );

 return this.click( jQuery.event.proxy( fn, function(event) {
 // Figure out which function to execute
 this.lastToggle = ( this.lastToggle || 0 ) % i;

 // Make sure that clicks stop
 event.preventDefault();

 // and execute the function
 return args[ this.lastToggle++ ].apply( this, arguments ) || false;
 }));
 },

 hover: function(fnOver, fnOut) {
 return this.bind('mouseenter', fnOver).bind('mouseleave', fnOut);
 },

 ready: function(fn) {
 // Attach the listeners
 bindReady();

 // If the DOM is already ready
 if ( jQuery.isReady )
 // Execute the function immediately
 fn.call( document, jQuery );

 // Otherwise, remember the function for later
 else
 // Add the function to the wait list
 jQuery.readyList.push( function() { return fn.call(this, jQuery); } );

 return this;
 }
});

jQuery.extend({
 isReady: false,
 readyList: [],
 // Handle when the DOM is ready
 ready: function() {
 // Make sure that the DOM is not already loaded
 if ( !jQuery.isReady ) {
 // Remember that the DOM is ready
 jQuery.isReady = true;

 // If there are functions bound, to execute
 if ( jQuery.readyList ) {
 // Execute all of them
 jQuery.each( jQuery.readyList, function(){
 this.call( document );
 });

 // Reset the list of functions
 jQuery.readyList = null;
 }

 // Trigger any bound ready events
 jQuery(document).triggerHandler("ready");
 }
 }
});

var readyBound = false;

function bindReady(){
 if ( readyBound ) return;
 readyBound = true;

 // Mozilla, Opera (see further below for it) and webkit nightlies currently support this event
 if ( document.addEventListener && !jQuery.browser.opera)
 // Use the handy event callback
 document.addEventListener( "DOMContentLoaded", jQuery.ready, false );

 // If IE is used and is not in a frame
 // Continually check to see if the document is ready
 if ( jQuery.browser.msie && window == top ) (function(){
 if (jQuery.isReady) return;
 try {
 // If IE is used, use the trick by Diego Perini
 // http://javascript.nwbox.com/IEContentLoaded/
 document.documentElement.doScroll("left");
 } catch( error ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 })();

 if ( jQuery.browser.opera )
 document.addEventListener( "DOMContentLoaded", function () {
 if (jQuery.isReady) return;
 for (var i = 0; i < document.styleSheets.length; i++)
 if (document.styleSheets[i].disabled) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 }, false);

 if ( jQuery.browser.safari ) {
 var numStyles;
 (function(){
 if (jQuery.isReady) return;
 if ( document.readyState != "loaded" && document.readyState != "complete" ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 if ( numStyles === undefined )
 numStyles = jQuery("style, link[rel=stylesheet]").length;
 if ( document.styleSheets.length != numStyles ) {
 setTimeout( arguments.callee, 0 );
 return;
 }
 // and execute any waiting functions
 jQuery.ready();
 })();
 }

 // A fallback to window.onload, that will always work
 jQuery.event.add( window, "load", jQuery.ready );
}

jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
 "mousedown,mouseup,mousemove,mouseover,mouseout,change,select," +
 "submit,keydown,keypress,keyup,error").split(","), function(i, name){

 // Handle event binding
 jQuery.fn[name] = function(fn){
 return fn ? this.bind(name, fn) : this.trigger(name);
 };
});

// Checks if an event happened on an element within another element
// Used in jQuery.event.special.mouseenter and mouseleave handlers
var withinElement = function(event, elem) {
 // Check if mouse(over|out) are still within the same parent element
 var parent = event.relatedTarget;
 // Traverse up the tree
 while ( parent && parent != elem ) try { parent = parent.parentNode; } catch(error) { parent = elem; }
 // Return true if we actually just moused on to a sub-element
 return parent == elem;
};

// Prevent memory leaks in IE
// And prevent errors on refresh with events like mouseover in other browsers
// Window isn't included so as not to unbind existing unload events
jQuery(window).bind("unload", function() {
 jQuery("*").add(document).unbind();
});
jQuery.fn.extend({
 // Keep a copy of the old load
 _load: jQuery.fn.load,

 load: function( url, params, callback ) {
 if ( typeof url != 'string' )
 return this._load( url );

 var off = url.indexOf(" ");
 if ( off >= 0 ) {
 var selector = url.slice(off, url.length);
 url = url.slice(0, off);
 }

 callback = callback || function(){};

 // Default to a GET request
 var type = "GET";

 // If the second parameter was provided
 if ( params )
 // If it's a function
 if ( jQuery.isFunction( params ) ) {
 // We assume that it's the callback
 callback = params;
 params = null;

 // Otherwise, build a param string
 } else {
 params = jQuery.param( params );
 type = "POST";
 }

 var self = this;

 // Request the remote document
 jQuery.ajax({
 url: url,
 type: type,
 dataType: "html",
 data: params,
 complete: function(res, status){
 // If successful, inject the HTML into all the matched elements
 if ( status == "success" || status == "notmodified" )
 // See if a selector was specified
 self.html( selector ?
 // Create a dummy div to hold the results
 jQuery("<div/>")
 // inject the contents of the document in, removing the scripts
 // to avoid any 'Permission Denied' errors in IE
 .append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))

 // Locate the specified elements
 .find(selector) :

 // If not, just inject the full result
 res.responseText );

 self.each( callback, [res.responseText, status, res] );
 }
 });
 return this;
 },

 serialize: function() {
 return jQuery.param(this.serializeArray());
 },
 serializeArray: function() {
 return this.map(function(){
 return jQuery.nodeName(this, "form") ?
 jQuery.makeArray(this.elements) : this;
 })
 .filter(function(){
 return this.name && !this.disabled &&
 (this.checked || /select|textarea/i.test(this.nodeName) ||
 /text|hidden|password/i.test(this.type));
 })
 .map(function(i, elem){
 var val = jQuery(this).val();
 return val == null ? null :
 val.constructor == Array ?
 jQuery.map( val, function(val, i){
 return {name: elem.name, value: val};
 }) :
 {name: elem.name, value: val};
 }).get();
 }
});

// Attach a bunch of functions for handling common AJAX events
jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
 jQuery.fn[o] = function(f){
 return this.bind(o, f);
 };
});

var jsc = now();

jQuery.extend({
 get: function( url, data, callback, type ) {
 // shift arguments if data argument was ommited
 if ( jQuery.isFunction( data ) ) {
 callback = data;
 data = null;
 }

 return jQuery.ajax({
 type: "GET",
 url: url,
 data: data,
 success: callback,
 dataType: type
 });
 },

 getScript: function( url, callback ) {
 return jQuery.get(url, null, callback, "script");
 },

 getJSON: function( url, data, callback ) {
 return jQuery.get(url, data, callback, "json");
 },

 post: function( url, data, callback, type ) {
 if ( jQuery.isFunction( data ) ) {
 callback = data;
 data = {};
 }

 return jQuery.ajax({
 type: "POST",
 url: url,
 data: data,
 success: callback,
 dataType: type
 });
 },

 ajaxSetup: function( settings ) {
 jQuery.extend( jQuery.ajaxSettings, settings );
 },

 ajaxSettings: {
 url: location.href,
 global: true,
 type: "GET",
 timeout: 0,
 contentType: "application/x-www-form-urlencoded",
 processData: true,
 async: true,
 data: null,
 username: null,
 password: null,
 accepts: {
 xml: "application/xml, text/xml",
 html: "text/html",
 script: "text/javascript, application/javascript",
 json: "application/json, text/javascript",
 text: "text/plain",
 _default: "*/*"
 }
 },

 // Last-Modified header cache for next request
 lastModified: {},

 ajax: function( s ) {
 // Extend the settings, but re-extend 's' so that it can be
 // checked again later (in the test suite, specifically)
 s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));

 var jsonp, jsre = /=\?(&|$)/g, status, data,
 type = s.type.toUpperCase();

 // convert data if not already a string
 if ( s.data && s.processData && typeof s.data != "string" )
 s.data = jQuery.param(s.data);

 // Handle JSONP Parameter Callbacks
 if ( s.dataType == "jsonp" ) {
 if ( type == "GET" ) {
 if ( !s.url.match(jsre) )
 s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
 } else if ( !s.data || !s.data.match(jsre) )
 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
 s.dataType = "json";
 }

 // Build temporary JSONP function
 if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
 jsonp = "jsonp" + jsc++;

 // Replace the =? sequence both in the query string and the data
 if ( s.data )
 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
 s.url = s.url.replace(jsre, "=" + jsonp + "$1");

 // We need to make sure
 // that a JSONP style response is executed properly
 s.dataType = "script";

 // Handle JSONP-style loading
 window[ jsonp ] = function(tmp){
 data = tmp;
 success();
 complete();
 // Garbage collect
 window[ jsonp ] = undefined;
 try{ delete window[ jsonp ]; } catch(e){}
 if ( head )
 head.removeChild( script );
 };
 }

 if ( s.dataType == "script" && s.cache == null )
 s.cache = false;

 if ( s.cache === false && type == "GET" ) {
 var ts = now();
 // try replacing _= if it is there
 var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
 // if nothing was replaced, add timestamp to the end
 s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
 }

 // If data is available, append data to url for get requests
 if ( s.data && type == "GET" ) {
 s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;

 // IE likes to send both get and post data, prevent this
 s.data = null;
 }

 // Watch for a new set of requests
 if ( s.global && ! jQuery.active++ )
 jQuery.event.trigger( "ajaxStart" );

 // Matches an absolute URL, and saves the domain
 var remote = /^(?:\w+:)?\/\/([^\/?#]+)/;

 // If we're requesting a remote document
 // and trying to load JSON or Script with a GET
 if ( s.dataType == "script" && type == "GET"
 && remote.test(s.url) && remote.exec(s.url)[1] != location.host ){
 var head = document.getElementsByTagName("head")[0];
 var script = document.createElement("script");
 script.src = s.url;
 if (s.scriptCharset)
 script.charset = s.scriptCharset;

 // Handle Script loading
 if ( !jsonp ) {
 var done = false;

 // Attach handlers for all browsers
 script.onload = script.onreadystatechange = function(){
 if ( !done && (!this.readyState ||
 this.readyState == "loaded" || this.readyState == "complete") ) {
 done = true;
 success();
 complete();
 head.removeChild( script );
 }
 };
 }

 head.appendChild(script);

 // We handle everything using the script element injection
 return undefined;
 }

 var requestDone = false;

 // Create the request object; Microsoft failed to properly
 // implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
 var xhr = window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();

 // Open the socket
 // Passing null username, generates a login popup on Opera (#2865)
 if( s.username )
 xhr.open(type, s.url, s.async, s.username, s.password);
 else
 xhr.open(type, s.url, s.async);

 // Need an extra try/catch for cross domain requests in Firefox 3
 try {
 // Set the correct header, if data is being sent
 if ( s.data )
 xhr.setRequestHeader("Content-Type", s.contentType);

 // Set the If-Modified-Since header, if ifModified mode.
 if ( s.ifModified )
 xhr.setRequestHeader("If-Modified-Since",
 jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );

 // Set header so the called script knows that it's an XMLHttpRequest
 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");

 // Set the Accepts header for the server, depending on the dataType
 xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
 s.accepts[ s.dataType ] + ", */*" :
 s.accepts._default );
 } catch(e){}

 // Allow custom headers/mimetypes
 if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
 // cleanup active request counter
 s.global && jQuery.active--;
 // close opended socket
 xhr.abort();
 return false;
 }

 if ( s.global )
 jQuery.event.trigger("ajaxSend", [xhr, s]);

 // Wait for a response to come back
 var onreadystatechange = function(isTimeout){
 // The transfer is complete and the data is available, or the request timed out
 if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
 requestDone = true;

 // clear poll interval
 if (ival) {
 clearInterval(ival);
 ival = null;
 }

 status = isTimeout == "timeout" && "timeout" ||
 !jQuery.httpSuccess( xhr ) && "error" ||
 s.ifModified && jQuery.httpNotModified( xhr, s.url ) && "notmodified" ||
 "success";

 if ( status == "success" ) {
 // Watch for, and catch, XML document parse errors
 try {
 // process the data (runs the xml through httpData regardless of callback)
 data = jQuery.httpData( xhr, s.dataType, s.dataFilter );
 } catch(e) {
 status = "parsererror";
 }
 }

 // Make sure that the request was successful or notmodified
 if ( status == "success" ) {
 // Cache Last-Modified header, if ifModified mode.
 var modRes;
 try {
 modRes = xhr.getResponseHeader("Last-Modified");
 } catch(e) {} // swallow exception thrown by FF if header is not available

 if ( s.ifModified && modRes )
 jQuery.lastModified[s.url] = modRes;

 // JSONP handles its own success callback
 if ( !jsonp )
 success();
 } else
 jQuery.handleError(s, xhr, status);

 // Fire the complete handlers
 complete();

 // Stop memory leaks
 if ( s.async )
 xhr = null;
 }
 };

 if ( s.async ) {
 // don't attach the handler to the request, just poll it instead
 var ival = setInterval(onreadystatechange, 13);

 // Timeout checker
 if ( s.timeout > 0 )
 setTimeout(function(){
 // Check to see if the request is still happening
 if ( xhr ) {
 // Cancel the request
 xhr.abort();

 if( !requestDone )
 onreadystatechange( "timeout" );
 }
 }, s.timeout);
 }

 // Send the data
 try {
 xhr.send(s.data);
 } catch(e) {
 jQuery.handleError(s, xhr, null, e);
 }

 // firefox 1.5 doesn't fire statechange for sync requests
 if ( !s.async )
 onreadystatechange();

 function success(){
 // If a local callback was specified, fire it and pass it the data
 if ( s.success )
 s.success( data, status );

 // Fire the global callback
 if ( s.global )
 jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
 }

 function complete(){
 // Process result
 if ( s.complete )
 s.complete(xhr, status);

 // The request was completed
 if ( s.global )
 jQuery.event.trigger( "ajaxComplete", [xhr, s] );

 // Handle the global AJAX counter
 if ( s.global && ! --jQuery.active )
 jQuery.event.trigger( "ajaxStop" );
 }

 // return XMLHttpRequest to allow aborting the request etc.
 return xhr;
 },

 handleError: function( s, xhr, status, e ) {
 // If a local callback was specified, fire it
 if ( s.error ) s.error( xhr, status, e );

 // Fire the global callback
 if ( s.global )
 jQuery.event.trigger( "ajaxError", [xhr, s, e] );
 },

 // Counter for holding the number of active queries
 active: 0,

 // Determines if an XMLHttpRequest was successful or not
 httpSuccess: function( xhr ) {
 try {
 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
 return !xhr.status && location.protocol == "file:" ||
 ( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223 ||
 jQuery.browser.safari && xhr.status == undefined;
 } catch(e){}
 return false;
 },

 // Determines if an XMLHttpRequest returns NotModified
 httpNotModified: function( xhr, url ) {
 try {
 var xhrRes = xhr.getResponseHeader("Last-Modified");

 // Firefox always returns 200. check Last-Modified date
 return xhr.status == 304 || xhrRes == jQuery.lastModified[url] ||
 jQuery.browser.safari && xhr.status == undefined;
 } catch(e){}
 return false;
 },

 httpData: function( xhr, type, filter ) {
 var ct = xhr.getResponseHeader("content-type"),
 xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
 data = xml ? xhr.responseXML : xhr.responseText;

 if ( xml && data.documentElement.tagName == "parsererror" )
 throw "parsererror";
 
 // Allow a pre-filtering function to sanitize the response
 if( filter )
 data = filter( data, type );

 // If the type is "script", eval it in global context
 if ( type == "script" )
 jQuery.globalEval( data );

 // Get the JavaScript object, if JSON is used.
 if ( type == "json" )
 data = eval("(" + data + ")");

 return data;
 },

 // Serialize an array of form elements or a set of
 // key/values into a query string
 param: function( a ) {
 var s = [];

 // If an array was passed in, assume that it is an array
 // of form elements
 if ( a.constructor == Array || a.jquery )
 // Serialize the form elements
 jQuery.each( a, function(){
 s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
 });

 // Otherwise, assume that it's an object of key/value pairs
 else
 // Serialize the key/values
 for ( var j in a )
 // If the value is an array then the key names need to be repeated
 if ( a[j] && a[j].constructor == Array )
 jQuery.each( a[j], function(){
 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( this ) );
 });
 else
 s.push( encodeURIComponent(j) + "=" + encodeURIComponent( jQuery.isFunction(a[j]) ? a[j]() : a[j] ) );

 // Return the resulting serialization
 return s.join("&").replace(/%20/g, "+");
 }

});
jQuery.fn.extend({
 show: function(speed,callback){
 return speed ?
 this.animate({
 height: "show", width: "show", opacity: "show"
 }, speed, callback) :

 this.filter(":hidden").each(function(){
 this.style.display = this.oldblock || "";
 if ( jQuery.css(this,"display") == "none" ) {
 var elem = jQuery("<" + this.tagName + " />").appendTo("body");
 this.style.display = elem.css("display");
 // handle an edge condition where css is - div { display:none; } or similar
 if (this.style.display == "none")
 this.style.display = "block";
 elem.remove();
 }
 }).end();
 },

 hide: function(speed,callback){
 return speed ?
 this.animate({
 height: "hide", width: "hide", opacity: "hide"
 }, speed, callback) :

 this.filter(":visible").each(function(){
 this.oldblock = this.oldblock || jQuery.css(this,"display");
 this.style.display = "none";
 }).end();
 },

 // Save the old toggle function
 _toggle: jQuery.fn.toggle,

 toggle: function( fn, fn2 ){
 return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
 this._toggle.apply( this, arguments ) :
 fn ?
 this.animate({
 height: "toggle", width: "toggle", opacity: "toggle"
 }, fn, fn2) :
 this.each(function(){
 jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
 });
 },

 slideDown: function(speed,callback){
 return this.animate({height: "show"}, speed, callback);
 },

 slideUp: function(speed,callback){
 return this.animate({height: "hide"}, speed, callback);
 },

 slideToggle: function(speed, callback){
 return this.animate({height: "toggle"}, speed, callback);
 },

 fadeIn: function(speed, callback){
 return this.animate({opacity: "show"}, speed, callback);
 },

 fadeOut: function(speed, callback){
 return this.animate({opacity: "hide"}, speed, callback);
 },

 fadeTo: function(speed,to,callback){
 return this.animate({opacity: to}, speed, callback);
 },

 animate: function( prop, speed, easing, callback ) {
 var optall = jQuery.speed(speed, easing, callback);

 return this[ optall.queue === false ? "each" : "queue" ](function(){
 if ( this.nodeType != 1)
 return false;

 var opt = jQuery.extend({}, optall), p,
 hidden = jQuery(this).is(":hidden"), self = this;

 for ( p in prop ) {
 if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
 return opt.complete.call(this);

 if ( p == "height" || p == "width" ) {
 // Store display property
 opt.display = jQuery.css(this, "display");

 // Make sure that nothing sneaks out
 opt.overflow = this.style.overflow;
 }
 }

 if ( opt.overflow != null )
 this.style.overflow = "hidden";

 opt.curAnim = jQuery.extend({}, prop);

 jQuery.each( prop, function(name, val){
 var e = new jQuery.fx( self, opt, name );

 if ( /toggle|show|hide/.test(val) )
 e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
 else {
 var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
 start = e.cur(true) || 0;

 if ( parts ) {
 var end = parseFloat(parts[2]),
 unit = parts[3] || "px";

 // We need to compute starting value
 if ( unit != "px" ) {
 self.style[ name ] = (end || 1) + unit;
 start = ((end || 1) / e.cur(true)) * start;
 self.style[ name ] = start + unit;
 }

 // If a +=/-= token was provided, we're doing a relative animation
 if ( parts[1] )
 end = ((parts[1] == "-=" ? -1 : 1) * end) + start;

 e.custom( start, end, unit );
 } else
 e.custom( start, val, "" );
 }
 });

 // For JS strict compliance
 return true;
 });
 },

 queue: function(type, fn){
 if ( jQuery.isFunction(type) || ( type && type.constructor == Array )) {
 fn = type;
 type = "fx";
 }

 if ( !type || (typeof type == "string" && !fn) )
 return queue( this[0], type );

 return this.each(function(){
 if ( fn.constructor == Array )
 queue(this, type, fn);
 else {
 queue(this, type).push( fn );

 if ( queue(this, type).length == 1 )
 fn.call(this);
 }
 });
 },

 stop: function(clearQueue, gotoEnd){
 var timers = jQuery.timers;

 if (clearQueue)
 this.queue([]);

 this.each(function(){
 // go in reverse order so anything added to the queue during the loop is ignored
 for ( var i = timers.length - 1; i >= 0; i-- )
 if ( timers[i].elem == this ) {
 if (gotoEnd)
 // force the next step to be the last
 timers[i](true);
 timers.splice(i, 1);
 }
 });

 // start the next in the queue if the last step wasn't forced
 if (!gotoEnd)
 this.dequeue();

 return this;
 }

});

var queue = function( elem, type, array ) {
 if ( elem ){

 type = type || "fx";

 var q = jQuery.data( elem, type + "queue" );

 if ( !q || array )
 q = jQuery.data( elem, type + "queue", jQuery.makeArray(array) );

 }
 return q;
};

jQuery.fn.dequeue = function(type){
 type = type || "fx";

 return this.each(function(){
 var q = queue(this, type);

 q.shift();

 if ( q.length )
 q[0].call( this );
 });
};

jQuery.extend({

 speed: function(speed, easing, fn) {
 var opt = speed && speed.constructor == Object ? speed : {
 complete: fn || !fn && easing ||
 jQuery.isFunction( speed ) && speed,
 duration: speed,
 easing: fn && easing || easing && easing.constructor != Function && easing
 };

 opt.duration = (opt.duration && opt.duration.constructor == Number ?
 opt.duration :
 jQuery.fx.speeds[opt.duration]) || jQuery.fx.speeds.def;

 // Queueing
 opt.old = opt.complete;
 opt.complete = function(){
 if ( opt.queue !== false )
 jQuery(this).dequeue();
 if ( jQuery.isFunction( opt.old ) )
 opt.old.call( this );
 };

 return opt;
 },

 easing: {
 linear: function( p, n, firstNum, diff ) {
 return firstNum + diff * p;
 },
 swing: function( p, n, firstNum, diff ) {
 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
 }
 },

 timers: [],
 timerId: null,

 fx: function( elem, options, prop ){
 this.options = options;
 this.elem = elem;
 this.prop = prop;

 if ( !options.orig )
 options.orig = {};
 }

});

jQuery.fx.prototype = {

 // Simple function for setting a style value
 update: function(){
 if ( this.options.step )
 this.options.step.call( this.elem, this.now, this );

 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );

 // Set display property to block for height/width animations
 if ( this.prop == "height" || this.prop == "width" )
 this.elem.style.display = "block";
 },

 // Get the current size
 cur: function(force){
 if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
 return this.elem[ this.prop ];

 var r = parseFloat(jQuery.css(this.elem, this.prop, force));
 return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
 },

 // Start an animation from one number to another
 custom: function(from, to, unit){
 this.startTime = now();
 this.start = from;
 this.end = to;
 this.unit = unit || this.unit || "px";
 this.now = this.start;
 this.pos = this.state = 0;
 this.update();

 var self = this;
 function t(gotoEnd){
 return self.step(gotoEnd);
 }

 t.elem = this.elem;

 jQuery.timers.push(t);

 if ( jQuery.timerId == null ) {
 jQuery.timerId = setInterval(function(){
 var timers = jQuery.timers;

 for ( var i = 0; i < timers.length; i++ )
 if ( !timers[i]() )
 timers.splice(i--, 1);

 if ( !timers.length ) {
 clearInterval( jQuery.timerId );
 jQuery.timerId = null;
 }
 }, 13);
 }
 },

 // Simple 'show' function
 show: function(){
 // Remember where we started, so that we can go back to it later
 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
 this.options.show = true;

 // Begin the animation
 this.custom(0, this.cur());

 // Make sure that we start at a small width/height to avoid any
 // flash of content
 if ( this.prop == "width" || this.prop == "height" )
 this.elem.style[this.prop] = "1px";

 // Start by showing the element
 jQuery(this.elem).show();
 },

 // Simple 'hide' function
 hide: function(){
 // Remember where we started, so that we can go back to it later
 this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
 this.options.hide = true;

 // Begin the animation
 this.custom(this.cur(), 0);
 },

 // Each step of an animation
 step: function(gotoEnd){
 var t = now();

 if ( gotoEnd || t > this.options.duration + this.startTime ) {
 this.now = this.end;
 this.pos = this.state = 1;
 this.update();

 this.options.curAnim[ this.prop ] = true;

 var done = true;
 for ( var i in this.options.curAnim )
 if ( this.options.curAnim[i] !== true )
 done = false;

 if ( done ) {
 if ( this.options.display != null ) {
 // Reset the overflow
 this.elem.style.overflow = this.options.overflow;

 // Reset the display
 this.elem.style.display = this.options.display;
 if ( jQuery.css(this.elem, "display") == "none" )
 this.elem.style.display = "block";
 }

 // Hide the element if the "hide" operation was done
 if ( this.options.hide )
 this.elem.style.display = "none";

 // Reset the properties, if the item has been hidden or shown
 if ( this.options.hide || this.options.show )
 for ( var p in this.options.curAnim )
 jQuery.attr(this.elem.style, p, this.options.orig[p]);
 }

 if ( done )
 // Execute the complete function
 this.options.complete.call( this.elem );

 return false;
 } else {
 var n = t - this.startTime;
 this.state = n / this.options.duration;

 // Perform the easing function, defaults to swing
 this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
 this.now = this.start + ((this.end - this.start) * this.pos);

 // Perform the next step of the animation
 this.update();
 }

 return true;
 }

};

jQuery.extend( jQuery.fx, {
 speeds:{
 slow: 600,
 fast: 200,
 // Default speed
 def: 400
 },
 step: {
 scrollLeft: function(fx){
 fx.elem.scrollLeft = fx.now;
 },

 scrollTop: function(fx){
 fx.elem.scrollTop = fx.now;
 },

 opacity: function(fx){
 jQuery.attr(fx.elem.style, "opacity", fx.now);
 },

 _default: function(fx){
 fx.elem.style[ fx.prop ] = fx.now + fx.unit;
 }
 }
});
// The Offset Method
// Originally By Brandon Aaron, part of the Dimension Plugin
// http://jquery.com/plugins/project/dimensions
jQuery.fn.offset = function() {
 var left = 0, top = 0, elem = this[0], results;

 if ( elem ) with ( jQuery.browser ) {
 var parent = elem.parentNode,
 offsetChild = elem,
 offsetParent = elem.offsetParent,
 doc = elem.ownerDocument,
 safari2 = safari && parseInt(version) < 522 && !/adobeair/i.test(userAgent),
 css = jQuery.curCSS,
 fixed = css(elem, "position") == "fixed";

 // Use getBoundingClientRect if available
 if ( elem.getBoundingClientRect ) {
 var box = elem.getBoundingClientRect();

 // Add the document scroll offsets
 add(box.left + Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
 box.top + Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));

 // IE adds the HTML element's border, by default it is medium which is 2px
 // IE 6 and 7 quirks mode the border width is overwritable by the following css html { border: 0; }
 // IE 7 standards mode, the border is always 2px
 // This border/offset is typically represented by the clientLeft and clientTop properties
 // However, in IE6 and 7 quirks mode the clientLeft and clientTop properties are not updated when overwriting it via CSS
 // Therefore this method will be off by 2px in IE while in quirksmode
 add( -doc.documentElement.clientLeft, -doc.documentElement.clientTop );

 // Otherwise loop through the offsetParents and parentNodes
 } else {

 // Initial element offsets
 add( elem.offsetLeft, elem.offsetTop );

 // Get parent offsets
 while ( offsetParent ) {
 // Add offsetParent offsets
 add( offsetParent.offsetLeft, offsetParent.offsetTop );

 // Mozilla and Safari > 2 does not include the border on offset parents
 // However Mozilla adds the border for table or table cells
 if ( mozilla && !/^t(able|d|h)$/i.test(offsetParent.tagName) || safari && !safari2 )
 border( offsetParent );

 // Add the document scroll offsets if position is fixed on any offsetParent
 if ( !fixed && css(offsetParent, "position") == "fixed" )
 fixed = true;

 // Set offsetChild to previous offsetParent unless it is the body element
 offsetChild = /^body$/i.test(offsetParent.tagName) ? offsetChild : offsetParent;
 // Get next offsetParent
 offsetParent = offsetParent.offsetParent;
 }

 // Get parent scroll offsets
 while ( parent && parent.tagName && !/^body|html$/i.test(parent.tagName) ) {
 // Remove parent scroll UNLESS that parent is inline or a table to work around Opera inline/table scrollLeft/Top bug
 if ( !/^inline|table.*$/i.test(css(parent, "display")) )
 // Subtract parent scroll offsets
 add( -parent.scrollLeft, -parent.scrollTop );

 // Mozilla does not add the border for a parent that has overflow != visible
 if ( mozilla && css(parent, "overflow") != "visible" )
 border( parent );

 // Get next parent
 parent = parent.parentNode;
 }

 // Safari <= 2 doubles body offsets with a fixed position element/offsetParent or absolutely positioned offsetChild
 // Mozilla doubles body offsets with a non-absolutely positioned offsetChild
 if ( (safari2 && (fixed || css(offsetChild, "position") == "absolute")) ||
 (mozilla && css(offsetChild, "position") != "absolute") )
 add( -doc.body.offsetLeft, -doc.body.offsetTop );

 // Add the document scroll offsets if position is fixed
 if ( fixed )
 add(Math.max(doc.documentElement.scrollLeft, doc.body.scrollLeft),
 Math.max(doc.documentElement.scrollTop, doc.body.scrollTop));
 }

 // Return an object with top and left properties
 results = { top: top, left: left };
 }

 function border(elem) {
 add( jQuery.curCSS(elem, "borderLeftWidth", true), jQuery.curCSS(elem, "borderTopWidth", true) );
 }

 function add(l, t) {
 left += parseInt(l, 10) || 0;
 top += parseInt(t, 10) || 0;
 }

 return results;
};


jQuery.fn.extend({
 position: function() {
 var left = 0, top = 0, results;

 if ( this[0] ) {
 // Get *real* offsetParent
 var offsetParent = this.offsetParent(),

 // Get correct offsets
 offset = this.offset(),
 parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();

 // Subtract element margins
 // note: when an element has margin: auto the offsetLeft and marginLeft 
 // are the same in Safari causing offset.left to incorrectly be 0
 offset.top -= num( this, 'marginTop' );
 offset.left -= num( this, 'marginLeft' );

 // Add offsetParent borders
 parentOffset.top += num( offsetParent, 'borderTopWidth' );
 parentOffset.left += num( offsetParent, 'borderLeftWidth' );

 // Subtract the two offsets
 results = {
 top: offset.top - parentOffset.top,
 left: offset.left - parentOffset.left
 };
 }

 return results;
 },

 offsetParent: function() {
 var offsetParent = this[0].offsetParent;
 while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
 offsetParent = offsetParent.offsetParent;
 return jQuery(offsetParent);
 }
});


// Create scrollLeft and scrollTop methods
jQuery.each( ['Left', 'Top'], function(i, name) {
 var method = 'scroll' + name;
 
 jQuery.fn[ method ] = function(val) {
 if (!this[0]) return;

 return val != undefined ?

 // Set the scroll offset
 this.each(function() {
 this == window || this == document ?
 window.scrollTo(
 !i ? val : jQuery(window).scrollLeft(),
 i ? val : jQuery(window).scrollTop()
 ) :
 this[ method ] = val;
 }) :

 // Return the scroll offset
 this[0] == window || this[0] == document ?
 self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
 jQuery.boxModel && document.documentElement[ method ] ||
 document.body[ method ] :
 this[0][ method ];
 };
});
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
jQuery.each([ "Height", "Width" ], function(i, name){

 var tl = i ? "Left" : "Top", // top or left
 br = i ? "Right" : "Bottom"; // bottom or right

 // innerHeight and innerWidth
 jQuery.fn["inner" + name] = function(){
 return this[ name.toLowerCase() ]() +
 num(this, "padding" + tl) +
 num(this, "padding" + br);
 };

 // outerHeight and outerWidth
 jQuery.fn["outer" + name] = function(margin) {
 return this["inner" + name]() +
 num(this, "border" + tl + "Width") +
 num(this, "border" + br + "Width") +
 (margin ?
 num(this, "margin" + tl) + num(this, "margin" + br) : 0);
 };

});})();

$j = jQuery.noConflict();/**
 * SWFObject v1.5: Flash Player detection and embed - http://blog.deconcept.com/swfobject/
 *
 * SWFObject is (c) 2007 Geoff Stearns and is released under the MIT License:
 * http://www.opensource.org/licenses/mit-license.php
 *
 */
if(typeof deconcept=="undefined"){var deconcept=new Object();}if(typeof deconcept.util=="undefined"){deconcept.util=new Object();}if(typeof deconcept.SWFObjectUtil=="undefined"){deconcept.SWFObjectUtil=new Object();}deconcept.SWFObject=function(_1,id,w,h,_5,c,_7,_8,_9,_a){if(!document.getElementById){return;}this.DETECT_KEY=_a?_a:"detectflash";this.skipDetect=deconcept.util.getRequestParameter(this.DETECT_KEY);this.params=new Object();this.variables=new Object();this.attributes=new Array();if(_1){this.setAttribute("swf",_1);}if(id){this.setAttribute("id",id);}if(w){this.setAttribute("width",w);}if(h){this.setAttribute("height",h);}if(_5){this.setAttribute("version",new deconcept.PlayerVersion(_5.toString().split(".")));}this.installedVer=deconcept.SWFObjectUtil.getPlayerVersion();if(!window.opera&&document.all&&this.installedVer.major>7){deconcept.SWFObject.doPrepUnload=true;}if(c){this.addParam("bgcolor",c);}var q=_7?_7:"high";this.addParam("quality",q);this.setAttribute("useExpressInstall",false);this.setAttribute("doExpressInstall",false);var _c=(_8)?_8:window.location;this.setAttribute("xiRedirectUrl",_c);this.setAttribute("redirectUrl","");if(_9){this.setAttribute("redirectUrl",_9);}};deconcept.SWFObject.prototype={useExpressInstall:function(_d){this.xiSWFPath=!_d?"expressinstall.swf":_d;this.setAttribute("useExpressInstall",true);},setAttribute:function(_e,_f){this.attributes[_e]=_f;},getAttribute:function(_10){return this.attributes[_10];},addParam:function(_11,_12){this.params[_11]=_12;},getParams:function(){return this.params;},addVariable:function(_13,_14){this.variables[_13]=_14;},getVariable:function(_15){return this.variables[_15];},getVariables:function(){return this.variables;},getVariablePairs:function(){var _16=new Array();var key;var _18=this.getVariables();for(key in _18){_16[_16.length]=key+"="+_18[key];}return _16;},getSWFHTML:function(){var _19="";if(navigator.plugins&&navigator.mimeTypes&&navigator.mimeTypes.length){if(this.getAttribute("doExpressInstall")){this.addVariable("MMplayerType","PlugIn");this.setAttribute("swf",this.xiSWFPath);}_19="<embed type=\"application/x-shockwave-flash\" src=\""+this.getAttribute("swf")+"\" width=\""+this.getAttribute("width")+"\" height=\""+this.getAttribute("height")+"\" style=\""+this.getAttribute("style")+"\"";_19+=" id=\""+this.getAttribute("id")+"\" name=\""+this.getAttribute("id")+"\" ";var _1a=this.getParams();for(var key in _1a){_19+=[key]+"=\""+_1a[key]+"\" ";}var _1c=this.getVariablePairs().join("&");if(_1c.length>0){_19+="flashvars=\""+_1c+"\"";}_19+="/>";}else{if(this.getAttribute("doExpressInstall")){this.addVariable("MMplayerType","ActiveX");this.setAttribute("swf",this.xiSWFPath);}_19="<object id=\""+this.getAttribute("id")+"\" classid=\"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\" width=\""+this.getAttribute("width")+"\" height=\""+this.getAttribute("height")+"\" style=\""+this.getAttribute("style")+"\">";_19+="<param name=\"movie\" value=\""+this.getAttribute("swf")+"\" />";var _1d=this.getParams();for(var key in _1d){_19+="<param name=\""+key+"\" value=\""+_1d[key]+"\" />";}var _1f=this.getVariablePairs().join("&");if(_1f.length>0){_19+="<param name=\"flashvars\" value=\""+_1f+"\" />";}_19+="</object>";}return _19;},write:function(_20){if(this.getAttribute("useExpressInstall")){var _21=new deconcept.PlayerVersion([6,0,65]);if(this.installedVer.versionIsValid(_21)&&!this.installedVer.versionIsValid(this.getAttribute("version"))){this.setAttribute("doExpressInstall",true);this.addVariable("MMredirectURL",escape(this.getAttribute("xiRedirectUrl")));document.title=document.title.slice(0,47)+" - Flash Player Installation";this.addVariable("MMdoctitle",document.title);}}if(this.skipDetect||this.getAttribute("doExpressInstall")||this.installedVer.versionIsValid(this.getAttribute("version"))){var n=(typeof _20=="string")?document.getElementById(_20):_20;n.innerHTML=this.getSWFHTML();return true;}else{if(this.getAttribute("redirectUrl")!=""){document.location.replace(this.getAttribute("redirectUrl"));}}return false;}};deconcept.SWFObjectUtil.getPlayerVersion=function(){var _23=new deconcept.PlayerVersion([0,0,0]);if(navigator.plugins&&navigator.mimeTypes.length){var x=navigator.plugins["Shockwave Flash"];if(x&&x.description){_23=new deconcept.PlayerVersion(x.description.replace(/([a-zA-Z]|\s)+/,"").replace(/(\s+r|\s+b[0-9]+)/,".").split("."));}}else{if(navigator.userAgent&&navigator.userAgent.indexOf("Windows CE")>=0){var axo=1;var _26=3;while(axo){try{_26++;axo=new ActiveXObject("ShockwaveFlash.ShockwaveFlash."+_26);_23=new deconcept.PlayerVersion([_26,0,0]);}catch(e){axo=null;}}}else{try{var axo=new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");}catch(e){try{var axo=new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");_23=new deconcept.PlayerVersion([6,0,21]);axo.AllowScriptAccess="always";}catch(e){if(_23.major==6){return _23;}}try{axo=new ActiveXObject("ShockwaveFlash.ShockwaveFlash");}catch(e){}}if(axo!=null){_23=new deconcept.PlayerVersion(axo.GetVariable("$version").split(" ")[1].split(","));}}}return _23;};deconcept.PlayerVersion=function(_29){this.major=_29[0]!=null?parseInt(_29[0]):0;this.minor=_29[1]!=null?parseInt(_29[1]):0;this.rev=_29[2]!=null?parseInt(_29[2]):0;};deconcept.PlayerVersion.prototype.versionIsValid=function(fv){if(this.major<fv.major){return false;}if(this.major>fv.major){return true;}if(this.minor<fv.minor){return false;}if(this.minor>fv.minor){return true;}if(this.rev<fv.rev){return false;}return true;};deconcept.util={getRequestParameter:function(_2b){var q=document.location.search||document.location.hash;if(_2b==null){return q;}if(q){var _2d=q.substring(1).split("&");for(var i=0;i<_2d.length;i++){if(_2d[i].substring(0,_2d[i].indexOf("="))==_2b){return _2d[i].substring((_2d[i].indexOf("=")+1));}}}return "";}};deconcept.SWFObjectUtil.cleanupSWFs=function(){var _2f=document.getElementsByTagName("OBJECT");for(var i=_2f.length-1;i>=0;i--){_2f[i].style.display="none";for(var x in _2f[i]){if(typeof _2f[i][x]=="function"){_2f[i][x]=function(){};}}}};if(deconcept.SWFObject.doPrepUnload){if(!deconcept.unloadSet){deconcept.SWFObjectUtil.prepUnload=function(){__flash_unloadHandler=function(){};__flash_savedUnloadHandler=function(){};window.attachEvent("onunload",deconcept.SWFObjectUtil.cleanupSWFs);};window.attachEvent("onbeforeunload",deconcept.SWFObjectUtil.prepUnload);deconcept.unloadSet=true;}}if(!document.getElementById&&document.all){document.getElementById=function(id){return document.all[id];};}var getQueryParamValue=deconcept.util.getRequestParameter;var FlashObject=deconcept.SWFObject;var SWFObject=deconcept.SWFObject;/*

what needs to happen?

user clicks the image
user sees loading icon
image loads
loading icon removed
big image is shown


on click... create new image, attach a callback when image is loaded
show a loading icon


 
 // create the javascript image
 // create an image object
 objImage = new Image();
 
 // set what happens once the image has loaded 
 objImage.onLoad=imagesLoaded();
 
 
 
 // preload the image file
 objImage.src= bigimage;
 
 // end the function here
 
 
 
function imagesLoade 
 
 
on the callback
remove the loading icon
show the image

*/

 var _global_this;
 var _global_bigimage;
 var _global_settings;
 var _global_event;

(function($j){
 var _hovering = false;
 var _zooming = false;

 
 $j.fn.jqueryzoom = function(options){

 var settings = 
 {
 xzoom: 200, //zoomed width default width
 yzoom: 200, //zoomed div default width
 offset: 0, //zoomed div default offset
 position: "right" ,//zoomed div default position,offset position is to the right of the image
 lens:1, //zooming lens over the image,by default is 1;
 showPreload: true,
 fadeIn: 300,
 fadeOut: 500
 };

 if(options)
 {
 $j.extend(settings, options);
 }
 
 _global_settings = settings;
 
 function show_notice()
 {
 if(_hovering == false && _zooming == false)
 {
 _hovering = true;
 $j(".jqzoom #rollovertozoom").fadeIn(100);
 }
 }
 
 function hide_notice(time)
 {
 if(_hovering == true)
 {
 $j(".jqzoom #rollovertozoom").fadeOut(time, function(){ _hovering=false; } );
 }
 }
 
 $j(".jqzoom").prepend('<div id="rollovertozoom" />');
 $j(".jqzoom #rollovertozoom").animate({opacity:1}, 5000, function(){$j(this).fadeOut(1000);});
 
 var noalt='';
 
 $j('.jqzoom').bind('mouseover', function() { show_notice(); });
 $j('.jqzoom').bind('mouseout', function() { hide_notice(); } );

 _zooming = false;
 
 
 // _zooming = true;
 

 
 
 // On hover
 $j(this).mousedown(function(e)
 {
 if(_zooming)
 {
 // Hide the notice instantly
 hide_notice(1); 
 return;
 }
 
 // We are loading the image
 //$j('#info h1').html('loading....');
 $j('#loadingbigimage').css('display', 'block') 
 
 // Determine the name of the large image
 var bigimage = $j(this).children('img').attr('src');
 
 // Last section stylecode-colorcode-1-6.jpg
 bigimage = bigimage.replace(/^.*[\/\\]/g, '');

 // Correct location is /m/1/m1200-100.jpg
 bigimage = '/media/catalog/product/'+bigimage.substr(0,1)+'/'+bigimage.substr(1,1)+'/'+bigimage;

 _global_this =this;
 _global_bigimage = bigimage;
 _global_event = e;

 // create an image object
 objImage = new Image();
 objImage.src= bigimage;
 
 // set what happens once the image has loaded 
 objImage.onload = imagesLoaded;
 

 

 });

 count = 0;

 if(settings.preload)
 {
 $j('body').append("<div style='display:none;' class='jqPreload"+count+"'>&nbsp;</div>");

 $j(this).each(function()
 {
 var imagetopreload= $j(this).children("img").attr("jqimg");
 var content = jQuery('div.jqPreload'+count+'').html();
 jQuery('div.jqPreload'+count+'').html(content+'<img src=\"'+imagetopreload+'\">');

 });
 }
}

})(jQuery);

function MouseEvent(e)
{
 this.x = e.pageX;
 this.y = e.pageY;
}



//george's rubbish functions
function imagesLoaded()
{
 image = _global_this;
 bigimage = _global_bigimage;
 settings = _global_settings;
 e = _global_event;
 
 //center the stuff here...
 mouse = new MouseEvent(e);
 
 //$j('#info h1').html('loaded.');
 $j('#loadingbigimage').css('display', 'none')
 
 // preload the image file
 
 // find an event that is called when the image fully loaded
 // do the rest of the config in another function

 
 $j(image).children("img").attr("alt",'');

 if($j("div.zoomdiv").get().length == 0)
 {
 $j(image).after("<div class='zoomdiv'><img class='bigimg' src='"+bigimage+"'/></div>");
 
 $j('div.zoomdiv').fadeIn(settings.fadeIn);
 $j(image).append("<div class='jqZoomPup'>&nbsp;</div>");
 $j('div.jqZoomPup').fadeIn(settings.fadeIn);
 
 }
 
 var imageLeft = $j(image).offset().left;
 var imageTop = $j(image).offset().top;
 
 var imageWidth = $j(image).children('img').get(0).offsetWidth;
 var imageHeight = $j(image).children('img').get(0).offsetHeight;

 noalt= $j(image).children("img").attr("alt");
 
 if(settings.position == "right")
 {
 if(imageLeft + imageWidth + settings.offset + settings.xzoom > screen.width)
 {
 leftpos = imageLeft- settings.offset - settings.xzoom;
 }
 else
 {
 leftpos = imageLeft + imageWidth + settings.offset;
 }
 }
 else
 {
 leftpos = imageLeft - settings.xzoom - settings.offset;
 
 if(leftpos < 0)
 {
 leftpos = imageLeft + imageWidth+ settings.offset;
 }
 }

 $j("div.zoomdiv").css({ top: imageTop+1,left: leftpos });
 $j("div.zoomdiv").width(settings.xzoom);
 $j("div.zoomdiv").height(settings.yzoom);
 
 if( !settings.lens )
 {
 $j(image).css('cursor','crosshair');
 }
 
 
 
 //center the stuff here...
 //mouse = new MouseEvent(e);
 
 var bigwidth = $j(".bigimg").get(0).offsetWidth;
 var bigheight = $j(".bigimg").get(0).offsetHeight;
 var scaley ='x';
 var scalex= 'y';
 
 if(isNaN(scalex)|isNaN(scaley))
 {
 var scalex = (bigwidth/imageWidth);
 var scaley = (bigheight/imageHeight);
 
 $j("div.jqZoomPup").width((settings.xzoom)/scalex );
 $j("div.jqZoomPup").height((settings.yzoom)/scaley);
 
 if(settings.lens)
 {
 $j("div.jqZoomPup").css('visibility','visible');
 }
 }
 
 xpos = mouse.x - $j("div.jqZoomPup").width()/2 - imageLeft;
 ypos = mouse.y - $j("div.jqZoomPup").height()/2 - imageTop ;
 
 xpos = mouse.x - $j("div.jqZoomPup").width()/2 - imageLeft;
 ypos = mouse.y - $j("div.jqZoomPup").height()/2 - imageTop;
 
 if(settings.lens)
 {
 xpos = (mouse.x - $j("div.jqZoomPup").width()/2 < imageLeft ) ? 0 : (mouse.x + $j("div.jqZoomPup").width()/2 > imageWidth + imageLeft ) ?(imageWidth -$j("div.jqZoomPup").width() -2): xpos;
 ypos = (mouse.y - $j("div.jqZoomPup").height()/2 < imageTop ) ? 0 : (mouse.y + $j("div.jqZoomPup").height()/2> imageHeight + imageTop ) ?(imageHeight - $j("div.jqZoomPup").height() -2 ) : ypos;
 }
 
 if(settings.lens)
 {
 $j("div.jqZoomPup").css({ top: ypos,left: xpos });
 }
 
 scrolly = ypos;
 $j("div.zoomdiv").get(0).scrollTop = scrolly * scaley;
 scrollx = xpos; 
 $j("div.zoomdiv").get(0).scrollLeft = (scrollx) * scalex;
 
 
//==============

 

//===============
 
 $j(document.body).mousemove(function(e)
 {
 mouse = new MouseEvent(e);

 var bigwidth = $j(".bigimg").get(0).offsetWidth;
 var bigheight = $j(".bigimg").get(0).offsetHeight;
 var scaley ='x';
 var scalex= 'y';

 
 if(isNaN(scalex)|isNaN(scaley))
 {
 var scalex = (bigwidth/imageWidth);
 var scaley = (bigheight/imageHeight);
 
 $j("div.jqZoomPup").width((settings.xzoom)/scalex );
 $j("div.jqZoomPup").height((settings.yzoom)/scaley);
 
 if(settings.lens)
 {
 $j("div.jqZoomPup").css('visibility','visible');
 $j("div.jqZoomPup").css('filter','alpha(Opacity=69)');
 }
 }
 
 xpos = mouse.x - $j("div.jqZoomPup").width()/2 - imageLeft;
 ypos = mouse.y - $j("div.jqZoomPup").height()/2 - imageTop ;
 
 xpos = mouse.x - $j("div.jqZoomPup").width()/2 - imageLeft;
 ypos = mouse.y - $j("div.jqZoomPup").height()/2 - imageTop;
 
 if(settings.lens)
 {
 xpos = (mouse.x - $j("div.jqZoomPup").width()/2 < imageLeft ) ? 0 : (mouse.x + $j("div.jqZoomPup").width()/2 > imageWidth + imageLeft ) ?(imageWidth -$j("div.jqZoomPup").width() -2): xpos;
 ypos = (mouse.y - $j("div.jqZoomPup").height()/2 < imageTop ) ? 0 : (mouse.y + $j("div.jqZoomPup").height()/2> imageHeight + imageTop ) ?(imageHeight - $j("div.jqZoomPup").height() -2 ) : ypos;
 }
 
 if(settings.lens)
 {
 $j("div.jqZoomPup").css({ top: ypos,left: xpos });
 }
 
 if( $j.browser.version == '6.0' )
 {
 //IE 6 to hide select box
 $j('#product-options-wrapper select').css('display', 'none')
 }
 
 scrolly = ypos;
 $j("div.zoomdiv").get(0).scrollTop = scrolly * scaley;
 scrollx = xpos; 
 $j("div.zoomdiv").get(0).scrollLeft = (scrollx) * scalex;
 
 //unbid if continual clicking
 $j(document.body).click(function(e)
 {
 $j(document.body).unbind("mousemove"); 
 });
 
 });
 
 $j(image).bind("mouseleave",function()
 {
 $j(this).children("img").attr("alt",noalt);
 $j(document.body).unbind("mousemove");
 
 if(settings.lens)
 {
 $j("div.jqZoomPup").fadeOut(settings.fadeOut, function ()
 {
 $j(this).remove();
 });
 }
 
 if( $j.browser.version == '6.0' )
 {
 //IE 6
 $j('#product-options-wrapper select').css('display', 'block')
 } 
 
 $j('div.zoomdiv').fadeOut(settings.fadeOut, function ()
 {
 _zooming = false;
 $j(this).remove();
 });
 });
}
 
 /*
 * jQuery Cycle Plugin (with Transition Definitions)
 * Examples and documentation at: http://malsup.com/jquery/cycle/
 * Copyright (c) 2007-2008 M. Alsup
 * Version: 2.30 (02-NOV-2008)
 * Dual licensed under the MIT and GPL licenses:
 * http://www.opensource.org/licenses/mit-license.php
 * http://www.gnu.org/licenses/gpl.html
 */
;eval(function(p,a,c,k,e,r){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--)r[e(c)]=k[c]||e(c);k=[function(e){return r[e]}];e=function(){return'\\w+'};c=1};while(c--)if(k[c])p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c]);return p}(';(4($j){8 q=\'2.30\';8 r=$j.25.26&&/37 6.0/.1u(38.39);4 1n(){7(27.28&&27.28.1n)27.28.1n(\'[B] \'+3a.3b.3c.3d(2x,\'\'))};$j.E.B=4(n){8 o=2x[1];O x.1s(4(){7(n===3e||n===P)n={};7(n.29==2y){3f(n){2a\'3g\':7(x.S)1v(x.S);x.S=0;$j(x).1F(\'B.1M\',\'\');O;2a\'2b\':x.1g=1;O;2a\'2z\':x.1g=0;7(o===2c){n=$j(x).1F(\'B.1M\');7(!n){1n(\'2A 1o 2B, 2C 1o 2z\');O}7(x.S){1v(x.S);x.S=0}1j(n.1N,n,1,1)}O;3h:n={1p:n}}}Q 7(n.29==3i){8 d=n;n=$j(x).1F(\'B.1M\');7(!n){1n(\'2A 1o 2B, 2C 1o 1O 2D\');O}7(d<0||d>=n.1N.L){1n(\'3j 2D 1G: \'+d);O}n.N=d;7(x.S){1v(x.S);x.S=0}1j(n.1N,n,1,d>=n.1b);O}7(x.S)1v(x.S);x.S=0;x.1g=0;8 e=$j(x);8 f=n.2d?$j(n.2d,x):e.3k();8 g=f.3l();7(g.L<2){1n(\'3m; 3n 3o 3p: \'+g.L);O}8 h=$j.3q({},$j.E.B.2E,n||{},$j.2F?e.2F():$j.3r?e.1F():{});7(h.2e)h.2f=h.2g||g.L;e.1F(\'B.1M\',h);h.1w=x;h.1N=g;h.H=h.H?[h.H]:[];h.1k=h.1k?[h.1k]:[];h.1k.1P(4(){h.2h=0});7(h.1x)h.1k.J(4(){1j(g,h,0,!h.1y)});7(r&&h.1Q&&!h.2G)2i(f);8 j=x.3s;h.D=T((j.1H(/w:(\\d+)/)||[])[1])||h.D;h.C=T((j.1H(/h:(\\d+)/)||[])[1])||h.C;h.W=T((j.1H(/t:(\\d+)/)||[])[1])||h.W;7(e.u(\'1R\')==\'3t\')e.u(\'1R\',\'3u\');7(h.D)e.D(h.D);7(h.C&&h.C!=\'1S\')e.C(h.C);7(h.18)h.18=T(h.18);7(h.1l){h.1q=[];1I(8 i=0;i<g.L;i++)h.1q.J(i);h.1q.3v(4(a,b){O 3w.1l()-0.5});h.Z=0;h.18=h.1q[0]}Q 7(h.18>=g.L)h.18=0;8 k=h.18||0;f.u({1R:\'2H\',y:0,9:0}).U().1s(4(i){8 z=k?i>=k?g.L-(i-k):k-i:g.L-i;$j(x).u(\'z-1G\',z)});$j(g[k]).u(\'1h\',1).V();7($j.25.26)g[k].2I.2J(\'2j\');7(h.1m&&h.D)f.D(h.D);7(h.1m&&h.C&&h.C!=\'1S\')f.C(h.C);7(h.2b)e.2K(4(){x.1g=1},4(){x.1g=0});8 l=$j.E.B.M[h.1p];7($j.2L(l))l(e,f,h);Q 7(h.1p!=\'2k\')1n(\'3x 3y: \'+h.1p);f.1s(4(){8 a=$j(x);x.11=(h.1m&&h.C)?h.C:a.C();x.12=(h.1m&&h.D)?h.D:a.D()});h.A=h.A||{};h.I=h.I||{};h.G=h.G||{};f.1o(\':2l(\'+k+\')\').u(h.A);7(h.1f)$j(f[k]).u(h.1f);7(h.W){h.W=T(h.W);7(h.19.29==2y)h.19=$j.1p.3z[h.19]||T(h.19);7(!h.1T)h.19=h.19/2;3A((h.W-h.19)<3B)h.W+=h.19}7(h.2m)h.1U=h.1V=h.2m;7(!h.1z)h.1z=h.19;7(!h.1J)h.1J=h.19;h.2M=g.L;h.1b=k;7(h.1l){h.N=h.1b;7(++h.Z==g.L)h.Z=0;h.N=h.1q[h.Z]}Q h.N=h.18>=(g.L-1)?0:h.18+1;8 m=f[k];7(h.H.L)h.H[0].1W(m,[m,m,h,2c]);7(h.1k.L>1)h.1k[1].1W(m,[m,m,h,2c]);7(h.1K&&!h.1a)h.1a=h.1K;7(h.1a)$j(h.1a).2n(\'1K\',4(){O 1O(g,h,h.1y?-1:1)});7(h.2o)$j(h.2o).2n(\'1K\',4(){O 1O(g,h,h.1y?1:-1)});7(h.1r)2N(g,h);h.3C=4(a,b){8 c=$j(a),s=c[0];7(!h.2g)h.2f++;g[b?\'1P\':\'J\'](s);7(h.1c)h.1c[b?\'1P\':\'J\'](s);h.2M=g.L;c.u(\'1R\',\'2H\');c[b?\'3D\':\'2O\'](e);7(b){h.1b++;h.N++}7(r&&h.1Q&&!h.2G)2i(c);7(h.1m&&h.D)c.D(h.D);7(h.1m&&h.C&&h.C!=\'1S\')f.C(h.C);s.11=(h.1m&&h.C)?h.C:c.C();s.12=(h.1m&&h.D)?h.D:c.D();c.u(h.A);7(h.1r)$j.E.B.2p(g.L-1,s,$j(h.1r),g,h);7(1X h.X==\'4\')h.X(c)};7(h.W||h.1x)x.S=1Y(4(){1j(g,h,0,!h.1y)},h.1x?10:h.W+(h.2P||0))})};4 1j(a,b,c,d){7(b.2h)O;8 p=b.1w,1A=a[b.1b],1a=a[b.N];7(p.S===0&&!c)O;7(!c&&!p.1g&&((b.2e&&(--b.2f<=0))||(b.1Z&&!b.1l&&b.N<b.1b))){7(b.2q)b.2q(b);O}7(c||!p.1g){7(b.H.L)$j.1s(b.H,4(i,o){o.1W(1a,[1A,1a,b,d])});8 e=4(){7($j.25.26&&b.1Q)x.2I.2J(\'2j\');$j.1s(b.1k,4(i,o){o.1W(1a,[1A,1a,b,d])})};7(b.N!=b.1b){b.2h=1;7(b.20)b.20(1A,1a,b,e,d);Q 7($j.2L($j.E.B[b.1p]))$j.E.B[b.1p](1A,1a,b,e);Q $j.E.B.2k(1A,1a,b,e,c&&b.2Q)}7(b.1l){b.1b=b.N;7(++b.Z==a.L)b.Z=0;b.N=b.1q[b.Z]}Q{8 f=(b.N+1)==a.L;b.N=f?0:b.N+1;b.1b=f?a.L-1:b.N-1}7(b.1r)$j.E.B.2r(b.1r,b.1b)}7(b.W&&!b.1x)p.S=1Y(4(){1j(a,b,0,!b.1y)},b.W);Q 7(b.1x&&p.1g)p.S=1Y(4(){1j(a,b,0,!b.1y)},10)};$j.E.B.2r=4(a,b){$j(a).3E(\'a\').3F(\'2R\').2j(\'a:2l(\'+b+\')\').3G(\'2R\')};4 1O(a,b,c){8 p=b.1w,W=p.S;7(W){1v(W);p.S=0}7(b.1l&&c<0){b.Z--;7(--b.Z==-2)b.Z=a.L-2;Q 7(b.Z==-1)b.Z=a.L-1;b.N=b.1q[b.Z]}Q 7(b.1l){7(++b.Z==a.L)b.Z=0;b.N=b.1q[b.Z]}Q{b.N=b.1b+c;7(b.N<0){7(b.1Z)O 21;b.N=a.L-1}Q 7(b.N>=a.L){7(b.1Z)O 21;b.N=0}}7(b.22&&1X b.22==\'4\')b.22(c>0,b.N,a[b.N]);1j(a,b,1,c>=0);O 21};4 2N(a,b){8 c=$j(b.1r);$j.1s(a,4(i,o){$j.E.B.2p(i,o,c,a,b)});$j.E.B.2r(b.1r,b.18)};$j.E.B.2p=4(i,a,b,c,d){8 e=(1X d.2s==\'4\')?$j(d.2s(i,a)):$j(\'<a 3H="#">\'+(i+1)+\'</a>\');7(e.3I(\'3J\').L==0)e.2O(b);e.2n(d.2S,4(){d.N=i;8 p=d.1w,W=p.S;7(W){1v(W);p.S=0}7(1X d.2t==\'4\')d.2t(d.N,c[d.N]);1j(c,d,1,d.1b<i);O 21});7(d.2T)e.2K(4(){d.1w.1g=1},4(){d.1w.1g=0})};4 2i(b){4 23(s){8 s=T(s).3K(16);O s.L<2?\'0\'+s:s};4 2U(e){1I(;e&&e.3L.3M()!=\'3N\';e=e.3O){8 v=$j.u(e,\'2V-2W\');7(v.3P(\'3Q\')>=0){8 a=v.1H(/\\d+/g);O\'#\'+23(a[0])+23(a[1])+23(a[2])}7(v&&v!=\'3R\')O v}O\'#3S\'};b.1s(4(){$j(x).u(\'2V-2W\',2U(x))})};$j.E.B.2k=4(a,b,c,d,e){8 f=$j(a),$jn=$j(b);$jn.u(c.A);8 g=e?1:c.1z;8 h=e?1:c.1J;8 i=e?P:c.1U;8 j=e?P:c.1V;8 k=4(){$jn.24(c.I,g,i,d)};f.24(c.G,h,j,4(){7(c.K)f.u(c.K);7(!c.1T)k()});7(c.1T)k()};$j.E.B.M={2X:4(b,c,d){c.1o(\':2l(\'+d.18+\')\').u(\'1h\',0);d.H.J(4(){$j(x).V()});d.I={1h:1};d.G={1h:0};d.A={1h:0};d.K={R:\'Y\'};d.X=4(a){a.U()}}};$j.E.B.3T=4(){O q};$j.E.B.2E={1p:\'2X\',W:3U,1x:0,19:3V,1z:P,1J:P,1a:P,2o:P,22:P,1r:P,2t:P,2S:\'1K\',2s:P,H:P,1k:P,2q:P,2m:P,1U:P,1V:P,1L:P,I:P,G:P,A:P,K:P,20:P,C:\'1S\',18:0,1T:1,1l:0,1m:0,2b:0,2T:0,2e:0,2g:0,2P:0,2d:P,1Q:0,1Z:0,2Q:0}})(2Y);(4($j){$j.E.B.M.3W=4(d,e,f){d.u(\'17\',\'1d\');f.H.J(4(a,b,c){$j(x).V();c.A.y=b.1B;c.G.y=0-a.1B});f.1f={y:0};f.I={y:0};f.K={R:\'Y\'}};$j.E.B.M.3X=4(d,e,f){d.u(\'17\',\'1d\');f.H.J(4(a,b,c){$j(x).V();c.A.y=0-b.1B;c.G.y=a.1B});f.1f={y:0};f.I={y:0};f.K={R:\'Y\'}};$j.E.B.M.3Y=4(d,e,f){d.u(\'17\',\'1d\');f.H.J(4(a,b,c){$j(x).V();c.A.9=b.1C;c.G.9=0-a.1C});f.1f={9:0};f.I={9:0}};$j.E.B.M.3Z=4(d,e,f){d.u(\'17\',\'1d\');f.H.J(4(a,b,c){$j(x).V();c.A.9=0-b.1C;c.G.9=a.1C});f.1f={9:0};f.I={9:0}};$j.E.B.M.40=4(f,g,h){f.u(\'17\',\'1d\').D();h.H.J(4(a,b,c,d){$j(x).V();8 e=a.1C,2u=b.1C;c.A=d?{9:2u}:{9:-2u};c.I.9=0;c.G.9=d?-e:e;g.1o(a).u(c.A)});h.1f={9:0};h.K={R:\'Y\'}};$j.E.B.M.41=4(f,g,h){f.u(\'17\',\'1d\');h.H.J(4(a,b,c,d){$j(x).V();8 e=a.1B,2v=b.1B;c.A=d?{y:-2v}:{y:2v};c.I.y=0;c.G.y=d?e:-e;g.1o(a).u(c.A)});h.1f={y:0};h.K={R:\'Y\'}};$j.E.B.M.42=4(d,e,f){f.H.J(4(a,b,c){$j(a).u(\'F\',1)});f.X=4(a){a.U()};f.A={F:2};f.I={D:\'V\'};f.G={D:\'U\'}};$j.E.B.M.43=4(d,e,f){f.H.J(4(a,b,c){$j(a).u(\'F\',1)});f.X=4(a){a.U()};f.A={F:2};f.I={C:\'V\'};f.G={C:\'U\'}};$j.E.B.M.1L=4(g,h,j){8 w=g.u(\'17\',\'2Z\').D();h.u({9:0,y:0});j.H.J(4(){$j(x).V()});j.19=j.19/2;j.1l=0;j.1L=j.1L||{9:-w,y:15};j.1c=[];1I(8 i=0;i<h.L;i++)j.1c.J(h[i]);1I(8 i=0;i<j.18;i++)j.1c.J(j.1c.31());j.20=4(a,b,c,d,e){8 f=e?$j(a):$j(b);f.24(c.1L,c.1z,c.1U,4(){e?c.1c.J(c.1c.31()):c.1c.1P(c.1c.44());7(e)1I(8 i=0,2w=c.1c.L;i<2w;i++)$j(c.1c[i]).u(\'z-1G\',2w-i);Q{8 z=$j(a).u(\'z-1G\');f.u(\'z-1G\',T(z)+1)}f.24({9:0,y:0},c.1J,c.1V,4(){$j(e?x:a).U();7(d)d()})})};j.X=4(a){a.U()}};$j.E.B.M.45=4(d,e,f){f.H.J(4(a,b,c){$j(x).V();c.A.y=b.11;c.I.C=b.11});f.X=4(a){a.U()};f.1f={y:0};f.A={C:0};f.I={y:0};f.G={C:0};f.K={R:\'Y\'}};$j.E.B.M.46=4(d,e,f){f.H.J(4(a,b,c){$j(x).V();c.I.C=b.11;c.G.y=a.11});f.X=4(a){a.U()};f.1f={y:0};f.A={y:0,C:0};f.G={C:0};f.K={R:\'Y\'}};$j.E.B.M.47=4(d,e,f){f.H.J(4(a,b,c){$j(x).V();c.A.9=b.12;c.I.D=b.12});f.X=4(a){a.U()};f.A={D:0};f.I={9:0};f.G={D:0};f.K={R:\'Y\'}};$j.E.B.M.48=4(d,e,f){f.H.J(4(a,b,c){$j(x).V();c.I.D=b.12;c.G.9=a.12});f.X=4(a){a.U()};f.A={9:0,D:0};f.I={9:0};f.G={D:0};f.K={R:\'Y\'}};$j.E.B.M.32=4(d,e,f){f.1f={y:0,9:0};f.K={R:\'Y\'};f.H.J(4(a,b,c){$j(x).V();c.A={D:0,C:0,y:b.11/2,9:b.12/2};c.K={R:\'Y\'};c.I={y:0,9:0,D:b.12,C:b.11};c.G={D:0,C:0,y:a.11/2,9:a.12/2};$j(a).u(\'F\',2);$j(b).u(\'F\',1)});f.X=4(a){a.U()}};$j.E.B.M.49=4(d,e,f){f.H.J(4(a,b,c){c.A={D:0,C:0,1h:1,9:b.12/2,y:b.11/2,F:1};c.I={y:0,9:0,D:b.12,C:b.11}});f.G={1h:0};f.K={F:0}};$j.E.B.M.4a=4(d,e,f){8 w=d.u(\'17\',\'1d\').D();e.V();f.H.J(4(a,b,c){$j(a).u(\'F\',1)});f.A={9:w,F:2};f.K={F:1};f.I={9:0};f.G={9:w}};$j.E.B.M.4b=4(d,e,f){8 h=d.u(\'17\',\'1d\').C();e.V();f.H.J(4(a,b,c){$j(a).u(\'F\',1)});f.A={y:h,F:2};f.K={F:1};f.I={y:0};f.G={y:h}};$j.E.B.M.4c=4(d,e,f){8 h=d.u(\'17\',\'1d\').C();8 w=d.D();e.V();f.H.J(4(a,b,c){$j(a).u(\'F\',1)});f.A={y:h,9:w,F:2};f.K={F:1};f.I={y:0,9:0};f.G={y:h,9:w}};$j.E.B.M.4d=4(d,e,f){f.H.J(4(a,b,c){c.A={9:x.12/2,D:0,F:2};c.I={9:0,D:x.12};c.G={9:0};$j(a).u(\'F\',1)});f.X=4(a){a.U().u(\'F\',1)}};$j.E.B.M.4e=4(d,e,f){f.H.J(4(a,b,c){c.A={y:x.11/2,C:0,F:2};c.I={y:0,C:x.11};c.G={y:0};$j(a).u(\'F\',1)});f.X=4(a){a.U().u(\'F\',1)}};$j.E.B.M.4f=4(d,e,f){f.H.J(4(a,b,c){c.A={9:b.12/2,D:0,F:1,R:\'1D\'};c.I={9:0,D:x.12};c.G={9:a.12/2,D:0};$j(a).u(\'F\',2)});f.X=4(a){a.U()};f.K={F:1,R:\'Y\'}};$j.E.B.M.4g=4(d,e,f){f.H.J(4(a,b,c){c.A={y:b.11/2,C:0,F:1,R:\'1D\'};c.I={y:0,C:x.11};c.G={y:a.11/2,C:0};$j(a).u(\'F\',2)});f.X=4(a){a.U()};f.K={F:1,R:\'Y\'}};$j.E.B.M.4h=4(e,f,g){8 d=g.33||\'9\';8 w=e.u(\'17\',\'1d\').D();8 h=e.C();g.H.J(4(a,b,c){c.A=c.A||{};c.A.F=2;c.A.R=\'1D\';7(d==\'34\')c.A.9=-w;Q 7(d==\'35\')c.A.y=h;Q 7(d==\'36\')c.A.y=-h;Q c.A.9=w;$j(a).u(\'F\',1)});7(!g.I)g.I={9:0,y:0};7(!g.G)g.G={9:0,y:0};g.K=g.K||{};g.K.F=2;g.K.R=\'Y\'};$j.E.B.M.4i=4(e,f,g){8 d=g.33||\'9\';8 w=e.u(\'17\',\'1d\').D();8 h=e.C();g.H.J(4(a,b,c){c.A.R=\'1D\';7(d==\'34\')c.G.9=w;Q 7(d==\'35\')c.G.y=-h;Q 7(d==\'36\')c.G.y=h;Q c.G.9=-w;$j(a).u(\'F\',2);$j(b).u(\'F\',1)});g.X=4(a){a.U()};7(!g.I)g.I={9:0,y:0};g.A=g.A||{};g.A.y=0;g.A.9=0;g.K=g.K||{};g.K.F=1;g.K.R=\'Y\'};$j.E.B.M.4j=4(d,e,f){8 w=d.u(\'17\',\'2Z\').D();8 h=d.C();f.H.J(4(a,b,c){$j(a).u(\'F\',2);c.A.R=\'1D\';7(!c.G.9&&!c.G.y)c.G={9:w*2,y:-h/2,1h:0};Q c.G.1h=0});f.X=4(a){a.U()};f.A={9:0,y:0,F:1,1h:1};f.I={9:0};f.K={F:2,R:\'Y\'}};$j.E.B.M.4k=4(o,p,q){8 w=o.u(\'17\',\'1d\').D();8 h=o.C();q.A=q.A||{};8 s;7(q.1i){7(/4l/.1u(q.1i))s=\'1t(1e 1e \'+h+\'14 1e)\';Q 7(/4m/.1u(q.1i))s=\'1t(1e \'+w+\'14 \'+h+\'14 \'+w+\'14)\';Q 7(/4n/.1u(q.1i))s=\'1t(1e \'+w+\'14 1e 1e)\';Q 7(/4o/.1u(q.1i))s=\'1t(\'+h+\'14 \'+w+\'14 \'+h+\'14 1e)\';Q 7(/32/.1u(q.1i)){8 t=T(h/2);8 l=T(w/2);s=\'1t(\'+t+\'14 \'+l+\'14 \'+t+\'14 \'+l+\'14)\'}}q.A.1i=q.A.1i||s||\'1t(1e 1e 1e 1e)\';8 d=q.A.1i.1H(/(\\d+)/g);8 t=T(d[0]),r=T(d[1]),b=T(d[2]),l=T(d[3]);q.H.J(4(g,i,j){7(g==i)O;8 k=$j(g).u(\'F\',2);8 m=$j(i).u({F:3,R:\'1D\'});8 n=1,1E=T((j.1z/13))-1;4 f(){8 a=t?t-T(n*(t/1E)):0;8 c=l?l-T(n*(l/1E)):0;8 d=b<h?b+T(n*((h-b)/1E||1)):h;8 e=r<w?r+T(n*((w-r)/1E||1)):w;m.u({1i:\'1t(\'+a+\'14 \'+e+\'14 \'+d+\'14 \'+c+\'14)\'});(n++<=1E)?1Y(f,13):k.u(\'R\',\'Y\')}f()});q.K={};q.I={9:0};q.G={9:0}}})(2Y);',62,273,'||||function|||if|var|left|||||||||||||||||||||css|||this|top||cssBefore|cycle|height|width|fn|zIndex|animOut|before|animIn|push|cssAfter|length|transitions|nextSlide|return|null|else|display|cycleTimeout|parseInt|hide|show|timeout|onAddSlide|none|randomIndex||cycleH|cycleW||px|||overflow|startingSlide|speed|next|currSlide|els|hidden|0px|cssFirst|cyclePause|opacity|clip|go|after|random|fit|log|not|fx|randomMap|pager|each|rect|test|clearTimeout|container|continuous|rev|speedIn|curr|offsetHeight|offsetWidth|block|count|data|index|match|for|speedOut|click|shuffle|opts|elements|advance|unshift|cleartype|position|auto|sync|easeIn|easeOut|apply|typeof|setTimeout|nowrap|fxFn|false|prevNextClick|hex|animate|browser|msie|window|console|constructor|case|pause|true|slideExpr|autostop|countdown|autostopCount|busy|clearTypeFix|filter|custom|eq|easing|bind|prev|createPagerAnchor|end|updateActivePagerLink|pagerAnchorBuilder|pagerClick|nextW|nextH|len|arguments|String|resume|options|found|can|slide|defaults|metadata|cleartypeNoBg|absolute|style|removeAttribute|hover|isFunction|slideCount|buildPager|appendTo|delay|fastOnEvent|activeSlide|pagerEvent|pauseOnPagerHover|getBg|background|color|fade|jQuery|visible||shift|zoom|direction|right|up|down|MSIE|navigator|userAgent|Array|prototype|join|call|undefined|switch|stop|default|Number|invalid|children|get|terminating|too|few|slides|extend|meta|className|static|relative|sort|Math|unknown|transition|speeds|while|250|addSlide|prependTo|find|removeClass|addClass|href|parents|body|toString|nodeName|toLowerCase|html|parentNode|indexOf|rgb|transparent|ffffff|ver|4000|1000|scrollUp|scrollDown|scrollLeft|scrollRight|scrollHorz|scrollVert|slideX|slideY|pop|turnUp|turnDown|turnLeft|turnRight|fadeZoom|blindX|blindY|blindZ|growX|growY|curtainX|curtainY|cover|uncover|toss|wipe|l2r|r2l|t2b|b2t'.split('|'),0,{}));


 var visible_limit = 3;
 
 var count = 0;
 var start_disabled = 0;
 var clicked = false;
 
 function onBefore() { 
 // The current node
 count = $j(this).prevAll().length;
 // 
 if ( count > visible_limit)
 {
 $j('#imagenav li:eq('+count+')').show();
 $j('#imagenav li:eq('+(count-4)+')').hide();
 prev = count;
 }
 
 // if we loop reset to all on
 // only do this if we havent just clicked
 if ( prev > count && clicked == false)
 {
 // Hide all after 3
 $j('#imagenav li:eq(3)').nextAll().hide();
 $j('#imagenav li:eq(4)').prevAll().show();
 prev = 0;
 }
 

 $j('#imagenav li').removeClass('active');
 $j('#imagenav li:eq('+count+')').addClass('active');
 clicked = false;
 } 

 var prev = 0;
 
 function onAfter()
 { 
 
 }


 $j(document).ready(function()
 { 
 // Clear some non js fixes in css
 $j('.home #imagenav').css('overflow', 'visible')
 
// if(! $j.browser.msie)
// {
// $j('#latest_two').css('left', '310px');
// $j('#latest_three').css(
// {
// left:'630px',
// position:'relative'
// });
// }

 
 $j('.overlay').css(
 {
 position:'relative',
 zIndex:'9999999'
 });
 
 // Hide any more than 4 elements
 $j('#imagenav li:eq('+visible_limit+')').nextAll().hide();
 
 // start_disabled = 
 $j(".jqzoom").jqueryzoom({xzoom: 458, yzoom: 622, offset: 20, position: "right", preload:1, lens:1, fadeIn: 600,fadeOut: 600}); 

 $j('#article #slide ul').cycle
 ({ 
 fx: 'fade', 
 timeout: 6000,
 delay: 0,
 speed: 400, 
 before: onBefore,
 
 after: onAfter,
 pager: '#imagenav',
 pagerAnchorBuilder: function(idx, slide)
 { 
 // return selector string for existing anchor 
 return '#imagenav li:eq(' + idx + ') a'; 
 },
 pagerClick: function() {
 clicked = true;
 },
 pause: 1
 });

 
// $j('#latest_one').cycle
// ({
// fx: 'fade',
// timeout: 0,
// next: '#latest_one',
// speed: 2500,
// timeout: 0
// });
// 
// $j('#latest_two').cycle
// ({
// fx: 'fade',
// timeout: 0,
// next: '#latest_two',
// speed: 2500,
// timeout: 0
// });
// 
// 
// $j('#latest_one').bind('mouseover', function()
// {
// $j('#latest_one ').click();
// });
// 
// $j('#latest_two').bind('mouseover', function()
// {
// $j('#latest_two ').click();
// });

 $j('#mast #bag').hover(
 function () {
 $j(this).addClass('sfhover');
 }, 
 function () {
 $j(this).removeClass('sfhover');
 }
 );

 $j('#help ul li').hover(
 function () {
 $j(this).addClass('sfhover');
 }, 
 function () {
 $j(this).removeClass('sfhover');
 }
 ); 

 $j('#navigation #siteNav li').hover(
 function () {
 $j(this).addClass('sfhover');
 }, 
 function () {
 $j(this).removeClass('sfhover');
 }
 );
 
 $j('.home #imagenav li').hover(
 function () {
 $j(this).addClass('sfhover');
 }, 
 function () {
 $j(this).removeClass('sfhover');
 }
 );

// $j('#logo').bind('click', function()
// {
// window.location = '/';
// });

 $j('.women_hover').hover
 (
 function () {
 $j('.lim_women').addClass('showblock');
 }, 
 function () {
 $j('.lim_women').removeClass('showblock');
 });
 
 $j('.men_hover').hover
 (
 
 function () {
 $j('.lim_men').addClass('showblock');
 }, 
 function () {
 $j('.lim_men').removeClass('showblock'); 
 });
 
 
 
 $j('.lim_men, .lim_women').hover
 (
 function () {
 $j(this).addClass('showblock');
 }, 
 function () {
 $j(this).removeClass('showblock'); 
 });

});



//----------------------------------
// ALL BELOW FOR MUSIC PLAYER POPUP
//----------------------------------

function launch_fp() {
 if (Macintosh_fp == true && browserName_fp == "IE") {
 playerWindow_fp = newWin_fp('http://www.fredperrysubculture.com/musicplayer_mainsite.asp?list=cat&id=1','player',600,88,false,'no','no','no','no','no','no',false,0,0);
 } else {
 playerWindow_fp = newWin_fp('http://www.fredperrysubculture.com/musicplayer_mainsite.asp?list=cat&id=1','player',600,58,false,'no','no','no','no','no','no',false,0,0);
 }
}

var its_fp;
var browserName_fp;
var browserName_fpLong;
var browserNew_fp;
var preloadFlag_fp = false;
var Macintosh_fp = navigator.userAgent.indexOf('Mac')>0;

function its_fp() {
 var n = navigator;
 var ua = ' ' + n.userAgent.toLowerCase();
 var pl = n.platform.toLowerCase();
 var an = n.appName.toLowerCase();

 // browser version
 this.version = n.appVersion;
 this.nn = ua.indexOf('mozilla') > 0;

 // 'compatible' versions of mozilla aren't navigator
 if(ua.indexOf('compatible') > 0) {
 this.nn = false;
 }
 
 this.opera = ua.indexOf('opera') > 0;
 this.ie = ua.indexOf('msie') > 0;
 this.major = parseInt( this.version );
 this.minor = parseFloat( this.version );

 // platform
 this.mac = ua.indexOf('mac') > 0;
 this.win = ua.indexOf('win') > 0;

 // workaround for IE5 which reports its_fpelf as version 4.0
 if(this.ie) {
 if(ua.indexOf("msie 5") > 1) {
 var msieIndex = navigator.appVersion.indexOf("MSIE") + 5;
 this.major = parseFloat(navigator.appVersion.substr(msieIndex,3));
 }
 }

 return this;
}

function browserNaming_fp() {
 its_fp = new its_fp();
 
 // is it a DOM-enabled browser?
 if (!document.getElementById) {
 browserNew_fp = false;
 }
 else {
 browserNew_fp = true;
 }

 // need the name, too
 if (its_fp.opera) {
 browserName_fp = "Opera";
 }
 else if (its_fp.ie) {
 browserName_fp = "IE";
 }
 else {
 browserName_fp = "NS";
 }

 // and the number
 browserName_fpLong = browserName_fp + its_fp.major;

}
//initialise browser checking
browserNaming_fp();


function newWin_fp(theurl,winName,windowWidth,windowHeight,center,status,menubar,toolbar,resizable,scroll,location,offset,xPos,yPos) {
 //check if browser is version 4 or above, and if centering is desired
 if (its_fp.major >= 4 && center == true) {
 wX = (screen.width/2)-(windowWidth/2+10);
 wY = (screen.height/2)-(windowHeight/2+20);
 }else if (offset == true) {
 wX = xPos;
 wY = yPos; // offset window
 }else {
 wX = 0;
 wY = 0; // set window pos to 0,0 if browser is not ver 4 or center == false && offset == false
 }
 theurl = theurl;
 var popped = window.open(theurl,winName,'width='+windowWidth+',height='+windowHeight+',status='+status+',menubar='+menubar+',toolbar='+toolbar+',scrollbars='+scroll+',resizable='+resizable+',location='+location+',screenX='+wX+',screenY='+wY+',left='+wX+',top='+wY);
 if (browserName_fp == "NS" || document.all) {
 popped.focus();
 }
}


function launch(list, trackid) {
 if (Macintosh_fp == true && browserName_fp == "IE") {
 playerWindow_fp = newWin_fp('http://www.fredperrysubculture.com/musicplayer_mainsite.asp?list='+list+'&id='+trackid,'player',600,88,false,'no','no','no','no','no','no',false,0,0);
 } else {
 playerWindow_fp = newWin_fp('http://www.fredperrysubculture.com/musicplayer_mainsite.asp?list='+list+'&id='+trackid,'player',600,58,false,'no','no','no','no','no','no',false,0,0);
 }
}

/**
 * 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.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){
 $j('.validation-failed').removeClass('validation-failed');
 $j('.validation-advice').animate({opacity: '0'});
 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);
 
 // MP: If we have options we should sort them, string options are sizes xxxxs <> xxxxl
 if (options != undefined)
 {
 if (typeof options[0].label == 'string')
 {
 if (isNaN(parseInt(options[0].label)))
 { 
 options.sort(function (a, b) {
 var lookup = {xxxxs:1, xxxs:2, xxs:3, xs:4, s:5, m:6, l:7, xl:8, xxl:9, xxxl:10, xxxxl:11};
 var _a = lookup[a.label.toLowerCase()];
 var _b = lookup[b.label.toLowerCase()];
 
 return (_a||99) - (_b||99);
 });
 }
 else
 {
 options.sort(function(a,b){ return a.label - b.label});
 }
 }
 }
 
 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);
 var str = option.label;
 if(price){
 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.optionPrices = {};
 this.containers = {};

 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;
 $H(this.optionPrices).each(function(pair) {
 result += pair.value;
 });
 return result;
 },

 reload: function() {
 var price;
 var formattedPrice;
 var optionPrices = this.getOptionPrices();
 $H(this.containers).each(function(pair) {
 var _productPrice;
 if ($(pair.value)) {
 if (pair.value == 'old-price-'+this.productId && this.productOldPrice != this.productPrice) {
 _productPrice = this.productOldPrice;
 } else {
 _productPrice = this.productPrice;
 }

 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.defaultTax / 100);
 var excl = price;
 var incl = excl + tax;
 }

 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;
 formattedPrice = this.formatPrice(price);
 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);
 }
}
/* Copyright Mihai Bazon, 2002-2005 | www.bazon.net/mishoo
 * -----------------------------------------------------------
 *
 * The DHTML Calendar, version 1.0 "It is happening again"
 *
 * Details and latest version at:
 * www.dynarch.com/projects/calendar
 *
 * This script is developed by Dynarch.com. Visit us at www.dynarch.com.
 *
 * This script is distributed under the GNU Lesser General Public License.
 * Read the entire license text here: http://www.gnu.org/licenses/lgpl.html
 */

// $Id: calendar.js,v 1.51 2005/03/07 16:44:31 mishoo Exp $

/** The Calendar object constructor. */
Calendar = function (firstDayOfWeek, dateStr, onSelected, onClose) {
 // member variables
 this.activeDiv = null;
 this.currentDateEl = null;
 this.getDateStatus = null;
 this.getDateToolTip = null;
 this.getDateText = null;
 this.timeout = null;
 this.onSelected = onSelected || null;
 this.onClose = onClose || null;
 this.dragging = false;
 this.hidden = false;
 this.minYear = 1970;
 this.maxYear = 2050;
 this.dateFormat = Calendar._TT["DEF_DATE_FORMAT"];
 this.ttDateFormat = Calendar._TT["TT_DATE_FORMAT"];
 this.isPopup = true;
 this.weekNumbers = true;
 this.firstDayOfWeek = typeof firstDayOfWeek == "number" ? firstDayOfWeek : Calendar._FD; // 0 for Sunday, 1 for Monday, etc.
 this.showsOtherMonths = false;
 this.dateStr = dateStr;
 this.ar_days = null;
 this.showsTime = false;
 this.time24 = true;
 this.yearStep = 2;
 this.hiliteToday = true;
 this.multiple = null;
 // HTML elements
 this.table = null;
 this.element = null;
 this.tbody = null;
 this.firstdayname = null;
 // Combo boxes
 this.monthsCombo = null;
 this.yearsCombo = null;
 this.hilitedMonth = null;
 this.activeMonth = null;
 this.hilitedYear = null;
 this.activeYear = null;
 // Information
 this.dateClicked = false;

 // one-time initializations
 if (typeof Calendar._SDN == "undefined") {
 // table of short day names
 if (typeof Calendar._SDN_len == "undefined")
 Calendar._SDN_len = 3;
 var ar = new Array();
 for (var i = 8; i > 0;) {
 ar[--i] = Calendar._DN[i].substr(0, Calendar._SDN_len);
 }
 Calendar._SDN = ar;
 // table of short month names
 if (typeof Calendar._SMN_len == "undefined")
 Calendar._SMN_len = 3;
 ar = new Array();
 for (var i = 12; i > 0;) {
 ar[--i] = Calendar._MN[i].substr(0, Calendar._SMN_len);
 }
 Calendar._SMN = ar;
 }
};

// ** constants

/// "static", needed for event handlers.
Calendar._C = null;

/// detect a special case of "web browser"
Calendar.is_ie = ( /msie/i.test(navigator.userAgent) &&
 !/opera/i.test(navigator.userAgent) );

Calendar.is_ie5 = ( Calendar.is_ie && /msie 5\.0/i.test(navigator.userAgent) );

/// detect Opera browser
Calendar.is_opera = /opera/i.test(navigator.userAgent);

/// detect KHTML-based browsers
Calendar.is_khtml = /Konqueror|Safari|KHTML/i.test(navigator.userAgent);

// BEGIN: UTILITY FUNCTIONS; beware that these might be moved into a separate
// library, at some point.

Calendar.getAbsolutePos = function(el) {
 var SL = 0, ST = 0;
 var is_div = /^div$/i.test(el.tagName);
 if (is_div && el.scrollLeft)
 SL = el.scrollLeft;
 if (is_div && el.scrollTop)
 ST = el.scrollTop;
 var r = { x: el.offsetLeft - SL, y: el.offsetTop - ST };
 if (el.offsetParent) {
 var tmp = this.getAbsolutePos(el.offsetParent);
 r.x += tmp.x;
 r.y += tmp.y;
 }
 return r;
};

Calendar.isRelated = function (el, evt) {
 var related = evt.relatedTarget;
 if (!related) {
 var type = evt.type;
 if (type == "mouseover") {
 related = evt.fromElement;
 } else if (type == "mouseout") {
 related = evt.toElement;
 }
 }
 while (related) {
 if (related == el) {
 return true;
 }
 related = related.parentNode;
 }
 return false;
};

Calendar.removeClass = function(el, className) {
 if (!(el && el.className)) {
 return;
 }
 var cls = el.className.split(" ");
 var ar = new Array();
 for (var i = cls.length; i > 0;) {
 if (cls[--i] != className) {
 ar[ar.length] = cls[i];
 }
 }
 el.className = ar.join(" ");
};

Calendar.addClass = function(el, className) {
 Calendar.removeClass(el, className);
 el.className += " " + className;
};

// FIXME: the following 2 functions totally suck, are useless and should be replaced immediately.
Calendar.getElement = function(ev) {
 var f = Calendar.is_ie ? window.event.srcElement : ev.currentTarget;
 while (f.nodeType != 1 || /^div$/i.test(f.tagName))
 f = f.parentNode;
 return f;
};

Calendar.getTargetElement = function(ev) {
 var f = Calendar.is_ie ? window.event.srcElement : ev.target;
 while (f.nodeType != 1)
 f = f.parentNode;
 return f;
};

Calendar.stopEvent = function(ev) {
 ev || (ev = window.event);
 if (Calendar.is_ie) {
 ev.cancelBubble = true;
 ev.returnValue = false;
 } else {
 ev.preventDefault();
 ev.stopPropagation();
 }
 return false;
};

Calendar.addEvent = function(el, evname, func) {
 if (el.attachEvent) { // IE
 el.attachEvent("on" + evname, func);
 } else if (el.addEventListener) { // Gecko / W3C
 el.addEventListener(evname, func, true);
 } else {
 el["on" + evname] = func;
 }
};

Calendar.removeEvent = function(el, evname, func) {
 if (el.detachEvent) { // IE
 el.detachEvent("on" + evname, func);
 } else if (el.removeEventListener) { // Gecko / W3C
 el.removeEventListener(evname, func, true);
 } else {
 el["on" + evname] = null;
 }
};

Calendar.createElement = function(type, parent) {
 var el = null;
 if (document.createElementNS) {
 // use the XHTML namespace; IE won't normally get here unless
 // _they_ "fix" the DOM2 implementation.
 el = document.createElementNS("http://www.w3.org/1999/xhtml", type);
 } else {
 el = document.createElement(type);
 }
 if (typeof parent != "undefined") {
 parent.appendChild(el);
 }
 return el;
};

// END: UTILITY FUNCTIONS

// BEGIN: CALENDAR STATIC FUNCTIONS

/** Internal -- adds a set of events to make some element behave like a button. */
Calendar._add_evs = function(el) {
 with (Calendar) {
 addEvent(el, "mouseover", dayMouseOver);
 addEvent(el, "mousedown", dayMouseDown);
 addEvent(el, "mouseout", dayMouseOut);
 if (is_ie) {
 addEvent(el, "dblclick", dayMouseDblClick);
 el.setAttribute("unselectable", true);
 }
 }
};

Calendar.findMonth = function(el) {
 if (typeof el.month != "undefined") {
 return el;
 } else if (typeof el.parentNode.month != "undefined") {
 return el.parentNode;
 }
 return null;
};

Calendar.findYear = function(el) {
 if (typeof el.year != "undefined") {
 return el;
 } else if (typeof el.parentNode.year != "undefined") {
 return el.parentNode;
 }
 return null;
};

Calendar.showMonthsCombo = function () {
 var cal = Calendar._C;
 if (!cal) {
 return false;
 }
 var cal = cal;
 var cd = cal.activeDiv;
 var mc = cal.monthsCombo;
 if (cal.hilitedMonth) {
 Calendar.removeClass(cal.hilitedMonth, "hilite");
 }
 if (cal.activeMonth) {
 Calendar.removeClass(cal.activeMonth, "active");
 }
 var mon = cal.monthsCombo.getElementsByTagName("div")[cal.date.getMonth()];
 Calendar.addClass(mon, "active");
 cal.activeMonth = mon;
 var s = mc.style;
 s.display = "block";
 if (cd.navtype < 0)
 s.left = cd.offsetLeft + "px";
 else {
 var mcw = mc.offsetWidth;
 if (typeof mcw == "undefined")
 // Konqueror brain-dead techniques
 mcw = 50;
 s.left = (cd.offsetLeft + cd.offsetWidth - mcw) + "px";
 }
 s.top = (cd.offsetTop + cd.offsetHeight) + "px";
};

Calendar.showYearsCombo = function (fwd) {
 var cal = Calendar._C;
 if (!cal) {
 return false;
 }
 var cal = cal;
 var cd = cal.activeDiv;
 var yc = cal.yearsCombo;
 if (cal.hilitedYear) {
 Calendar.removeClass(cal.hilitedYear, "hilite");
 }
 if (cal.activeYear) {
 Calendar.removeClass(cal.activeYear, "active");
 }
 cal.activeYear = null;
 var Y = cal.date.getFullYear() + (fwd ? 1 : -1);
 var yr = yc.firstChild;
 var show = false;
 for (var i = 12; i > 0; --i) {
 if (Y >= cal.minYear && Y <= cal.maxYear) {
 yr.innerHTML = Y;
 yr.year = Y;
 yr.style.display = "block";
 show = true;
 } else {
 yr.style.display = "none";
 }
 yr = yr.nextSibling;
 Y += fwd ? cal.yearStep : -cal.yearStep;
 }
 if (show) {
 var s = yc.style;
 s.display = "block";
 if (cd.navtype < 0)
 s.left = cd.offsetLeft + "px";
 else {
 var ycw = yc.offsetWidth;
 if (typeof ycw == "undefined")
 // Konqueror brain-dead techniques
 ycw = 50;
 s.left = (cd.offsetLeft + cd.offsetWidth - ycw) + "px";
 }
 s.top = (cd.offsetTop + cd.offsetHeight) + "px";
 }
};

// event handlers

Calendar.tableMouseUp = function(ev) {
 var cal = Calendar._C;
 if (!cal) {
 return false;
 }
 if (cal.timeout) {
 clearTimeout(cal.timeout);
 }
 var el = cal.activeDiv;
 if (!el) {
 return false;
 }
 var target = Calendar.getTargetElement(ev);
 ev || (ev = window.event);
 Calendar.removeClass(el, "active");
 if (target == el || target.parentNode == el) {
 Calendar.cellClick(el, ev);
 }
 var mon = Calendar.findMonth(target);
 var date = null;
 if (mon) {
 date = new Date(cal.date);
 if (mon.month != date.getMonth()) {
 date.setMonth(mon.month);
 cal.setDate(date);
 cal.dateClicked = false;
 cal.callHandler();
 }
 } else {
 var year = Calendar.findYear(target);
 if (year) {
 date = new Date(cal.date);
 if (year.year != date.getFullYear()) {
 date.setFullYear(year.year);
 cal.setDate(date);
 cal.dateClicked = false;
 cal.callHandler();
 }
 }
 }
 with (Calendar) {
 removeEvent(document, "mouseup", tableMouseUp);
 removeEvent(document, "mouseover", tableMouseOver);
 removeEvent(document, "mousemove", tableMouseOver);
 cal._hideCombos();
 _C = null;
 return stopEvent(ev);
 }
};

Calendar.tableMouseOver = function (ev) {
 var cal = Calendar._C;
 if (!cal) {
 return;
 }
 var el = cal.activeDiv;
 var target = Calendar.getTargetElement(ev);
 if (target == el || target.parentNode == el) {
 Calendar.addClass(el, "hilite active");
 Calendar.addClass(el.parentNode, "rowhilite");
 } else {
 if (typeof el.navtype == "undefined" || (el.navtype != 50 && (el.navtype == 0 || Math.abs(el.navtype) > 2)))
 Calendar.removeClass(el, "active");
 Calendar.removeClass(el, "hilite");
 Calendar.removeClass(el.parentNode, "rowhilite");
 }
 ev || (ev = window.event);
 if (el.navtype == 50 && target != el) {
 var pos = Calendar.getAbsolutePos(el);
 var w = el.offsetWidth;
 var x = ev.clientX;
 var dx;
 var decrease = true;
 if (x > pos.x + w) {
 dx = x - pos.x - w;
 decrease = false;
 } else
 dx = pos.x - x;

 if (dx < 0) dx = 0;
 var range = el._range;
 var current = el._current;
 var count = Math.floor(dx / 10) % range.length;
 for (var i = range.length; --i >= 0;)
 if (range[i] == current)
 break;
 while (count-- > 0)
 if (decrease) {
 if (--i < 0)
 i = range.length - 1;
 } else if ( ++i >= range.length )
 i = 0;
 var newval = range[i];
 el.innerHTML = newval;

 cal.onUpdateTime();
 }
 var mon = Calendar.findMonth(target);
 if (mon) {
 if (mon.month != cal.date.getMonth()) {
 if (cal.hilitedMonth) {
 Calendar.removeClass(cal.hilitedMonth, "hilite");
 }
 Calendar.addClass(mon, "hilite");
 cal.hilitedMonth = mon;
 } else if (cal.hilitedMonth) {
 Calendar.removeClass(cal.hilitedMonth, "hilite");
 }
 } else {
 if (cal.hilitedMonth) {
 Calendar.removeClass(cal.hilitedMonth, "hilite");
 }
 var year = Calendar.findYear(target);
 if (year) {
 if (year.year != cal.date.getFullYear()) {
 if (cal.hilitedYear) {
 Calendar.removeClass(cal.hilitedYear, "hilite");
 }
 Calendar.addClass(year, "hilite");
 cal.hilitedYear = year;
 } else if (cal.hilitedYear) {
 Calendar.removeClass(cal.hilitedYear, "hilite");
 }
 } else if (cal.hilitedYear) {
 Calendar.removeClass(cal.hilitedYear, "hilite");
 }
 }
 return Calendar.stopEvent(ev);
};

Calendar.tableMouseDown = function (ev) {
 if (Calendar.getTargetElement(ev) == Calendar.getElement(ev)) {
 return Calendar.stopEvent(ev);
 }
};

Calendar.calDragIt = function (ev) {
 var cal = Calendar._C;
 if (!(cal && cal.dragging)) {
 return false;
 }
 var posX;
 var posY;
 if (Calendar.is_ie) {
 posY = window.event.clientY + document.body.scrollTop;
 posX = window.event.clientX + document.body.scrollLeft;
 } else {
 posX = ev.pageX;
 posY = ev.pageY;
 }
 cal.hideShowCovered();
 var st = cal.element.style;
 st.left = (posX - cal.xOffs) + "px";
 st.top = (posY - cal.yOffs) + "px";
 return Calendar.stopEvent(ev);
};

Calendar.calDragEnd = function (ev) {
 var cal = Calendar._C;
 if (!cal) {
 return false;
 }
 cal.dragging = false;
 with (Calendar) {
 removeEvent(document, "mousemove", calDragIt);
 removeEvent(document, "mouseup", calDragEnd);
 tableMouseUp(ev);
 }
 cal.hideShowCovered();
};

Calendar.dayMouseDown = function(ev) {
 var el = Calendar.getElement(ev);
 if (el.disabled) {
 return false;
 }
 var cal = el.calendar;
 cal.activeDiv = el;
 Calendar._C = cal;
 if (el.navtype != 300) with (Calendar) {
 if (el.navtype == 50) {
 el._current = el.innerHTML;
 addEvent(document, "mousemove", tableMouseOver);
 } else
 addEvent(document, Calendar.is_ie5 ? "mousemove" : "mouseover", tableMouseOver);
 addClass(el, "hilite active");
 addEvent(document, "mouseup", tableMouseUp);
 } else if (cal.isPopup) {
 cal._dragStart(ev);
 }
 if (el.navtype == -1 || el.navtype == 1) {
 if (cal.timeout) clearTimeout(cal.timeout);
 cal.timeout = setTimeout("Calendar.showMonthsCombo()", 250);
 } else if (el.navtype == -2 || el.navtype == 2) {
 if (cal.timeout) clearTimeout(cal.timeout);
 cal.timeout = setTimeout((el.navtype > 0) ? "Calendar.showYearsCombo(true)" : "Calendar.showYearsCombo(false)", 250);
 } else {
 cal.timeout = null;
 }
 return Calendar.stopEvent(ev);
};

Calendar.dayMouseDblClick = function(ev) {
 Calendar.cellClick(Calendar.getElement(ev), ev || window.event);
 if (Calendar.is_ie) {
 document.selection.empty();
 }
};

Calendar.dayMouseOver = function(ev) {
 var el = Calendar.getElement(ev);
 if (Calendar.isRelated(el, ev) || Calendar._C || el.disabled) {
 return false;
 }
 if (el.ttip) {
 if (el.ttip.substr(0, 1) == "_") {
 el.ttip = el.caldate.print(el.calendar.ttDateFormat) + el.ttip.substr(1);
 }
 el.calendar.tooltips.innerHTML = el.ttip;
 }
 if (el.navtype != 300) {
 Calendar.addClass(el, "hilite");
 if (el.caldate) {
 Calendar.addClass(el.parentNode, "rowhilite");
 }
 }
 return Calendar.stopEvent(ev);
};

Calendar.dayMouseOut = function(ev) {
 with (Calendar) {
 var el = getElement(ev);
 if (isRelated(el, ev) || _C || el.disabled)
 return false;
 removeClass(el, "hilite");
 if (el.caldate)
 removeClass(el.parentNode, "rowhilite");
 if (el.calendar)
 el.calendar.tooltips.innerHTML = _TT["SEL_DATE"];
 return stopEvent(ev);
 }
};

/**
 * A generic "click" handler :) handles all types of buttons defined in this
 * calendar.
 */
Calendar.cellClick = function(el, ev) {
 var cal = el.calendar;
 var closing = false;
 var newdate = false;
 var date = null;
 if (typeof el.navtype == "undefined") {
 if (cal.currentDateEl) {
 Calendar.removeClass(cal.currentDateEl, "selected");
 Calendar.addClass(el, "selected");
 closing = (cal.currentDateEl == el);
 if (!closing) {
 cal.currentDateEl = el;
 }
 }
 cal.date.setDateOnly(el.caldate);
 date = cal.date;
 var other_month = !(cal.dateClicked = !el.otherMonth);
 if (!other_month && !cal.currentDateEl)
 cal._toggleMultipleDate(new Date(date));
 else
 newdate = !el.disabled;
 // a date was clicked
 if (other_month)
 cal._init(cal.firstDayOfWeek, date);
 } else {
 if (el.navtype == 200) {
 Calendar.removeClass(el, "hilite");
 cal.callCloseHandler();
 return;
 }
 date = new Date(cal.date);
 if (el.navtype == 0)
 date.setDateOnly(new Date()); // TODAY
 // unless "today" was clicked, we assume no date was clicked so
 // the selected handler will know not to close the calenar when
 // in single-click mode.
 // cal.dateClicked = (el.navtype == 0);
 cal.dateClicked = false;
 var year = date.getFullYear();
 var mon = date.getMonth();
 function setMonth(m) {
 var day = date.getDate();
 var max = date.getMonthDays(m);
 if (day > max) {
 date.setDate(max);
 }
 date.setMonth(m);
 };
 switch (el.navtype) {
 case 400:
 Calendar.removeClass(el, "hilite");
 var text = Calendar._TT["ABOUT"];
 if (typeof text != "undefined") {
 text += cal.showsTime ? Calendar._TT["ABOUT_TIME"] : "";
 } else {
 // FIXME: this should be removed as soon as lang files get updated!
 text = "Help and about box text is not translated into this language.\n" +
 "If you know this language and you feel generous please update\n" +
 "the corresponding file in \"lang\" subdir to match calendar-en.js\n" +
 "and send it back to <mihai_bazon@yahoo.com> to get it into the distribution ;-)\n\n" +
 "Thank you!\n" +
 "http://dynarch.com/mishoo/calendar.epl\n";
 }
 alert(text);
 return;
 case -2:
 if (year > cal.minYear) {
 date.setFullYear(year - 1);
 }
 break;
 case -1:
 if (mon > 0) {
 setMonth(mon - 1);
 } else if (year-- > cal.minYear) {
 date.setFullYear(year);
 setMonth(11);
 }
 break;
 case 1:
 if (mon < 11) {
 setMonth(mon + 1);
 } else if (year < cal.maxYear) {
 date.setFullYear(year + 1);
 setMonth(0);
 }
 break;
 case 2:
 if (year < cal.maxYear) {
 date.setFullYear(year + 1);
 }
 break;
 case 100:
 cal.setFirstDayOfWeek(el.fdow);
 return;
 case 50:
 var range = el._range;
 var current = el.innerHTML;
 for (var i = range.length; --i >= 0;)
 if (range[i] == current)
 break;
 if (ev && ev.shiftKey) {
 if (--i < 0)
 i = range.length - 1;
 } else if ( ++i >= range.length )
 i = 0;
 var newval = range[i];
 el.innerHTML = newval;
 cal.onUpdateTime();
 return;
 case 0:
 // TODAY will bring us here
 if ((typeof cal.getDateStatus == "function") &&
 cal.getDateStatus(date, date.getFullYear(), date.getMonth(), date.getDate())) {
 return false;
 }
 break;
 }
 if (!date.equalsTo(cal.date)) {
 cal.setDate(date);
 newdate = true;
 } else if (el.navtype == 0)
 newdate = closing = true;
 }
 if (newdate) {
 ev && cal.callHandler();
 }
 if (closing) {
 Calendar.removeClass(el, "hilite");
 ev && cal.callCloseHandler();
 }
};

// END: CALENDAR STATIC FUNCTIONS

// BEGIN: CALENDAR OBJECT FUNCTIONS

/**
 * This function creates the calendar inside the given parent. If _par is
 * null than it creates a popup calendar inside the BODY element. If _par is
 * an element, be it BODY, then it creates a non-popup calendar (still
 * hidden). Some properties need to be set before calling this function.
 */
Calendar.prototype.create = function (_par) {
 var parent = null;
 if (! _par) {
 // default parent is the document body, in which case we create
 // a popup calendar.
 parent = document.getElementsByTagName("body")[0];
 this.isPopup = true;
 } else {
 parent = _par;
 this.isPopup = false;
 }
 this.date = this.dateStr ? new Date(this.dateStr) : new Date();

 var table = Calendar.createElement("table");
 this.table = table;
 table.cellSpacing = 0;
 table.cellPadding = 0;
 table.calendar = this;
 Calendar.addEvent(table, "mousedown", Calendar.tableMouseDown);

 var div = Calendar.createElement("div");
 this.element = div;
 div.className = "calendar";
 if (this.isPopup) {
 div.style.position = "absolute";
 div.style.display = "none";
 }
 div.appendChild(table);

 var thead = Calendar.createElement("thead", table);
 var cell = null;
 var row = null;

 var cal = this;
 var hh = function (text, cs, navtype) {
 cell = Calendar.createElement("td", row);
 cell.colSpan = cs;
 cell.className = "button";
 if (navtype != 0 && Math.abs(navtype) <= 2)
 cell.className += " nav";
 Calendar._add_evs(cell);
 cell.calendar = cal;
 cell.navtype = navtype;
 cell.innerHTML = "<div unselectable='on'>" + text + "</div>";
 return cell;
 };

 row = Calendar.createElement("tr", thead);
 var title_length = 6;
 (this.isPopup) && --title_length;
 (this.weekNumbers) && ++title_length;

 hh("?", 1, 400).ttip = Calendar._TT["INFO"];
 this.title = hh("", title_length, 300);
 this.title.className = "title";
 if (this.isPopup) {
 this.title.ttip = Calendar._TT["DRAG_TO_MOVE"];
 this.title.style.cursor = "move";
 hh("&#x00d7;", 1, 200).ttip = Calendar._TT["CLOSE"];
 }

 row = Calendar.createElement("tr", thead);
 row.className = "headrow";

 this._nav_py = hh("&#x00ab;", 1, -2);
 this._nav_py.ttip = Calendar._TT["PREV_YEAR"];

 this._nav_pm = hh("&#x2039;", 1, -1);
 this._nav_pm.ttip = Calendar._TT["PREV_MONTH"];

 this._nav_now = hh(Calendar._TT["TODAY"], this.weekNumbers ? 4 : 3, 0);
 this._nav_now.ttip = Calendar._TT["GO_TODAY"];

 this._nav_nm = hh("&#x203a;", 1, 1);
 this._nav_nm.ttip = Calendar._TT["NEXT_MONTH"];

 this._nav_ny = hh("&#x00bb;", 1, 2);
 this._nav_ny.ttip = Calendar._TT["NEXT_YEAR"];

 // day names
 row = Calendar.createElement("tr", thead);
 row.className = "daynames";
 if (this.weekNumbers) {
 cell = Calendar.createElement("td", row);
 cell.className = "name wn";
 cell.innerHTML = Calendar._TT["WK"];
 }
 for (var i = 7; i > 0; --i) {
 cell = Calendar.createElement("td", row);
 if (!i) {
 cell.navtype = 100;
 cell.calendar = this;
 Calendar._add_evs(cell);
 }
 }
 this.firstdayname = (this.weekNumbers) ? row.firstChild.nextSibling : row.firstChild;
 this._displayWeekdays();

 var tbody = Calendar.createElement("tbody", table);
 this.tbody = tbody;

 for (i = 6; i > 0; --i) {
 row = Calendar.createElement("tr", tbody);
 if (this.weekNumbers) {
 cell = Calendar.createElement("td", row);
 }
 for (var j = 7; j > 0; --j) {
 cell = Calendar.createElement("td", row);
 cell.calendar = this;
 Calendar._add_evs(cell);
 }
 }

 if (this.showsTime) {
 row = Calendar.createElement("tr", tbody);
 row.className = "time";

 cell = Calendar.createElement("td", row);
 cell.className = "time";
 cell.colSpan = 2;
 cell.innerHTML = Calendar._TT["TIME"] || "&nbsp;";

 cell = Calendar.createElement("td", row);
 cell.className = "time";
 cell.colSpan = this.weekNumbers ? 4 : 3;

 (function(){
 function makeTimePart(className, init, range_start, range_end) {
 var part = Calendar.createElement("span", cell);
 part.className = className;
 part.innerHTML = init;
 part.calendar = cal;
 part.ttip = Calendar._TT["TIME_PART"];
 part.navtype = 50;
 part._range = [];
 if (typeof range_start != "number")
 part._range = range_start;
 else {
 for (var i = range_start; i <= range_end; ++i) {
 var txt;
 if (i < 10 && range_end >= 10) txt = '0' + i;
 else txt = '' + i;
 part._range[part._range.length] = txt;
 }
 }
 Calendar._add_evs(part);
 return part;
 };
 var hrs = cal.date.getHours();
 var mins = cal.date.getMinutes();
 var t12 = !cal.time24;
 var pm = (hrs > 12);
 if (t12 && pm) hrs -= 12;
 var H = makeTimePart("hour", hrs, t12 ? 1 : 0, t12 ? 12 : 23);
 var span = Calendar.createElement("span", cell);
 span.innerHTML = ":";
 span.className = "colon";
 var M = makeTimePart("minute", mins, 0, 59);
 var AP = null;
 cell = Calendar.createElement("td", row);
 cell.className = "time";
 cell.colSpan = 2;
 if (t12)
 AP = makeTimePart("ampm", pm ? "pm" : "am", ["am", "pm"]);
 else
 cell.innerHTML = "&nbsp;";

 cal.onSetTime = function() {
 var pm, hrs = this.date.getHours(),
 mins = this.date.getMinutes();
 if (t12) {
 pm = (hrs >= 12);
 if (pm) hrs -= 12;
 if (hrs == 0) hrs = 12;
 AP.innerHTML = pm ? "pm" : "am";
 }
 H.innerHTML = (hrs < 10) ? ("0" + hrs) : hrs;
 M.innerHTML = (mins < 10) ? ("0" + mins) : mins;
 };

 cal.onUpdateTime = function() {
 var date = this.date;
 var h = parseInt(H.innerHTML, 10);
 if (t12) {
 if (/pm/i.test(AP.innerHTML) && h < 12)
 h += 12;
 else if (/am/i.test(AP.innerHTML) && h == 12)
 h = 0;
 }
 var d = date.getDate();
 var m = date.getMonth();
 var y = date.getFullYear();
 date.setHours(h);
 date.setMinutes(parseInt(M.innerHTML, 10));
 date.setFullYear(y);
 date.setMonth(m);
 date.setDate(d);
 this.dateClicked = false;
 this.callHandler();
 };
 })();
 } else {
 this.onSetTime = this.onUpdateTime = function() {};
 }

 var tfoot = Calendar.createElement("tfoot", table);

 row = Calendar.createElement("tr", tfoot);
 row.className = "footrow";

 cell = hh(Calendar._TT["SEL_DATE"], this.weekNumbers ? 8 : 7, 300);
 cell.className = "ttip";
 if (this.isPopup) {
 cell.ttip = Calendar._TT["DRAG_TO_MOVE"];
 cell.style.cursor = "move";
 }
 this.tooltips = cell;

 div = Calendar.createElement("div", this.element);
 this.monthsCombo = div;
 div.className = "combo";
 for (i = 0; i < Calendar._MN.length; ++i) {
 var mn = Calendar.createElement("div");
 mn.className = Calendar.is_ie ? "label-IEfix" : "label";
 mn.month = i;
 mn.innerHTML = Calendar._SMN[i];
 div.appendChild(mn);
 }

 div = Calendar.createElement("div", this.element);
 this.yearsCombo = div;
 div.className = "combo";
 for (i = 12; i > 0; --i) {
 var yr = Calendar.createElement("div");
 yr.className = Calendar.is_ie ? "label-IEfix" : "label";
 div.appendChild(yr);
 }

 this._init(this.firstDayOfWeek, this.date);
 parent.appendChild(this.element);
};

/** keyboard navigation, only for popup calendars */
Calendar._keyEvent = function(ev) {
 var cal = window._dynarch_popupCalendar;
 if (!cal || cal.multiple)
 return false;
 (Calendar.is_ie) && (ev = window.event);
 var act = (Calendar.is_ie || ev.type == "keypress"),
 K = ev.keyCode;
 if (ev.ctrlKey) {
 switch (K) {
 case 37: // KEY left
 act && Calendar.cellClick(cal._nav_pm);
 break;
 case 38: // KEY up
 act && Calendar.cellClick(cal._nav_py);
 break;
 case 39: // KEY right
 act && Calendar.cellClick(cal._nav_nm);
 break;
 case 40: // KEY down
 act && Calendar.cellClick(cal._nav_ny);
 break;
 default:
 return false;
 }
 } else switch (K) {
 case 32: // KEY space (now)
 Calendar.cellClick(cal._nav_now);
 break;
 case 27: // KEY esc
 act && cal.callCloseHandler();
 break;
 case 37: // KEY left
 case 38: // KEY up
 case 39: // KEY right
 case 40: // KEY down
 if (act) {
 var prev, x, y, ne, el, step;
 prev = K == 37 || K == 38;
 step = (K == 37 || K == 39) ? 1 : 7;
 function setVars() {
 el = cal.currentDateEl;
 var p = el.pos;
 x = p & 15;
 y = p >> 4;
 ne = cal.ar_days[y][x];
 };setVars();
 function prevMonth() {
 var date = new Date(cal.date);
 date.setDate(date.getDate() - step);
 cal.setDate(date);
 };
 function nextMonth() {
 var date = new Date(cal.date);
 date.setDate(date.getDate() + step);
 cal.setDate(date);
 };
 while (1) {
 switch (K) {
 case 37: // KEY left
 if (--x >= 0)
 ne = cal.ar_days[y][x];
 else {
 x = 6;
 K = 38;
 continue;
 }
 break;
 case 38: // KEY up
 if (--y >= 0)
 ne = cal.ar_days[y][x];
 else {
 prevMonth();
 setVars();
 }
 break;
 case 39: // KEY right
 if (++x < 7)
 ne = cal.ar_days[y][x];
 else {
 x = 0;
 K = 40;
 continue;
 }
 break;
 case 40: // KEY down
 if (++y < cal.ar_days.length)
 ne = cal.ar_days[y][x];
 else {
 nextMonth();
 setVars();
 }
 break;
 }
 break;
 }
 if (ne) {
 if (!ne.disabled)
 Calendar.cellClick(ne);
 else if (prev)
 prevMonth();
 else
 nextMonth();
 }
 }
 break;
 case 13: // KEY enter
 if (act)
 Calendar.cellClick(cal.currentDateEl, ev);
 break;
 default:
 return false;
 }
 return Calendar.stopEvent(ev);
};

/**
 * (RE)Initializes the calendar to the given date and firstDayOfWeek
 */
Calendar.prototype._init = function (firstDayOfWeek, date) {
 var today = new Date(),
 TY = today.getFullYear(),
 TM = today.getMonth(),
 TD = today.getDate();
 this.table.style.visibility = "hidden";
 var year = date.getFullYear();
 if (year < this.minYear) {
 year = this.minYear;
 date.setFullYear(year);
 } else if (year > this.maxYear) {
 year = this.maxYear;
 date.setFullYear(year);
 }
 this.firstDayOfWeek = firstDayOfWeek;
 this.date = new Date(date);
 var month = date.getMonth();
 var mday = date.getDate();
 var no_days = date.getMonthDays();

 // calendar voodoo for computing the first day that would actually be
 // displayed in the calendar, even if it's from the previous month.
 // WARNING: this is magic. ;-)
 date.setDate(1);
 var day1 = (date.getDay() - this.firstDayOfWeek) % 7;
 if (day1 < 0)
 day1 += 7;
 date.setDate(-day1);
 date.setDate(date.getDate() + 1);

 var row = this.tbody.firstChild;
 var MN = Calendar._SMN[month];
 var ar_days = this.ar_days = new Array();
 var weekend = Calendar._TT["WEEKEND"];
 var dates = this.multiple ? (this.datesCells = {}) : null;
 for (var i = 0; i < 6; ++i, row = row.nextSibling) {
 var cell = row.firstChild;
 if (this.weekNumbers) {
 cell.className = "day wn";
 cell.innerHTML = date.getWeekNumber();
 cell = cell.nextSibling;
 }
 row.className = "daysrow";
 var hasdays = false, iday, dpos = ar_days[i] = [];
 for (var j = 0; j < 7; ++j, cell = cell.nextSibling, date.setDate(iday + 1)) {
 iday = date.getDate();
 var wday = date.getDay();
 cell.className = "day";
 cell.pos = i << 4 | j;
 dpos[j] = cell;
 var current_month = (date.getMonth() == month);
 if (!current_month) {
 if (this.showsOtherMonths) {
 cell.className += " othermonth";
 cell.otherMonth = true;
 } else {
 cell.className = "emptycell";
 cell.innerHTML = "&nbsp;";
 cell.disabled = true;
 continue;
 }
 } else {
 cell.otherMonth = false;
 hasdays = true;
 }
 cell.disabled = false;
 cell.innerHTML = this.getDateText ? this.getDateText(date, iday) : iday;
 if (dates)
 dates[date.print("%Y%m%d")] = cell;
 if (this.getDateStatus) {
 var status = this.getDateStatus(date, year, month, iday);
 if (this.getDateToolTip) {
 var toolTip = this.getDateToolTip(date, year, month, iday);
 if (toolTip)
 cell.title = toolTip;
 }
 if (status === true) {
 cell.className += " disabled";
 cell.disabled = true;
 } else {
 if (/disabled/i.test(status))
 cell.disabled = true;
 cell.className += " " + status;
 }
 }
 if (!cell.disabled) {
 cell.caldate = new Date(date);
 cell.ttip = "_";
 if (!this.multiple && current_month
 && iday == mday && this.hiliteToday) {
 cell.className += " selected";
 this.currentDateEl = cell;
 }
 if (date.getFullYear() == TY &&
 date.getMonth() == TM &&
 iday == TD) {
 cell.className += " today";
 cell.ttip += Calendar._TT["PART_TODAY"];
 }
 if (weekend.indexOf(wday.toString()) != -1)
 cell.className += cell.otherMonth ? " oweekend" : " weekend";
 }
 }
 if (!(hasdays || this.showsOtherMonths))
 row.className = "emptyrow";
 }
 this.title.innerHTML = Calendar._MN[month] + ", " + year;
 this.onSetTime();
 this.table.style.visibility = "visible";
 this._initMultipleDates();
 // PROFILE
 // this.tooltips.innerHTML = "Generated in " + ((new Date()) - today) + " ms";
};

Calendar.prototype._initMultipleDates = function() {
 if (this.multiple) {
 for (var i in this.multiple) {
 var cell = this.datesCells[i];
 var d = this.multiple[i];
 if (!d)
 continue;
 if (cell)
 cell.className += " selected";
 }
 }
};

Calendar.prototype._toggleMultipleDate = function(date) {
 if (this.multiple) {
 var ds = date.print("%Y%m%d");
 var cell = this.datesCells[ds];
 if (cell) {
 var d = this.multiple[ds];
 if (!d) {
 Calendar.addClass(cell, "selected");
 this.multiple[ds] = date;
 } else {
 Calendar.removeClass(cell, "selected");
 delete this.multiple[ds];
 }
 }
 }
};

Calendar.prototype.setDateToolTipHandler = function (unaryFunction) {
 this.getDateToolTip = unaryFunction;
};

/**
 * Calls _init function above for going to a certain date (but only if the
 * date is different than the currently selected one).
 */
Calendar.prototype.setDate = function (date) {
 if (!date.equalsTo(this.date)) {
 this._init(this.firstDayOfWeek, date);
 }
};

/**
 * Refreshes the calendar. Useful if the "disabledHandler" function is
 * dynamic, meaning that the list of disabled date can change at runtime.
 * Just * call this function if you think that the list of disabled dates
 * should * change.
 */
Calendar.prototype.refresh = function () {
 this._init(this.firstDayOfWeek, this.date);
};

/** Modifies the "firstDayOfWeek" parameter (pass 0 for Synday, 1 for Monday, etc.). */
Calendar.prototype.setFirstDayOfWeek = function (firstDayOfWeek) {
 this._init(firstDayOfWeek, this.date);
 this._displayWeekdays();
};

/**
 * Allows customization of what dates are enabled. The "unaryFunction"
 * parameter must be a function object that receives the date (as a JS Date
 * object) and returns a boolean value. If the returned value is true then
 * the passed date will be marked as disabled.
 */
Calendar.prototype.setDateStatusHandler = Calendar.prototype.setDisabledHandler = function (unaryFunction) {
 this.getDateStatus = unaryFunction;
};

/** Customization of allowed year range for the calendar. */
Calendar.prototype.setRange = function (a, z) {
 this.minYear = a;
 this.maxYear = z;
};

/** Calls the first user handler (selectedHandler). */
Calendar.prototype.callHandler = function () {
 if (this.onSelected) {
 this.onSelected(this, this.date.print(this.dateFormat));
 }
};

/** Calls the second user handler (closeHandler). */
Calendar.prototype.callCloseHandler = function () {
 if (this.onClose) {
 this.onClose(this);
 }
 this.hideShowCovered();
};

/** Removes the calendar object from the DOM tree and destroys it. */
Calendar.prototype.destroy = function () {
 var el = this.element.parentNode;
 el.removeChild(this.element);
 Calendar._C = null;
 window._dynarch_popupCalendar = null;
};

/**
 * Moves the calendar element to a different section in the DOM tree (changes
 * its parent).
 */
Calendar.prototype.reparent = function (new_parent) {
 var el = this.element;
 el.parentNode.removeChild(el);
 new_parent.appendChild(el);
};

// This gets called when the user presses a mouse button anywhere in the
// document, if the calendar is shown. If the click was outside the open
// calendar this function closes it.
Calendar._checkCalendar = function(ev) {
 var calendar = window._dynarch_popupCalendar;
 if (!calendar) {
 return false;
 }
 var el = Calendar.is_ie ? Calendar.getElement(ev) : Calendar.getTargetElement(ev);
 for (; el != null && el != calendar.element; el = el.parentNode);
 if (el == null) {
 // calls closeHandler which should hide the calendar.
 window._dynarch_popupCalendar.callCloseHandler();
 return Calendar.stopEvent(ev);
 }
};

/** Shows the calendar. */
Calendar.prototype.show = function () {
 var rows = this.table.getElementsByTagName("tr");
 for (var i = rows.length; i > 0;) {
 var row = rows[--i];
 Calendar.removeClass(row, "rowhilite");
 var cells = row.getElementsByTagName("td");
 for (var j = cells.length; j > 0;) {
 var cell = cells[--j];
 Calendar.removeClass(cell, "hilite");
 Calendar.removeClass(cell, "active");
 }
 }
 this.element.style.display = "block";
 this.hidden = false;
 if (this.isPopup) {
 window._dynarch_popupCalendar = this;
 Calendar.addEvent(document, "keydown", Calendar._keyEvent);
 Calendar.addEvent(document, "keypress", Calendar._keyEvent);
 Calendar.addEvent(document, "mousedown", Calendar._checkCalendar);
 }
 this.hideShowCovered();
};

/**
 * Hides the calendar. Also removes any "hilite" from the class of any TD
 * element.
 */
Calendar.prototype.hide = function () {
 if (this.isPopup) {
 Calendar.removeEvent(document, "keydown", Calendar._keyEvent);
 Calendar.removeEvent(document, "keypress", Calendar._keyEvent);
 Calendar.removeEvent(document, "mousedown", Calendar._checkCalendar);
 }
 this.element.style.display = "none";
 this.hidden = true;
 this.hideShowCovered();
};

/**
 * Shows the calendar at a given absolute position (beware that, depending on
 * the calendar element style -- position property -- this might be relative
 * to the parent's containing rectangle).
 */
Calendar.prototype.showAt = function (x, y) {
 var s = this.element.style;
 s.left = x + "px";
 s.top = y + "px";
 this.show();
};

/** Shows the calendar near a given element. */
Calendar.prototype.showAtElement = function (el, opts) {
 var self = this;
 var p = Calendar.getAbsolutePos(el);
 if (!opts || typeof opts != "string") {
 this.showAt(p.x, p.y + el.offsetHeight);
 return true;
 }
 function fixPosition(box) {
 if (box.x < 0)
 box.x = 0;
 if (box.y < 0)
 box.y = 0;
 var cp = document.createElement("div");
 var s = cp.style;
 s.position = "absolute";
 s.right = s.bottom = s.width = s.height = "0px";
 document.body.appendChild(cp);
 var br = Calendar.getAbsolutePos(cp);
 document.body.removeChild(cp);
 if (Calendar.is_ie) {
 br.y += document.body.scrollTop;
 br.x += document.body.scrollLeft;
 } else {
 br.y += window.scrollY;
 br.x += window.scrollX;
 }
 var tmp = box.x + box.width - br.x;
 if (tmp > 0) box.x -= tmp;
 tmp = box.y + box.height - br.y;
 if (tmp > 0) box.y -= tmp;
 };
 this.element.style.display = "block";
 Calendar.continuation_for_the_fucking_khtml_browser = function() {
 var w = self.element.offsetWidth;
 var h = self.element.offsetHeight;
 self.element.style.display = "none";
 var valign = opts.substr(0, 1);
 var halign = "l";
 if (opts.length > 1) {
 halign = opts.substr(1, 1);
 }
 // vertical alignment
 switch (valign) {
 case "T": p.y -= h; break;
 case "B": p.y += el.offsetHeight; break;
 case "C": p.y += (el.offsetHeight - h) / 2; break;
 case "t": p.y += el.offsetHeight - h; break;
 case "b": break; // already there
 }
 // horizontal alignment
 switch (halign) {
 case "L": p.x -= w; break;
 case "R": p.x += el.offsetWidth; break;
 case "C": p.x += (el.offsetWidth - w) / 2; break;
 case "l": p.x += el.offsetWidth - w; break;
 case "r": break; // already there
 }
 p.width = w;
 p.height = h + 40;
 self.monthsCombo.style.display = "none";
 fixPosition(p);
 self.showAt(p.x, p.y);
 };
 if (Calendar.is_khtml)
 setTimeout("Calendar.continuation_for_the_fucking_khtml_browser()", 10);
 else
 Calendar.continuation_for_the_fucking_khtml_browser();
};

/** Customizes the date format. */
Calendar.prototype.setDateFormat = function (str) {
 this.dateFormat = str;
};

/** Customizes the tooltip date format. */
Calendar.prototype.setTtDateFormat = function (str) {
 this.ttDateFormat = str;
};

/**
 * Tries to identify the date represented in a string. If successful it also
 * calls this.setDate which moves the calendar to the given date.
 */
Calendar.prototype.parseDate = function(str, fmt) {
 if (!fmt)
 fmt = this.dateFormat;
 this.setDate(Date.parseDate(str, fmt));
};

Calendar.prototype.hideShowCovered = function () {
 if (!Calendar.is_ie && !Calendar.is_opera)
 return;
 function getVisib(obj){
 var value = obj.style.visibility;
 if (!value) {
 if (document.defaultView && typeof (document.defaultView.getComputedStyle) == "function") { // Gecko, W3C
 if (!Calendar.is_khtml)
 value = document.defaultView.
 getComputedStyle(obj, "").getPropertyValue("visibility");
 else
 value = '';
 } else if (obj.currentStyle) { // IE
 value = obj.currentStyle.visibility;
 } else
 value = '';
 }
 return value;
 };

 var tags = new Array("applet", "iframe", "select");
 var el = this.element;

 var p = Calendar.getAbsolutePos(el);
 var EX1 = p.x;
 var EX2 = el.offsetWidth + EX1;
 var EY1 = p.y;
 var EY2 = el.offsetHeight + EY1;

 for (var k = tags.length; k > 0; ) {
 var ar = document.getElementsByTagName(tags[--k]);
 var cc = null;

 for (var i = ar.length; i > 0;) {
 cc = ar[--i];

 p = Calendar.getAbsolutePos(cc);
 var CX1 = p.x;
 var CX2 = cc.offsetWidth + CX1;
 var CY1 = p.y;
 var CY2 = cc.offsetHeight + CY1;

 if (this.hidden || (CX1 > EX2) || (CX2 < EX1) || (CY1 > EY2) || (CY2 < EY1)) {
 if (!cc.__msh_save_visibility) {
 cc.__msh_save_visibility = getVisib(cc);
 }
 cc.style.visibility = cc.__msh_save_visibility;
 } else {
 if (!cc.__msh_save_visibility) {
 cc.__msh_save_visibility = getVisib(cc);
 }
 cc.style.visibility = "hidden";
 }
 }
 }
};

/** Internal function; it displays the bar with the names of the weekday. */
Calendar.prototype._displayWeekdays = function () {
 var fdow = this.firstDayOfWeek;
 var cell = this.firstdayname;
 var weekend = Calendar._TT["WEEKEND"];
 for (var i = 0; i < 7; ++i) {
 cell.className = "day name";
 var realday = (i + fdow) % 7;
 if (i) {
 cell.ttip = Calendar._TT["DAY_FIRST"].replace("%s", Calendar._DN[realday]);
 cell.navtype = 100;
 cell.calendar = this;
 cell.fdow = realday;
 Calendar._add_evs(cell);
 }
 if (weekend.indexOf(realday.toString()) != -1) {
 Calendar.addClass(cell, "weekend");
 }
 cell.innerHTML = Calendar._SDN[(i + fdow) % 7];
 cell = cell.nextSibling;
 }
};

/** Internal function. Hides all combo boxes that might be displayed. */
Calendar.prototype._hideCombos = function () {
 this.monthsCombo.style.display = "none";
 this.yearsCombo.style.display = "none";
};

/** Internal function. Starts dragging the element. */
Calendar.prototype._dragStart = function (ev) {
 if (this.dragging) {
 return;
 }
 this.dragging = true;
 var posX;
 var posY;
 if (Calendar.is_ie) {
 posY = window.event.clientY + document.body.scrollTop;
 posX = window.event.clientX + document.body.scrollLeft;
 } else {
 posY = ev.clientY + window.scrollY;
 posX = ev.clientX + window.scrollX;
 }
 var st = this.element.style;
 this.xOffs = posX - parseInt(st.left);
 this.yOffs = posY - parseInt(st.top);
 with (Calendar) {
 addEvent(document, "mousemove", calDragIt);
 addEvent(document, "mouseup", calDragEnd);
 }
};

// BEGIN: DATE OBJECT PATCHES

/** Adds the number of days array to the Date object. */
Date._MD = new Array(31,28,31,30,31,30,31,31,30,31,30,31);

/** Constants used for time computations */
Date.SECOND = 1000 /* milliseconds */;
Date.MINUTE = 60 * Date.SECOND;
Date.HOUR = 60 * Date.MINUTE;
Date.DAY = 24 * Date.HOUR;
Date.WEEK = 7 * Date.DAY;

Date.parseDate = function(str, fmt) {
 var today = new Date();
 var y = 0;
 var m = -1;
 var d = 0;

 // translate date into en_US, because split() cannot parse non-latin stuff
 var a = str;
 var i;
 for (i = 0; i < Calendar._MN.length; i++) {
 a = a.replace(Calendar._MN[i], enUS.m.wide[i]);
 }
 for (i = 0; i < Calendar._SMN.length; i++) {
 a = a.replace(Calendar._SMN[i], enUS.m.abbr[i]);
 }
 a = a.replace(Calendar._am, 'am');
 a = a.replace(Calendar._am.toLowerCase(), 'am');
 a = a.replace(Calendar._pm, 'pm');
 a = a.replace(Calendar._pm.toLowerCase(), 'pm');

 a = a.split(/\W+/);

 var b = fmt.match(/%./g);
 var i = 0, j = 0;
 var hr = 0;
 var min = 0;
 for (i = 0; i < a.length; ++i) {
 if (!a[i])
 continue;
 switch (b[i]) {
 case "%d":
 case "%e":
 d = parseInt(a[i], 10);
 break;

 case "%m":
 m = parseInt(a[i], 10) - 1;
 break;

 case "%Y":
 case "%y":
 y = parseInt(a[i], 10);
 (y < 100) && (y += (y > 29) ? 1900 : 2000);
 break;

 case "%b":
 for (j = 0; j < 12; ++j) {
 if (enUS.m.abbr[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { m = j; break; }
 }
 break;

 case "%B":
 for (j = 0; j < 12; ++j) {
 if (enUS.m.wide[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { m = j; break; }
 }
 break;

 case "%H":
 case "%I":
 case "%k":
 case "%l":
 hr = parseInt(a[i], 10);
 break;

 case "%P":
 case "%p":
 if (/pm/i.test(a[i]) && hr < 12)
 hr += 12;
 else if (/am/i.test(a[i]) && hr >= 12)
 hr -= 12;
 break;

 case "%M":
 min = parseInt(a[i], 10);
 break;
 }
 }
 if (isNaN(y)) y = today.getFullYear();
 if (isNaN(m)) m = today.getMonth();
 if (isNaN(d)) d = today.getDate();
 if (isNaN(hr)) hr = today.getHours();
 if (isNaN(min)) min = today.getMinutes();
 if (y != 0 && m != -1 && d != 0)
 return new Date(y, m, d, hr, min, 0);
 y = 0; m = -1; d = 0;
 for (i = 0; i < a.length; ++i) {
 if (a[i].search(/[a-zA-Z]+/) != -1) {
 var t = -1;
 for (j = 0; j < 12; ++j) {
 if (Calendar._MN[j].substr(0, a[i].length).toLowerCase() == a[i].toLowerCase()) { t = j; break; }
 }
 if (t != -1) {
 if (m != -1) {
 d = m+1;
 }
 m = t;
 }
 } else if (parseInt(a[i], 10) <= 12 && m == -1) {
 m = a[i]-1;
 } else if (parseInt(a[i], 10) > 31 && y == 0) {
 y = parseInt(a[i], 10);
 (y < 100) && (y += (y > 29) ? 1900 : 2000);
 } else if (d == 0) {
 d = a[i];
 }
 }
 if (y == 0)
 y = today.getFullYear();
 if (m != -1 && d != 0)
 return new Date(y, m, d, hr, min, 0);
 return today;
};

/** Returns the number of days in the current month */
Date.prototype.getMonthDays = function(month) {
 var year = this.getFullYear();
 if (typeof month == "undefined") {
 month = this.getMonth();
 }
 if (((0 == (year%4)) && ( (0 != (year%100)) || (0 == (year%400)))) && month == 1) {
 return 29;
 } else {
 return Date._MD[month];
 }
};

/** Returns the number of day in the year. */
Date.prototype.getDayOfYear = function() {
 var now = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
 var then = new Date(this.getFullYear(), 0, 0, 0, 0, 0);
 var time = now - then;
 return Math.floor(time / Date.DAY);
};

/** Returns the number of the week in year, as defined in ISO 8601. */
Date.prototype.getWeekNumber = function() {
 var d = new Date(this.getFullYear(), this.getMonth(), this.getDate(), 0, 0, 0);
 var DoW = d.getDay();
 d.setDate(d.getDate() - (DoW + 6) % 7 + 3); // Nearest Thu
 var ms = d.valueOf(); // GMT
 d.setMonth(0);
 d.setDate(4); // Thu in Week 1
 return Math.round((ms - d.valueOf()) / (7 * 864e5)) + 1;
};

/** Checks date and time equality */
Date.prototype.equalsTo = function(date) {
 return ((this.getFullYear() == date.getFullYear()) &&
 (this.getMonth() == date.getMonth()) &&
 (this.getDate() == date.getDate()) &&
 (this.getHours() == date.getHours()) &&
 (this.getMinutes() == date.getMinutes()));
};

/** Set only the year, month, date parts (keep existing time) */
Date.prototype.setDateOnly = function(date) {
 var tmp = new Date(date);
 this.setDate(1);
 this.setFullYear(tmp.getFullYear());
 this.setMonth(tmp.getMonth());
 this.setDate(tmp.getDate());
};

/** Prints the date in a string according to the given format. */
Date.prototype.print = function (str) {
 var m = this.getMonth();
 var d = this.getDate();
 var y = this.getFullYear();
 var wn = this.getWeekNumber();
 var w = this.getDay();
 var s = {};
 var hr = this.getHours();
 var pm = (hr >= 12);
 var ir = (pm) ? (hr - 12) : hr;
 var dy = this.getDayOfYear();
 if (ir == 0)
 ir = 12;
 var min = this.getMinutes();
 var sec = this.getSeconds();
 s["%a"] = Calendar._SDN[w]; // abbreviated weekday name [FIXME: I18N]
 s["%A"] = Calendar._DN[w]; // full weekday name
 s["%b"] = Calendar._SMN[m]; // abbreviated month name [FIXME: I18N]
 s["%B"] = Calendar._MN[m]; // full month name
 // FIXME: %c : preferred date and time representation for the current locale
 s["%C"] = 1 + Math.floor(y / 100); // the century number
 s["%d"] = (d < 10) ? ("0" + d) : d; // the day of the month (range 01 to 31)
 s["%e"] = d; // the day of the month (range 1 to 31)
 // FIXME: %D : american date style: %m/%d/%y
 // FIXME: %E, %F, %G, %g, %h (man strftime)
 s["%H"] = (hr < 10) ? ("0" + hr) : hr; // hour, range 00 to 23 (24h format)
 s["%I"] = (ir < 10) ? ("0" + ir) : ir; // hour, range 01 to 12 (12h format)
 s["%j"] = (dy < 100) ? ((dy < 10) ? ("00" + dy) : ("0" + dy)) : dy; // day of the year (range 001 to 366)
 s["%k"] = hr; // hour, range 0 to 23 (24h format)
 s["%l"] = ir; // hour, range 1 to 12 (12h format)
 s["%m"] = (m < 9) ? ("0" + (1+m)) : (1+m); // month, range 01 to 12
 s["%M"] = (min < 10) ? ("0" + min) : min; // minute, range 00 to 59
 s["%n"] = "\n"; // a newline character
 s["%p"] = pm ? Calendar._pm.toUpperCase() : Calendar._am.toUpperCase();
 s["%P"] = pm ? Calendar._pm.toLowerCase() : Calendar._am.toLowerCase();
 // FIXME: %r : the time in am/pm notation %I:%M:%S %p
 // FIXME: %R : the time in 24-hour notation %H:%M
 s["%s"] = Math.floor(this.getTime() / 1000);
 s["%S"] = (sec < 10) ? ("0" + sec) : sec; // seconds, range 00 to 59
 s["%t"] = "\t"; // a tab character
 // FIXME: %T : the time in 24-hour notation (%H:%M:%S)
 s["%U"] = s["%W"] = s["%V"] = (wn < 10) ? ("0" + wn) : wn;
 s["%u"] = w + 1; // the day of the week (range 1 to 7, 1 = MON)
 s["%w"] = w; // the day of the week (range 0 to 6, 0 = SUN)
 // FIXME: %x : preferred date representation for the current locale without the time
 // FIXME: %X : preferred time representation for the current locale without the date
 s["%y"] = ('' + y).substr(2, 2); // year without the century (range 00 to 99)
 s["%Y"] = y; // year with the century
 s["%%"] = "%"; // a literal '%' character

 var re = /%./g;
 if (!Calendar.is_ie5 && !Calendar.is_khtml)
 return str.replace(re, function (par) { return s[par] || par; });

 var a = str.match(re);
 for (var i = 0; i < a.length; i++) {
 var tmp = s[a[i]];
 if (tmp) {
 re = new RegExp(a[i], 'g');
 str = str.replace(re, tmp);
 }
 }

 return str;
};

Date.prototype.__msh_oldSetFullYear = Date.prototype.setFullYear;
Date.prototype.setFullYear = function(y) {
 var d = new Date(this);
 d.__msh_oldSetFullYear(y);
 if (d.getMonth() != this.getMonth())
 this.setDate(28);
 this.__msh_oldSetFullYear(y);
};

// END: DATE OBJECT PATCHES


// global object that remembers the calendar
window._dynarch_popupCalendar = null;