/**
 * javascript by Miracle 2.3
 * copyright (c) eWorld - 2004-2012
 */


 

var Prototype ={
 Version: '1.5.0_rc2 ',
 BrowserFeatures:{
 XPath: !!document.evaluate
},
 
 ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
 emptyFunction: function(){},
 K: function(x){return x}
}

 var Class ={
 create: function(){
 return function(){
 this.initialize.apply(this, arguments);
}
}
}

var Abstract = new Object();

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 === undefined) return 'undefined';
 if (object === null) return 'null';
 return object.inspect ? object.inspect() : object.toString();
}catch (e){
 if (e instanceof RangeError) return '...';
 throw e;
}
},
 
 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);
}
});

Function.prototype.bind = function(){
 var __method = this, args = $A(arguments), object = args.shift();
 return function(){
 return __method.apply(object, args.concat($A(arguments)));
}
}

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

Object.extend(Number.prototype,{
 toColorPart: function(){
 var digits = this.toString(16);
 if (this < 16) return '0' + digits;
 return digits;
},

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

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


var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype ={
 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);
},
 
 stop: function(){
 if (!this.timer) return;
 clearInterval(this.timer);
 this.timer = null;
},

 onTimerEvent: function(){
 if (!this.currentlyExecuting){
 try{
 this.currentlyExecuting = true;
 this.callback(this);
}finally{
 this.currentlyExecuting = false;
}
}
}
}
 String.interpret = function(value){
 return value == null ? '' : String(value);
}

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 = count === undefined ? 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 this;
},
 
 truncate: function(length, truncation){
 length = length || 30;
 truncation = truncation === undefined ? '...' : truncation;
 return this.length > length ? 
 this.slice(0, length - truncation.length) + truncation : 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 div = document.createElement('div');
 var text = document.createTextNode(this);
 div.appendChild(text);
 return div.innerHTML;
},

 unescapeHTML: function(){
 var div = document.createElement('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 name = decodeURIComponent(pair[0]);
 var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;

 if (hash[name] !== undefined){
 if (hash[name].constructor != Array)
 hash[name] = [hash[name]];
 if (value) hash[name].push(value);
}
 else hash[name] = 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);
},

 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.replace(/\\/g, '\\\\');
 if (useDoubleQuotes)
 return '"' + escapedString.replace(/"/g, '\\"') + '"';
 else
 return "'" + escapedString.replace(/'/g, '\\\'') + "'";
}
});

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

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

var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype ={
 initialize: function(template, pattern){
 this.template = template.toString();
 this.pattern = pattern || Template.Pattern;
},
 
 evaluate: function(object){
 return this.template.gsub(this.pattern, function(match){
 var before = match[1];
 if (before == '\\') return match[2];
 return before + String.interpret(object[match[3]]);
});
}
}
 

 var $break = new Object();
var $continue = new Object();

var Enumerable ={
 each: function(iterator){
 var index = 0;
 try{
 this._each(function(value){
 try{
 iterator(value, index++);
}catch (e){
 if (e != $continue) throw e;
}
});
}catch (e){
 if (e != $break) throw e;
}
 return this;
},
 
 eachSlice: function(number, iterator){
 var index = -number, slices = [], array = this.toArray();
 while ((index += number) < array.length)
 slices.push(array.slice(index, index+number));
 return slices.map(iterator);
},
 
 all: function(iterator){
 var result = true;
 this.each(function(value, index){
 result = result && !!(iterator || Prototype.K)(value, index);
 if (!result) throw $break;
});
 return result;
},
 
 any: function(iterator){
 var result = false;
 this.each(function(value, index){
 if (result = !!(iterator || Prototype.K)(value, index)) 
 throw $break;
});
 return result;
},
 
 collect: function(iterator){
 var results = [];
 this.each(function(value, index){
 results.push((iterator || Prototype.K)(value, index));
});
 return results;
},
 
 detect: function(iterator){
 var result;
 this.each(function(value, index){
 if (iterator(value, index)){
 result = value;
 throw $break;
}
});
 return result;
},
 
 findAll: function(iterator){
 var results = [];
 this.each(function(value, index){
 if (iterator(value, index))
 results.push(value);
});
 return results;
},
 
 grep: function(pattern, iterator){
 var results = [];
 this.each(function(value, index){
 var stringValue = value.toString();
 if (stringValue.match(pattern))
 results.push((iterator || Prototype.K)(value, index));
})
 return results;
},
 
 include: function(object){
 var found = false;
 this.each(function(value){
 if (value == object){
 found = true;
 throw $break;
}
});
 return found;
},
 
 inGroupsOf: function(number, fillWith){
 fillWith = fillWith === undefined ? null : fillWith;
 return this.eachSlice(number, function(slice){
 while(slice.length < number) slice.push(fillWith);
 return slice;
});
},
 
 inject: function(memo, iterator){
 this.each(function(value, index){
 memo = iterator(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){
 var result;
 this.each(function(value, index){
 value = (iterator || Prototype.K)(value, index);
 if (result == undefined || value >= result)
 result = value;
});
 return result;
},
 
 min: function(iterator){
 var result;
 this.each(function(value, index){
 value = (iterator || Prototype.K)(value, index);
 if (result == undefined || value < result)
 result = value;
});
 return result;
},
 
 partition: function(iterator){
 var trues = [], falses = [];
 this.each(function(value, index){
 ((iterator || Prototype.K)(value, index) ? 
 trues : falses).push(value);
});
 return [trues, falses];
},
 
 pluck: function(property){
 var results = [];
 this.each(function(value, index){
 results.push(value[property]);
});
 return results;
},
 
 reject: function(iterator){
 var results = [];
 this.each(function(value, index){
 if (!iterator(value, index))
 results.push(value);
});
 return results;
},
 
 sortBy: function(iterator){
 return this.map(function(value, index){
 return{value: value, criteria: iterator(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 (typeof args.last() == 'function')
 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,
 member: Enumerable.include,
 entries: Enumerable.toArray
});
 var $A = Array.from = function(iterable){
 if (!iterable) return [];
 if (iterable.toArray){
 return iterable.toArray();
}else{
 var results = [];
 for (var i = 0, length = iterable.length; i < length; i++)
 results.push(iterable[i]);
 return results;
}
}

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(value && value.constructor == Array ?
 value.flatten() : [value]);
});
},
 
 without: function(){
 var values = $A(arguments);
 return this.select(function(value){
 return !values.include(value);
});
},
 
 indexOf: function(object){
 for (var i = 0, length = this.length; i < length; i++)
 if (this[i] == object) return i;
 return -1;
},
 
 reverse: function(inline){
 return (inline !== false ? this : this.toArray())._reverse();
},
 
 reduce: function(){
 return this.length > 1 ? this : this[0];
},
 
 uniq: function(){
 return this.inject([], function(array, value){
 return array.include(value) ? array : array.concat([value]);
});
},
 
 clone: function(){
 return [].concat(this);
},
 
 size: function(){
 return this.length;
},
 
 inspect: function(){
 return '[' + this.map(Object.inspect).join(', ') + ']';
}
});

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

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

if(window.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(arguments[i].constructor == Array){
 for(var j = 0, arrayLength = arguments[i].length; j < arrayLength; j++) 
 array.push(arguments[i][j]);
}else{
 array.push(arguments[i]);
}
}
 return array;
}
}
 var Hash ={
 _each: function(iterator){
 for (var key in this){
 var value = this[key];
 if (typeof value == 'function') continue;
 
 var pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
}
},
 
 keys: function(){
 return this.pluck('key');
},
 
 values: function(){
 return this.pluck('value');
},
 
 merge: function(hash){
 return $H(hash).inject(this, function(mergedHash, pair){
 mergedHash[pair.key] = pair.value;
 return mergedHash;
});
},
 
 toQueryString: function(){
 return this.map(function(pair){
 if (!pair.key) return null;
 
 if (pair.value && pair.value.constructor == Array){
 pair.value = pair.value.compact();
 
 if (pair.value.length < 2){
 pair.value = pair.value.reduce();
}else{
 var key = encodeURIComponent(pair.key);
 return pair.value.map(function(value){
 return key + '=' + encodeURIComponent(value);
}).join('&');
}
}
 
 if (pair.value == undefined) pair[1] = '';
 return pair.map(encodeURIComponent).join('=');
}).join('&');
},
 
 inspect: function(){
 return '#<Hash:{' + this.map(function(pair){
 return pair.map(Object.inspect).join(': ');
}).join(', ') + '}>';
}
}

function $H(object){
 var hash = Object.extend({}, object ||{});
 Object.extend(hash, Enumerable);
 Object.extend(hash, Hash);
 return hash;
}
 ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype,{
 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 (typeof responder[callback] == 'function'){
 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 = function(){};
Ajax.Base.prototype ={
 setOptions: function(options){
 this.options ={
 method: 'post',
 asynchronous: true,
 contentType: 'application/x-www-form-urlencoded',
 encoding: 'UTF-8',
 parameters: ''
}
 Object.extend(this.options, options ||{});
 
 this.options.method = this.options.method.toLowerCase();

 this.options.parameters = $H(typeof this.options.parameters == 'string' ?
 this.options.parameters.toQueryParams() : this.options.parameters);
}
}

Ajax.Request = Class.create();
Ajax.Request.Events = 
 ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(),{
 _complete: false,
 
 initialize: function(url, options){
 this.transport = Ajax.getTransport();
 this.setOptions(options);
 this.request(url);
},

 request: function(url){
 var params = this.options.parameters;
 if (params.any()) params['_'] = '';

 if (!['get', 'post'].include(this.options.method)){

 params['_method'] = this.options.method;
 this.options.method = 'post';
}
 
 this.url = url;

 if (this.options.method == 'get' && params.any())
 this.url += (this.url.indexOf('?') >= 0 ? '&' : '?') + 
 params.toQueryString();
 
 try{
 Ajax.Responders.dispatch('onCreate', this, this.transport);
 
 this.transport.open(this.options.method.toUpperCase(), this.url, 
 this.options.asynchronous);

 if (this.options.asynchronous)
 setTimeout(function(){this.respondToReadyState(1)}.bind(this), 10);
 
 this.transport.onreadystatechange = this.onStateChange.bind(this);
 this.setRequestHeaders();

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

 
 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.options.method == 'post'){
 headers['Content-type'] = this.options.contentType +
 (this.options.encoding ? '; charset=' + this.options.encoding : '');
 
 
 if (this.transport.overrideMimeType &&
 (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
 headers['Connection'] = 'close';
}

 if (typeof this.options.requestHeaders == 'object'){
 var extras = this.options.requestHeaders;

 if (typeof extras.push == 'function')
 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(){
 return !this.transport.status
 || (this.transport.status >= 200 && this.transport.status < 300);
},

 respondToReadyState: function(readyState){
 var state = Ajax.Request.Events[readyState];
 var transport = this.transport, json = this.evalJSON();

 if (state == 'Complete'){
 try{
 this._complete = true;
 (this.options['on' + this.transport.status]
 || this.options['on' + (this.success() ? 'Success' : 'Failure')]
 || Prototype.emptyFunction)(transport, json);
}catch (e){
 this.dispatchException(e);
}
 
 if ((this.getHeader('Content-type') || 'text/javascript').strip().
 match(/^(text|application)\/(x-)?(java|ecma)script(;.*)?$/i))
 this.evalResponse();
}

 try{
 (this.options['on' + state] || Prototype.emptyFunction)(transport, json);
 Ajax.Responders.dispatch('on' + state, this, transport, json);
}catch (e){
 this.dispatchException(e);
}
 
 if (state == 'Complete'){

 this.transport.onreadystatechange = Prototype.emptyFunction;
}
},
 
 getHeader: function(name){
 try{
 return this.transport.getResponseHeader(name);
}catch (e){return null}
},
 
 evalJSON: function(){
 try{
 var json = this.getHeader('X-JSON');
 return json ? eval('(' + json + ')') : null;
}catch (e){return null}
},
 
 evalResponse: function(){
 try{
 return eval(this.transport.responseText);
}catch (e){
 this.dispatchException(e);
}
},

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

Ajax.Updater = Class.create();

Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype),{
 initialize: function(container, url, options){
 this.container ={
 success: (container.success || container),
 failure: (container.failure || (container.success ? null : container))
}
 
 this.transport = Ajax.getTransport();
 this.setOptions(options);

 var onComplete = this.options.onComplete || Prototype.emptyFunction;
 this.options.onComplete = (function(transport, param){
 this.updateContent();
 onComplete(transport, param);
}).bind(this);

 this.request(url);
},

 updateContent: function(){
 var receiver = this.container[this.success() ? 'success' : 'failure'];
 var response = this.transport.responseText;
 
 if (!this.options.evalScripts) response = response.stripScripts();
 
 if (receiver = $(receiver)){
 if (this.options.insertion)
 new this.options.insertion(receiver, response);
 else
 receiver.update(response);
}
 
 if (this.success()){
 if (this.onComplete)
 setTimeout(this.onComplete.bind(this), 10);
}
}
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(),{
 initialize: function(container, url, options){
 this.setOptions(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(request){
 if (this.options.decay){
 this.decay = (request.responseText == this.lastText ? 
 this.decay * this.options.decay : 1);

 this.lastText = request.responseText;
}
 this.timer = setTimeout(this.onTimerEvent.bind(this), 
 this.decay * this.frequency * 1000);
},

 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 (typeof element == 'string')
 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(query.snapshotItem(i));
 return results;
}
}

document.getElementsByClassName = function(className, parentElement){
 if (Prototype.BrowserFeatures.XPath){
 var q = "./" + "/" + "*" + "[contains(concat(' ', @class, ' '), ' " + className + " ')]";
 return document._getElementsByXPath(q, parentElement);
}else{
 var children = ($(parentElement) || document.body).getElementsByTagName('*');
 var elements = [], child;
 for (var i = 0, length = children.length; i < length; i++){
 child = children[i];
 if (Element.hasClassName(child, className))
 elements.push(Element.extend(child));
}
 return elements;
}
}


if (!window.Element)
 var Element = new Object();

Element.extend = function(element){
 if (!element || _nativeExtensions || element.nodeType == 3) return element;
 
 if (!element._extended && element.tagName && element != window){
 var methods = Object.clone(Element.Methods), cache = Element.extend.cache;
 
 if (element.tagName == 'FORM')
 Object.extend(methods, Form.Methods);
 if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName)) 
 Object.extend(methods, Form.Element.Methods);
 
 Object.extend(methods, Element.Methods.Simulated);
 
 for (var property in methods){
 var value = methods[property];
 if (typeof value == 'function' && !(property in element))
 element[property] = cache.findOrStore(value);
}
}
 
 element._extended = true;
 return element;
}

Element.extend.cache ={
 findOrStore: function(value){
 return this[value] = this[value] || function(){
 return value.apply(null, [this].concat($A(arguments)));
}
}
}

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).style.display = 'none';
 return element;
},
 
 show: function(element){
 $(element).style.display = '';
 return element;
},

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

 update: function(element, html){
 html = typeof html == 'undefined' ? '' : html.toString();
 $(element).innerHTML = html.stripScripts();
 setTimeout(function(){html.evalScripts()}, 10);
 return element;
},
 
 replace: function(element, html){
 element = $(element);
 if (element.outerHTML){
 element.outerHTML = html.stripScripts();
}else{
 var range = element.ownerDocument.createRange();
 range.selectNodeContents(element);
 element.parentNode.replaceChild(
 range.createContextualFragment(html.stripScripts()), element);
}
 setTimeout(function(){html.evalScripts()}, 10);
 return element;
},
 
 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 $A($(element).getElementsByTagName('*'));
},
 
 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 (typeof selector == 'string')
 selector = new Selector(selector);
 return selector.match($(element));
},
 
 up: function(element, expression, index){
 return Selector.findElement($(element).ancestors(), expression, index);
},
 
 down: function(element, expression, index){
 return Selector.findElement($(element).descendants(), expression, index);
},

 previous: function(element, expression, index){
 return Selector.findElement($(element).previousSiblings(), expression, index);
},
 
 next: function(element, expression, index){
 return Selector.findElement($(element).nextSiblings(), expression, index);
},
 
 getElementsBySelector: function(){
 var args = $A(arguments), element = $(args.shift());
 return Selector.findChildElements(element, args);
},
 
 getElementsByClassName: function(element, className){
 return document.getElementsByClassName(className, element);
},
 
 readAttribute: function(element, name){
 return $(element).getAttribute(name);
},
 
 getHeight: function(element){
 return $(element).offsetHeight; 
},
 
 classNames: function(element){
 return new Element.ClassNames(element);
},

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

 addClassName: function(element, className){
 if (!(element = $(element))) return;
 Element.classNames(element).add(className);
 return element;
},

 removeClassName: function(element, className){
 if (!(element = $(element))) return;
 Element.classNames(element).remove(className);
 return element;
},
 
 toggleClassName: function(element, className){
 if (!(element = $(element))) return;
 Element.classNames(element)[element.hasClassName(className) ? 'remove' : 'add'](className);
 return element;
},
 
 observe: function(){
 Event.observe.apply(Event, arguments);
 return $A(arguments).first();
},
 
 stopObserving: function(){
 Event.stopObserving.apply(Event, arguments);
 return $A(arguments).first();
},

 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.match(/^\s*$/);
},
 
 childOf: function(element, ancestor){
 element = $(element), ancestor = $(ancestor);
 while (element = element.parentNode)
 if (element == ancestor) return true;
 return false;
},
 
 scrollTo: function(element){
 element = $(element);
 var pos = Position.cumulativeOffset(element);
 window.scrollTo(pos[0], pos[1]);
 return element;
},
 
 getStyle: function(element, style){
 element = $(element);
 var camelizedStyle = (style == 'float' ? 
 (typeof element.style.styleFloat != 'undefined' ? 'styleFloat' : 'cssFloat') : style).camelize();
 var value = element.style[camelizedStyle];
 if (!value){
 if (document.defaultView && document.defaultView.getComputedStyle){
 var css = document.defaultView.getComputedStyle(element, null);
 value = css ? css[camelizedStyle] : null;
}else if (element.currentStyle){
 value = element.currentStyle[camelizedStyle];
}
}
 
 if((value == 'auto') && ['width','height'].include(style) && (element.getStyle('display') != 'none'))
 value = element['offset'+style.capitalize()] + 'px';
 
 if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
 if (Element.getStyle(element, 'position') == 'static') value = 'auto';
 if(style == 'opacity'){
 if(value) return parseFloat(value);
 if(value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/)) 
 if(value[1]) return parseFloat(value[1]) / 100; 
 return 1.0; 
}
 return value == 'auto' ? null : value;
},
 
 setStyle: function(element, style){
 element = $(element);
 for (var name in style){
 var value = style[name];
 if(name == 'opacity'){
 if (value == 1){
 value = (/Gecko/.test(navigator.userAgent) &&
 !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
 if(/MSIE/.test(navigator.userAgent) && !window.opera)
 element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'');
}else{
 if(value < 0.00001) value = 0; 
 if(/MSIE/.test(navigator.userAgent) && !window.opera)
 element.style.filter = element.getStyle('filter').replace(/alpha\([^\)]*\)/gi,'') +
 'alpha(opacity='+value*100+')';
}
}else if(name == 'float') name = (typeof element.style.styleFloat != 'undefined') ? 'styleFloat' : 'cssFloat';
 element.style[name.camelize()] = value;
}
 return element;
},
 
 getDimensions: function(element){
 element = $(element);
 if (Element.getStyle(element, 'display') != 'none')
 return{width: element.offsetWidth, height: element.offsetHeight};


 var els = element.style;
 var originalVisibility = els.visibility;
 var originalPosition = els.position;
 els.visibility = 'hidden';
 els.position = 'absolute';
 els.display = '';
 var originalWidth = element.clientWidth;
 var originalHeight = element.clientHeight;
 els.display = 'none';
 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';


 if (window.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.style.overflow || 'auto';
 if ((Element.getStyle(element, 'overflow') || 'visible') != '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;
}
}

Element.Methods.Simulated ={
 hasAttribute: function(element, attribute){
 return $(element).getAttributeNode(attribute).specified;
}
}

if(document.all){
 Element.Methods.update = function(element, html){
 element = $(element);
 html = typeof html == 'undefined' ? '' : html.toString();
 var tagName = element.tagName.toUpperCase(); 
 if (['THEAD','TBODY','TR','TD'].include(tagName)){
 var div = document.createElement('div');
 switch (tagName){
 case 'THEAD':
 case 'TBODY':
 div.innerHTML = '<table><tbody>' + html.stripScripts() + '</tbody></table>';
 depth = 2;
 break;
 case 'TR':
 div.innerHTML = '<table><tbody><tr>' + html.stripScripts() + '</tr></tbody></table>';
 depth = 3;
 break;
 case 'TD':
 div.innerHTML = '<table><tbody><tr><td>' + html.stripScripts() + '</td></tr></tbody></table>';
 depth = 4;
}
 $A(element.childNodes).each(function(node){
 element.removeChild(node)
});
 depth.times(function(){div = div.firstChild});
 
 $A(div.childNodes).each(
 function(node){element.appendChild(node)});
}else{
 element.innerHTML = html.stripScripts();
}
 setTimeout(function(){html.evalScripts()}, 10);
 return element;
}
}

Object.extend(Element, Element.Methods);

var _nativeExtensions = false;

if(/Konqueror|Safari|KHTML/.test(navigator.userAgent))
 ['', 'Form', 'Input', 'TextArea', 'Select'].each(function(tag){
 var className = 'HTML' + tag + 'Element';
 if(window[className]) return;
 var klass = window[className] ={};
 klass.prototype = document.createElement(tag ? tag.toLowerCase() : 'div').__proto__;
});

Element.addMethods = function(methods){
 Object.extend(Element.Methods, methods ||{});
 
 function copy(methods, destination, onlyIfAbsent){
 onlyIfAbsent = onlyIfAbsent || false;
 var cache = Element.extend.cache;
 for (var property in methods){
 var value = methods[property];
 if (!onlyIfAbsent || !(property in destination))
 destination[property] = cache.findOrStore(value);
}
}
 
 if (typeof HTMLElement != 'undefined'){
 copy(Element.Methods, HTMLElement.prototype);
 copy(Element.Methods.Simulated, HTMLElement.prototype, true);
 copy(Form.Methods, HTMLFormElement.prototype);
 [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass){
 copy(Form.Element.Methods, klass.prototype);
});
 _nativeExtensions = true;
}
}

var Toggle = new Object();
Toggle.display = Element.toggle;


Abstract.Insertion = function(adjacency){
 this.adjacency = adjacency;
}

Abstract.Insertion.prototype ={
 initialize: function(element, content){
 this.element = $(element);
 this.content = content.stripScripts();
 
 if (this.adjacency && this.element.insertAdjacentHTML){
 try{
 this.element.insertAdjacentHTML(this.adjacency, this.content);
}catch (e){
 var tagName = this.element.tagName.toUpperCase();
 if (['TBODY', 'TR'].include(tagName)){
 this.insertContent(this.contentFromAnonymousTable());
}else{
 throw e;
}
}
}else{
 this.range = this.element.ownerDocument.createRange();
 if (this.initializeRange) this.initializeRange();
 this.insertContent([this.range.createContextualFragment(this.content)]);
}

 setTimeout(function(){content.evalScripts()}, 10); 
},
 
 contentFromAnonymousTable: function(){
 var div = document.createElement('div');
 div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
 return $A(div.childNodes[0].childNodes[0].childNodes);
}
}

var Insertion = new Object();

Insertion.Before = Class.create();
Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'),{
 initializeRange: function(){
 this.range.setStartBefore(this.element);
},
 
 insertContent: function(fragments){
 fragments.each((function(fragment){
 this.element.parentNode.insertBefore(fragment, this.element);
}).bind(this));
}
});

Insertion.Top = Class.create();
Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'),{
 initializeRange: function(){
 this.range.selectNodeContents(this.element);
 this.range.collapse(true);
},
 
 insertContent: function(fragments){
 fragments.reverse(false).each((function(fragment){
 this.element.insertBefore(fragment, this.element.firstChild);
}).bind(this));
}
});

Insertion.Bottom = Class.create();
Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'),{
 initializeRange: function(){
 this.range.selectNodeContents(this.element);
 this.range.collapse(this.element);
},
 
 insertContent: function(fragments){
 fragments.each((function(fragment){
 this.element.appendChild(fragment);
}).bind(this));
}
});

Insertion.After = Class.create();
Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'),{
 initializeRange: function(){
 this.range.setStartAfter(this.element);
},
 
 insertContent: function(fragments){
 fragments.each((function(fragment){
 this.element.parentNode.insertBefore(fragment, 
 this.element.nextSibling);
}).bind(this));
}
});


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);
 var Selector = Class.create();
Selector.prototype ={
 initialize: function(expression){
 this.params ={classNames: []};
 this.expression = expression.toString().strip();
 this.parseExpression();
 this.compileMatcher();
},

 parseExpression: function(){
 function abort(message){throw 'Parse error in selector: ' + message;}

 if (this.expression == '') abort('empty expression');

 var params = this.params, expr = this.expression, match, modifier, clause, rest;
 while (match = expr.match(/^(.*)\[([a-z0-9_:-]+?)(?:([~\|!]?=)(?:"([^"]*)"|([^\]\s]*)))?\]$/i)){
 params.attributes = params.attributes || [];
 params.attributes.push({name: match[2], operator: match[3], value: match[4] || match[5] || ''});
 expr = match[1];
}

 if (expr == '*') return this.params.wildcard = true;
 
 while (match = expr.match(/^([^a-z0-9_-])?([a-z0-9_-]+)(.*)/i)){
 modifier = match[1], clause = match[2], rest = match[3];
 switch (modifier){
 case '#': params.id = clause; break;
 case '.': params.classNames.push(clause); break;
 case '':
 case undefined: params.tagName = clause.toUpperCase(); break;
 default: abort(expr.inspect());
}
 expr = rest;
}
 
 if (expr.length > 0) abort(expr.inspect());
},

 buildMatchExpression: function(){
 var params = this.params, conditions = [], clause;

 if (params.wildcard)
 conditions.push('true');
 if (clause = params.id)
 conditions.push('element.getAttribute("id") == ' + clause.inspect());
 if (clause = params.tagName)
 conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
 if ((clause = params.classNames).length > 0)
 for (var i = 0, length = clause.length; i < length; i++)
 conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
 if (clause = params.attributes){
 clause.each(function(attribute){
 var value = 'element.getAttribute(' + attribute.name.inspect() + ')';
 var splitValueBy = function(delimiter){
 return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
}
 
 switch (attribute.operator){
 case '=': conditions.push(value + ' == ' + attribute.value.inspect()); break;
 case '~=': conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
 case '|=': conditions.push(
 splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
 ); break;
 case '!=': conditions.push(value + ' != ' + attribute.value.inspect()); break;
 case '':
 case undefined: conditions.push(value + ' != null'); break;
 default: throw 'Unknown operator ' + attribute.operator + ' in selector';
}
});
}

 return conditions.join(' && ');
},

 compileMatcher: function(){
 this.match = new Function('element', 'if (!element.tagName) return false; \
 return ' + this.buildMatchExpression());
},

 findElements: function(scope){
 var element;

 if (element = $(this.params.id))
 if (this.match(element))
 if (!scope || Element.childOf(element, scope))
 return [element];

 scope = (scope || document).getElementsByTagName(this.params.tagName || '*');

 var results = [];
 for (var i = 0, length = scope.length; i < length; i++)
 if (this.match(element = scope[i]))
 results.push(Element.extend(element));

 return results;
},

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

Object.extend(Selector,{
 matchElements: function(elements, expression){
 var selector = new Selector(expression);
 return elements.select(selector.match.bind(selector)).map(Element.extend);
},
 
 findElement: function(elements, expression, index){
 if (typeof expression == 'number') index = expression, expression = false;
 return Selector.matchElements(elements, expression || '*')[index || 0];
},
 
 findChildElements: function(element, expressions){
 return expressions.map(function(expression){
 return expression.strip().split(/\s+/).inject([null], function(results, expr){
 var selector = new Selector(expr);
 return results.inject([], function(elements, result){
 return elements.concat(selector.findElements(result || element));
});
});
}).flatten();
}
});

function $$(){
 return Selector.findChildElements(document, $A(arguments));
}
 var Form ={
 reset: function(form){
 $(form).reset();
 return form;
},
 
 serializeElements: function(elements){
 return elements.inject([], function(queryComponents, element){
 var queryComponent = Form.Element.serialize(element);
 if (queryComponent) queryComponents.push(queryComponent);
 return queryComponents;
}).join('&');
}
};

Form.Methods ={
 serialize: function(form){
 return Form.serializeElements(Form.getElements(form));
},
 
 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'), matchingInputs = [];
 
 if (!typeName && !name)
 return $A(inputs).map(Element.extend);
 
 for (var i = 0, 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().each(function(element){
 element.blur();
 element.disabled = 'true';
});
 return form;
},

 enable: function(form){
 form = $(form);
 form.getElements().each(function(element){
 element.disabled = '';
});
 return form;
},

 findFirstElement: function(form){
 return $(form).getElements().find(function(element){
 return element.type != 'hidden' && !element.disabled &&
 ['input', 'select', 'textarea'].include(element.tagName.toLowerCase());
});
},

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

Object.extend(Form, Form.Methods);


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) return '';
 var method = element.tagName.toLowerCase();
 var parameter = Form.Element.Serializers[method](element);
 
 if (parameter){
 var key = encodeURIComponent(parameter[0]);
 if (key.length == 0) return;
 
 if (parameter[1].constructor != Array)
 parameter[1] = [parameter[1]];
 
 return parameter[1].map(function(value){
 return key + '=' + encodeURIComponent(value);
}).join('&');
}
},
 
 getValue: function(element){
 element = $(element);
 var method = element.tagName.toLowerCase();
 var parameter = Form.Element.Serializers[method](element);
 
 if (parameter)
 return parameter[1];
},

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

 present: function(element){
 return $(element).value != '';
},
 
 activate: function(element){
 element = $(element);
 element.focus();
 if (element.select && ( element.tagName.toLowerCase() != 'input' ||
 !['button', 'reset', 'submit'].include(element.type) ) )
 element.select();
 return element;
},
 
 disable: function(element){
 element = $(element);
 element.disabled = true;
 return element;
},
 
 enable: function(element){
 element = $(element);
 element.blur();
 element.disabled = false;
 return element;
}
}

Object.extend(Form.Element, Form.Element.Methods);
var Field = Form.Element;


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

 inputSelector: function(element){
 if (element.checked)
 return [element.name, element.value];
},

 textarea: function(element){
 return [element.name, element.value];
},
 
 select: function(element){
 return Form.Element.Serializers[element.type == 'select-one' ? 
 'selectOne' : 'selectMany'](element);
},
 
 selectOne: function(element){
 var value = '', opt, index = element.selectedIndex;
 if (index >= 0){
 opt = Element.extend(element.options[index]);

 value = opt.hasAttribute('value') ? opt.value : opt.text;
}
 return [element.name, value];
},
 
 selectMany: function(element){
 var value = [];
 for (var i = 0, length = element.length; i < length; i++){
 var opt = Element.extend(element.options[i]);
 if (opt.selected)

 value.push(opt.hasAttribute('value') ? opt.value : opt.text);
}
 return [element.name, value];
}
}


var $F = Form.Element.getValue;


Abstract.TimedObserver = function(){}
Abstract.TimedObserver.prototype ={
 initialize: function(element, frequency, callback){
 this.frequency = frequency;
 this.element = $(element);
 this.callback = callback;
 
 this.lastValue = this.getValue();
 this.registerCallback();
},
 
 registerCallback: function(){
 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},
 
 onTimerEvent: function(){
 var value = this.getValue();
 var changed = ('string' == typeof this.lastValue && 'string' == typeof value
 ? this.lastValue != value : String(this.lastValue) != String(value));
 if (changed){
 this.callback(this.element, value);
 this.lastValue = value;
}
}
}

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

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


Abstract.EventObserver = function(){}
Abstract.EventObserver.prototype ={
 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.bind(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();
Form.Element.EventObserver.prototype = Object.extend(new Abstract.EventObserver(),{
 getValue: function(){
 return Form.Element.getValue(this.element);
}
});

Form.EventObserver = Class.create();
Form.EventObserver.prototype = Object.extend(new Abstract.EventObserver(),{
 getValue: function(){
 return Form.serialize(this.element);
}
});

 if (!window.Event){
 var Event = new Object();
}

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,

 element: function(event){
 return event.target || event.srcElement;
},

 isLeftClick: function(event){
 return (((event.which) && (event.which == 1)) ||
 ((event.button) && (event.button == 1)));
},

 pointerX: function(event){
 return event.pageX || (event.clientX + 
 (document.documentElement.scrollLeft || document.body.scrollLeft));
},

 pointerY: function(event){
 return event.pageY || (event.clientY + 
 (document.documentElement.scrollTop || document.body.scrollTop));
},

 stop: function(event){
 if (event.preventDefault){
 event.preventDefault(); 
 event.stopPropagation(); 
}else{
 event.returnValue = false;
 event.cancelBubble = true;
}
},


 findElement: function(event, tagName){
 var element = Event.element(event);
 while (element.parentNode && (!element.tagName ||
 (element.tagName.toUpperCase() != tagName.toUpperCase())))
 element = element.parentNode;
 return element;
},

 observers: false,
 
 _observeAndCache: function(element, name, observer, useCapture){
 if (!this.observers) this.observers = [];
 if (element.addEventListener){
 this.observers.push([element, name, observer, useCapture]);
 element.addEventListener(name, observer, useCapture);
}else if (element.attachEvent){
 this.observers.push([element, name, observer, useCapture]);
 element.attachEvent('on' + name, observer);
}
},
 
 unloadCache: function(){
 if (!Event.observers) return;
 for (var i = 0, length = Event.observers.length; i < length; i++){
 Event.stopObserving.apply(this, Event.observers[i]);
 Event.observers[i][0] = null;
}
 Event.observers = false;
},

 observe: function(element, name, observer, useCapture){
 element = $(element);
 useCapture = useCapture || false;
 
 if (name == 'keypress' &&
 (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
 || element.attachEvent))
 name = 'keydown';
 
 Event._observeAndCache(element, name, observer, useCapture);
},

 stopObserving: function(element, name, observer, useCapture){
 element = $(element);
 useCapture = useCapture || false;
 
 if (name == 'keypress' &&
 (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
 || element.detachEvent))
 name = 'keydown';
 
 if (element.removeEventListener){
 element.removeEventListener(name, observer, useCapture);
}else if (element.detachEvent){
 try{
 element.detachEvent('on' + name, observer); 
}catch (e){}
}
}
});

if (navigator.appVersion.match(/\bMSIE\b/))
 Event.observe(window, 'unload', Event.unloadCache, false);
 var Position ={



 includeScrollOffsets: false, 


 prepare: function(){
 this.deltaX = window.pageXOffset 
 || document.documentElement.scrollLeft 
 || document.body.scrollLeft 
 || 0;
 this.deltaY = window.pageYOffset 
 || document.documentElement.scrollTop 
 || document.body.scrollTop 
 || 0;
},

 realOffset: function(element){
 var valueT = 0, valueL = 0;
 do{
 valueT += element.scrollTop || 0;
 valueL += element.scrollLeft || 0; 
 element = element.parentNode;
}while (element);
 return [valueL, valueT];
},

 cumulativeOffset: function(element){
 var valueT = 0, valueL = 0;
 do{
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 element = element.offsetParent;
}while (element);
 return [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=='BODY') break;
 var p = Element.getStyle(element, 'position');
 if (p == 'relative' || p == 'absolute') break;
}
}while (element);
 return [valueL, valueT];
},
 
 offsetParent: 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;
},

 within: function(element, x, y){
 if (this.includeScrollOffsets)
 return this.withinIncludingScrolloffsets(element, x, y);
 this.xcomp = x;
 this.ycomp = y;
 this.offset = this.cumulativeOffset(element);

 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 = this.realOffset(element);

 this.xcomp = x + offsetcache[0] - this.deltaX;
 this.ycomp = y + offsetcache[1] - this.deltaY;
 this.offset = this.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);
},

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

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

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

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

}while (element = element.offsetParent);

 element = forElement;
 do{
 if (!window.opera || element.tagName=='BODY'){
 valueT -= element.scrollTop || 0;
 valueL -= element.scrollLeft || 0;
}
}while (element = element.parentNode);

 return [valueL, valueT];
},

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

 source = $(source);
 var p = Position.page(source);

 target = $(target);
 var delta = [0, 0];
 var parent = null;


 if (Element.getStyle(target,'position') == 'absolute'){
 parent = Position.offsetParent(target);
 delta = Position.page(parent);
}

 if (parent == document.body){
 delta[0] -= document.body.offsetLeft;
 delta[1] -= document.body.offsetTop; 
}

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

 absolutize: function(element){
 element = $(element);
 if (element.style.position == 'absolute') return;
 Position.prepare();

 var offsets = Position.positionedOffset(element);
 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';;
},

 relativize: function(element){
 element = $(element);
 if (element.style.position == 'relative') return;
 Position.prepare();

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



if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)){
 Position.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 [valueL, valueT];
}
}


 

Element.addMethods();// EventSelectors 































var EventSelectors ={
 version: '1.0_pre',
 cache: [],
 
 start: function(rules){
 this.rules = rules ||{};
 this.timer = new Array();
 this._extendRules();
 this.assign(this.rules);
},
 
 assign: function(rules){
 var observer = null;
 this._unloadCache();
 rules._each(function(rule){
 var selectors = $A(rule.key.split(','));
 selectors.each(function(selector){
 var pair = selector.split(':');
 var event = pair[1];
 $$(pair[0]).each(function(element){
 if(pair[1] == '' || pair.length == 1) return rule.value(element);
 if(event.toLowerCase() == 'loaded'){
 this.timer[pair[0]] = setInterval(this._checkLoaded.bind(this, element, pair[0], rule), 15);
}else{
 observer = function(event){
 var element = Event.element(event);
 if (element.nodeType == 3) // Safari Bug (Fixed in Webkit)
 element = element.parentNode;
 rule.value($(element), event);
}
 this.cache.push([element, event, observer]);
 Event.observe(element, event, observer);
}
}.bind(this));
}.bind(this));
}.bind(this));
},

 _unloadCache: function(){
 if (!this.cache) return;
 for (var i = 0; i < this.cache.length; i++){
 Event.stopObserving.apply(this, this.cache[i]);
 this.cache[i][0] = null;
}
 this.cache = [];
},
 
 _checkLoaded: function(element, timer, rule){
 var node = $(element);
 if(element.tagName != 'undefined'){
 clearInterval(this.timer[timer]);
 rule.value(node);
}
},
 
 _extendRules: function(){
 Object.extend(this.rules,{
 _each: function(iterator){
 for (key in this){
 if(key == '_each') continue; 
 var value = this[key];
 var pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
}
}
});
}
}


























var Scriptaculous ={
 Version: '1.6',
 require: function(libraryName){

 document.write('<script type="text/javascript" src="'+libraryName+'"></script>');
},
 load: function(){
 if((typeof Prototype=='undefined') || 
 (typeof Element == 'undefined') || 
 (typeof Element.Methods=='undefined') ||
 parseFloat(Prototype.Version.split(".")[0] + "." +
 Prototype.Version.split(".")[1]) < 1.5)
 throw("script.aculo.us requires the Prototype JavaScript framework >= 1.5.0");
 
 $A(document.getElementsByTagName("script")).findAll( function(s){
 return (s.src && s.src.match(/scriptaculous\.js(\?.*)?$/))
}).each( function(s){
 var path = s.src.replace(/scriptaculous\.js(\?.*)?$/,'');
 var includes = s.src.match(/\?.*load=([a-z,]*)/);
 (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider').split(',').each(
 function(include){Scriptaculous.require(path+include+'.js')});
});
}
}

Scriptaculous.load();// Copyright (c) 2005 Thomas Fuchs (<a href="http://script.aculo.us">http://script.aculo.us</a>, <a href="http://mir.aculo.us">http://mir.aculo.us</a>)








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(element,{fontSize: (percent/100) + 'em'}); 
 if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
}

Element.getOpacity = function(element){
 var opacity;
 if (opacity = Element.getStyle(element, 'opacity')) 
 return parseFloat(opacity); 
 if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/)) 
 if(opacity[1]) return parseFloat(opacity[1]) / 100; 
 return 1.0; 
}

Element.setOpacity = function(element, value){
 element= $(element); 
 if (value == 1){
 Element.setStyle(element,{opacity: 
 (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 
 0.999999 : null});
 if(/MSIE/.test(navigator.userAgent)) 
 Element.setStyle(element,{filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')}); 
}else{
 if(value < 0.00001) value = 0; 
 Element.setStyle(element,{opacity: value});
 if(/MSIE/.test(navigator.userAgent)) 
 Element.setStyle(element, 
{filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
 'alpha(opacity='+value*100+')'}); 
}
}
 
Element.getInlineOpacity = function(element){
 return $(element).style.opacity || '';
}

Element.childrenWithClassName = function(element, className, findFirst){
 return [$A($(element).getElementsByTagName('*'))[findFirst ? 'detect' : 'select']( function(c){
 return c.className ? Element.hasClassName(c, className) : false;
})].flatten();
}

Element.forceRerendering = function(element){
 try{
 element = $(element);
 var n = document.createTextNode(' ');
 element.appendChild(n);
 element.removeChild(n);
}catch(e){}
};

['setOpacity','getOpacity','getInlineOpacity','forceRerendering','setContentZoom',
 'collectTextNodes','collectTextNodesIgnoreClass','childrenWithClassName'].each( 
 function(f){Element.Methods[f] = Element[f];}
);


Array.prototype.call = function(){
 var args = arguments;
 this.each(function(f){f.apply(this, args)});
}


var Effect ={
 tagifyText: function(element){
 var tagifyStyle = 'position:relative';
 if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
 element = $(element);
 $A(element.childNodes).each( function(child){
 if(child.nodeType==3){
 child.nodeValue.toArray().each( function(character){
 element.insertBefore(
 Builder.node('span',{style: tagifyStyle},
 character == ' ' ? String.fromCharCode(160) : character), 
 child);
});
 Element.remove(child);
}
});
},
 multiple: function(element, effect){
 var elements;
 if(((typeof element == 'object') || 
 (typeof element == 'function')) && 
 (element.length))
 elements = element;
 else
 elements = $(element).childNodes;
 
 var options = Object.extend({
 speed: 0.1,
 delay: 0.0
}, arguments[2] ||{});
 var masterDelay = options.delay;

 $A(elements).each( function(element, index){
 new effect(element, Object.extend(options,{delay: index * options.speed + masterDelay}));
});
},
 PAIRS:{
 'slide': ['SlideDown','SlideUp'],
 'blind': ['BlindDown','BlindUp'],
 'appear': ['Appear','Fade']
},
 toggle: function(element, effect){
 element = $(element);
 effect = (effect || 'appear').toLowerCase();
 var options = Object.extend({
 queue:{position:'end', scope:(element.id || 'global'), limit: 1}
}, arguments[2] ||{});
 Effect[element.visible() ? 
 Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
}
};

var Effect2 = Effect; // deprecated


Effect.Transitions ={}

Effect.Transitions.linear = function(pos){
 return pos;
}
Effect.Transitions.sinoidal = function(pos){
 return (-Math.cos(pos*Math.PI)/2) + 0.5;
}
Effect.Transitions.reverse = function(pos){
 return 1-pos;
}
Effect.Transitions.flicker = function(pos){
 return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
}
Effect.Transitions.wobble = function(pos){
 return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
}
Effect.Transitions.pulse = function(pos){
 return (Math.floor(pos*10) % 2 == 0 ? 
 (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
}
Effect.Transitions.none = function(pos){
 return 0;
}
Effect.Transitions.full = function(pos){
 return 1;
}


Effect.ScopedQueue = Class.create();
Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable),{
 initialize: function(){
 this.effects = [];
 this.interval = null;
},
 _each: function(iterator){
 this.effects._each(iterator);
},
 add: function(effect){
 var timestamp = new Date().getTime();
 
 var position = (typeof effect.options.queue == 'string') ? 
 effect.options.queue : effect.options.queue.position;
 
 switch(position){
 case 'front':

 this.effects.findAll(function(e){return e.state=='idle'}).each( function(e){
 e.startOn += effect.finishOn;
 e.finishOn += effect.finishOn;
});
 break;
 case 'end':

 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), 40);
},
 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();
 this.effects.invoke('loop', timePos);
}
});

Effect.Queues ={
 instances: $H(),
 get: function(queueName){
 if(typeof queueName != 'string') return queueName;
 
 if(!this.instances[queueName])
 this.instances[queueName] = new Effect.ScopedQueue();
 
 return this.instances[queueName];
}
}
Effect.Queue = Effect.Queues.get('global');

Effect.DefaultOptions ={
 transition: Effect.Transitions.sinoidal,
 duration: 1.0, // seconds
 fps: 25.0, // max. 25fps due to Effect.Queue implementation
 sync: false, // true for combining
 from: 0.0,
 to: 1.0,
 delay: 0.0,
 queue: 'parallel'
}

Effect.Base = function(){};
Effect.Base.prototype ={
 position: null,
 start: function(options){
 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.event('beforeStart');
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).add(this);
},
 loop: function(timePos){
 if(timePos >= this.startOn){
 if(timePos >= this.finishOn){
 this.render(1.0);
 this.cancel();
 this.event('beforeFinish');
 if(this.finish) this.finish(); 
 this.event('afterFinish');
 return; 
}
 var pos = (timePos - this.startOn) / (this.finishOn - this.startOn);
 var frame = Math.round(pos * this.options.fps * this.options.duration);
 if(frame > this.currentFrame){
 this.render(pos);
 this.currentFrame = frame;
}
}
},
 render: function(pos){
 if(this.state == 'idle'){
 this.state = 'running';
 this.event('beforeSetup');
 if(this.setup) this.setup();
 this.event('afterSetup');
}
 if(this.state == 'running'){
 if(this.options.transition) pos = this.options.transition(pos);
 pos *= (this.options.to-this.options.from);
 pos += this.options.from;
 this.position = pos;
 this.event('beforeUpdate');
 if(this.update) this.update(pos);
 this.event('afterUpdate');
}
},
 cancel: function(){
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).remove(this);
 this.state = 'finished';
},
 event: function(eventName){
 if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
 if(this.options[eventName]) this.options[eventName](this);
},
 inspect: function(){
 return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
}
}

Effect.Parallel = Class.create();
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype),{
 initialize: function(effects){
 this.effects = effects || [];
 this.start(arguments[1]);
},
 update: function(position){
 this.effects.invoke('render', position);
},
 finish: function(position){
 this.effects.each( function(effect){
 effect.render(1.0);
 effect.cancel();
 effect.event('beforeFinish');
 if(effect.finish) effect.finish(position);
 effect.event('afterFinish');
});
}
});

Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);

 if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
 this.element.setStyle({zoom: 1});
 var options = Object.extend({
 from: 0.0,
 to: 1.0
}, arguments[1] ||{});
 this.start(options);
},
 update: function(position){
 this.element.setOpacity(position);
}
});

Effect.Move = Class.create();
Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);
 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 + 'px',
 top: this.options.y * position + this.originalTop + 'px'
});
}
});

Effect.MoveBy = function(element, toTop, toLeft){
 return new Effect.Move(element, 
 Object.extend({x: toLeft, y: toTop}, arguments[3] ||{}));
};

Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype),{
 initialize: function(element, percent){
 this.element = $(element)
 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','%'].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 + 'px';
 if(this.options.scaleY) d.height = height + 'px';
 if(this.options.scaleFromCenter){
 var topd = (height - this.dims[0])/2;
 var leftd = (width - this.dims[1])/2;
 if(this.elementPositioning == 'absolute'){
 if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
 if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
}else{
 if(this.options.scaleY) d.top = -topd + 'px';
 if(this.options.scaleX) d.left = -leftd + 'px';
}
}
 this.element.setStyle(d);
}
});

Effect.Highlight = Class.create();
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);
 var options = Object.extend({startcolor: '#ffff99'}, arguments[1] ||{});
 this.start(options);
},
 setup: function(){

 if(this.element.getStyle('display')=='none'){this.cancel(); return;}

 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');

 this._base = $R(0,2).map(function(i){return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16)}.bind(this));
 this._delta = $R(0,2).map(function(i){return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i]}.bind(this));
},
 update: function(position){
 this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
 return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart());}.bind(this))});
},
 finish: function(){
 this.element.setStyle(Object.extend(this.oldStyle,{
 backgroundColor: this.options.restorecolor
}));
}
});

Effect.ScrollTo = Class.create();
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);
 this.start(arguments[1] ||{});
},
 setup: function(){
 Position.prepare();
 var offsets = Position.cumulativeOffset(this.element);
 if(this.options.offset) offsets[1] += this.options.offset;
 var max = window.innerHeight ? 
 window.height - window.innerHeight :
 document.body.scrollHeight - 
 (document.documentElement.clientHeight ? 
 document.documentElement.clientHeight : document.body.clientHeight);
 this.scrollStart = Position.deltaY;
 this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
},
 update: function(position){
 Position.prepare();
 window.scrollTo(Position.deltaX, 
 this.scrollStart + (position*this.delta));
}
});


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();
 effect.element.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,

 afterFinishInternal: function(effect){
 effect.element.forceRerendering();
},
 beforeSetup: function(effect){
 effect.element.setOpacity(effect.options.from);
 effect.element.show(); 
}}, arguments[1] ||{});
 return new Effect.Opacity(element,options);
}

Effect.Puff = function(element){
 element = $(element);
 var oldStyle ={opacity: element.getInlineOpacity(), position: element.getStyle('position')};
 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){
 effect.effects[0].element.setStyle({position: 'absolute'});},
 afterFinishInternal: function(effect){
 effect.effects[0].element.hide();
 effect.effects[0].element.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();
 effect.element.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();
 effect.element.setStyle({height: '0px'});
 effect.element.show(); 
}, 
 afterFinishInternal: function(effect){
 effect.element.undoClipping();
}
}, arguments[1] ||{})
 );
}

Effect.SwitchOff = function(element){
 element = $(element);
 var oldOpacity = element.getInlineOpacity();
 return new Effect.Appear(element,{
 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();
 effect.element.makeClipping();
},
 afterFinishInternal: function(effect){
 effect.element.hide();
 effect.element.undoClipping();
 effect.element.undoPositioned();
 effect.element.setStyle({opacity: oldOpacity});
}
})
}
});
}

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();
 effect.effects[0].element.undoPositioned();
 effect.effects[0].element.setStyle(oldStyle);
}
}, arguments[1] ||{}));
}

Effect.Shake = function(element){
 element = $(element);
 var oldStyle ={
 top: element.getStyle('top'),
 left: element.getStyle('left')};
 return new Effect.Move(element, 
{x: 20, y: 0, duration: 0.05, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect){
 effect.element.undoPositioned();
 effect.element.setStyle(oldStyle);
}})}})}})}})}})}});
}

Effect.SlideDown = function(element){
 element = $(element);
 element.cleanWhitespace();

 var oldInnerBottom = $(element.firstChild).getStyle('bottom');
 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.makePositioned();
 effect.element.firstChild.makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping();
 effect.element.setStyle({height: '0px'});
 effect.element.show();},
 afterUpdateInternal: function(effect){
 effect.element.firstChild.setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px'}); 
},
 afterFinishInternal: function(effect){
 effect.element.undoClipping(); 

 if(/MSIE/.test(navigator.userAgent)){
 effect.element.undoPositioned();
 effect.element.firstChild.undoPositioned();
}else{
 effect.element.firstChild.undoPositioned();
 effect.element.undoPositioned();
}
 effect.element.firstChild.setStyle({bottom: oldInnerBottom});}
}, arguments[1] ||{})
 );
}
 
Effect.SlideUp = function(element){
 element = $(element);
 element.cleanWhitespace();
 var oldInnerBottom = $(element.firstChild).getStyle('bottom');
 return new Effect.Scale(element, 0, 
 Object.extend({scaleContent: false, 
 scaleX: false, 
 scaleMode: 'box',
 scaleFrom: 100,
 restoreAfterFinish: true,
 beforeStartInternal: function(effect){
 effect.element.makePositioned();
 effect.element.firstChild.makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping();
 effect.element.show();}, 
 afterUpdateInternal: function(effect){
 effect.element.firstChild.setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px'});},
 afterFinishInternal: function(effect){
 effect.element.hide();
 effect.element.undoClipping();
 effect.element.firstChild.undoPositioned();
 effect.element.undoPositioned();
 effect.element.setStyle({bottom: oldInnerBottom});}
}, arguments[1] ||{})
 );
}

Effect.Squish = function(element){
 return new Effect.Scale(element, window.opera ? 1 : 0, 
{restoreAfterFinish: true,
 beforeSetup: function(effect){
 effect.element.makeClipping(effect.element);}, 
 afterFinishInternal: function(effect){
 effect.element.hide(effect.element); 
 effect.element.undoClipping(effect.element);}
});
}

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();
 effect.element.makeClipping();
 effect.element.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'});
 effect.effects[0].element.show(); 
},
 afterFinishInternal: function(effect){
 effect.effects[0].element.undoClipping();
 effect.effects[0].element.undoPositioned();
 effect.effects[0].element.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();
 effect.effects[0].element.makeClipping();},
 afterFinishInternal: function(effect){
 effect.effects[0].element.hide();
 effect.effects[0].element.undoClipping();
 effect.effects[0].element.undoPositioned();
 effect.effects[0].element.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))};
 reverser.bind(transition);
 return new Effect.Opacity(element, 
 Object.extend(Object.extend({duration: 3.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(element);
 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();
 effect.element.undoClipping(); 
 effect.element.setStyle(oldStyle);
}});
}}, arguments[1] ||{}));
}

Element.Methods.visualEffect = function(element, effect, options){
 s = effect.gsub(/_/, '-').camelize();
 effect_class = s.charAt(0).toUpperCase() + s.substring(1);
 new Effect[effect_class](element, options);
 return $(element);
};// Copyright (c) 2005 Thomas Fuchs (<a href="http://script.aculo.us">http://script.aculo.us</a>, <a href="http://mir.aculo.us">http://mir.aculo.us</a>)

































var Autocompleter ={}
Autocompleter.Base = function(){};
Autocompleter.Base.prototype ={
 baseInitialize: function(element, update, options){
 this.element = $(element); 
 this.update = $(update); 
 this.hasFocus = false; 
 this.changed = false; 
 this.active = false; 
 this.index = 0; 
 this.entryCount = 0;

 if (this.setOptions)
 this.setOptions(options);
 else
 this.options = options ||{};

 this.options.paramName = this.options.paramName || this.element.name;
 this.options.tokens = this.options.tokens || [];
 this.options.frequency = this.options.frequency || 0.4;
 this.options.minChars = this.options.minChars || 1;
 this.options.onShow = this.options.onShow || 
 function(element, update){
 if(!update.style.position || update.style.position=='absolute'){
 update.style.position = 'absolute';
 Position.clone(element, update,{setHeight: false, offsetTop: element.offsetHeight});
}
 Effect.Appear(update,{duration:0.15});
};
 this.options.onHide = this.options.onHide || 
 function(element, update){new Effect.Fade(update,{duration:0.15})};

 if (typeof(this.options.tokens) == 'string') 
 this.options.tokens = new Array(this.options.tokens);

 this.observer = null;
 
 this.element.setAttribute('autocomplete','off');

 Element.hide(this.update);

 Event.observe(this.element, "blur", this.onBlur.bindAsEventListener(this));
 Event.observe(this.element, "keypress", this.onKeyPress.bindAsEventListener(this));
},

 show: function(){
 if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
 if(!this.iefix && 
 (navigator.appVersion.indexOf('MSIE')>0) &&
 (navigator.userAgent.indexOf('Opera')<0) &&
 (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);
 this.iefix.style.zIndex = 1;
 this.update.style.zIndex = 2;
 Element.show(this.iefix);
},

 hide: function(){
 this.stopIndicator();
 if(Element.getStyle(this.update, 'display')!='none') this.options.onHide(this.element, this.update);
 if(this.iefix) Element.hide(this.iefix);
},

 startIndicator: function(){
 if(this.options.indicator) Element.show(this.options.indicator);
},

 stopIndicator: function(){
 if(this.options.indicator) Element.hide(this.options.indicator);
},

 onKeyPress: function(event){
 if(this.active)
 switch(event.keyCode){
 case Event.KEY_TAB:
 case Event.KEY_RETURN:
 this.selectEntry();
 Event.stop(event);
 case Event.KEY_ESC:
 this.hide();
 this.active = false;
 Event.stop(event);
 return;
 case Event.KEY_LEFT:
 case Event.KEY_RIGHT:
 return;
 case Event.KEY_UP:
 this.markPrevious();
 this.render();
 if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
 return;
 case Event.KEY_DOWN:
 this.markNext();
 this.render();
 if(navigator.appVersion.indexOf('AppleWebKit')>0) Event.stop(event);
 return;
}
 else 
 if(event.keyCode==Event.KEY_TAB || event.keyCode==Event.KEY_RETURN || 
 (navigator.appVersion.indexOf('AppleWebKit') > 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){

 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;
},
 
 markNext: function(){
 if(this.index < this.entryCount-1) this.index++
 else this.index = 0;
},
 
 getEntry: function(index){
 return this.update.firstChild.childNodes[index];
},
 
 getCurrentEntry: function(){
 return this.getEntry(this.index);
},
 
 selectEntry: function(){
 this.active = false;
 this.updateElement(this.getCurrentEntry());
},

 updateElement: function(selectedElement){
 if (this.options.updateElement){
 this.options.updateElement(selectedElement);
 return;
}
 var value = '';
 if (this.options.select){
 var nodes = document.getElementsByClassName(this.options.select, selectedElement) || [];
 if(nodes.length>0) value = Element.collectTextNodes(nodes[0], this.options.select);
}else
 value = Element.collectTextNodesIgnoreClass(selectedElement, 'informal');
 
 var lastTokenPos = this.findLastToken();
 if (lastTokenPos != -1){
 var newValue = this.element.value.substr(0, lastTokenPos + 1);
 var whitespace = this.element.value.substr(lastTokenPos + 1).match(/^\s+/);
 if (whitespace)
 newValue += whitespace[0];
 this.element.value = newValue + value;
}else{
 this.element.value = value;
}
 this.element.focus();
 
 if (this.options.afterUpdateElement)
 this.options.afterUpdateElement(this.element, selectedElement);
},

 updateChoices: function(choices){
 if(!this.changed && this.hasFocus){
 this.update.innerHTML = choices;
 Element.cleanWhitespace(this.update);
 Element.cleanWhitespace(this.update.firstChild);

 if(this.update.firstChild && this.update.firstChild.childNodes){
 this.entryCount = 
 this.update.firstChild.childNodes.length;
 for (var i = 0; i < this.entryCount; i++){
 var entry = this.getEntry(i);
 entry.autocompleteIndex = i;
 this.addObservers(entry);
}
}else{
 this.entryCount = 0;
}

 this.stopIndicator();

 this.index = 0;
 this.render();
}
},

 addObservers: function(element){
 Event.observe(element, "mouseover", this.onHover.bindAsEventListener(this));
 Event.observe(element, "click", this.onClick.bindAsEventListener(this));
},

 onObserverEvent: function(){
 this.changed = false; 
 if(this.getToken().length>=this.options.minChars){
 this.startIndicator();
 this.getUpdatedChoices();
}else{
 this.active = false;
 this.hide();
}
},

 getToken: function(){
 var tokenPos = this.findLastToken();
 if (tokenPos != -1)
 var ret = this.element.value.substr(tokenPos + 1).replace(/^\s+/,'').replace(/\s+$/,'');
 else
 var ret = this.element.value;

 return /\n/.test(ret) ? '' : ret;
},

 findLastToken: function(){
 var lastTokenPos = -1;

 for (var i=0; i<this.options.tokens.length; i++){
 var thisTokenPos = this.element.value.lastIndexOf(this.options.tokens[i]);
 if (thisTokenPos > lastTokenPos)
 lastTokenPos = thisTokenPos;
}
 return lastTokenPos;
}
}

Ajax.Autocompleter = Class.create();
Object.extend(Object.extend(Ajax.Autocompleter.prototype, Autocompleter.Base.prototype),{
 initialize: function(element, update, url, options){
 this.baseInitialize(element, update, options);
 this.options.asynchronous = true;
 this.options.onComplete = this.onComplete.bind(this);
 this.options.defaultParams = this.options.parameters || null;
 this.url = url;
},

 getUpdatedChoices: function(){
 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);
}

});



































Autocompleter.Local = Class.create();
Autocompleter.Local.prototype = Object.extend(new Autocompleter.Base(),{
 initialize: function(element, update, array, options){
 this.baseInitialize(element, update, options);
 this.options.array = array;
},

 getUpdatedChoices: function(){
 this.updateChoices(this.options.selector(this));
},

 setOptions: function(options){
 this.options = Object.extend({
 choices: 10,
 partialSearch: true,
 partialChars: 2,
 ignoreCase: true,
 fullSearch: false,
 selector: function(instance){
 var ret = []; // Beginning matches
 var partial = []; // Inside matches
 var entry = instance.getToken();
 var count = 0;

 for (var i = 0; i < instance.options.array.length && 
 ret.length < instance.options.choices ; i++){

 var elem = instance.options.array[i];
 var foundPos = instance.options.ignoreCase ? 
 elem.toLowerCase().indexOf(entry.toLowerCase()) : 
 elem.indexOf(entry);

 while (foundPos != -1){
 if (foundPos == 0 && elem.length != entry.length){
 ret.push("<li><strong>" + elem.substr(0, entry.length) + "</strong>" + 
 elem.substr(entry.length) + "</li>");
 break;
}else if (entry.length >= instance.options.partialChars && 
 instance.options.partialSearch && foundPos != -1){
 if (instance.options.fullSearch || /\s/.test(elem.substr(foundPos-1,1))){
 partial.push("<li>" + elem.substr(0, foundPos) + "<strong>" +
 elem.substr(foundPos, entry.length) + "</strong>" + elem.substr(
 foundPos + entry.length) + "</li>");
 break;
}
}

 foundPos = instance.options.ignoreCase ? 
 elem.toLowerCase().indexOf(entry.toLowerCase(), foundPos + 1) : 
 elem.indexOf(entry, foundPos + 1);

}
}
 if (partial.length)
 ret = ret.concat(partial.slice(0, instance.options.choices - ret.length))
 return "<ul>" + ret.join('') + "</ul>";
}
}, options ||{});
}
});






Field.scrollFreeActivate = function(field){
 setTimeout(function(){
 Field.activate(field);
}, 1);
}

Ajax.InPlaceEditor = Class.create();
Ajax.InPlaceEditor.defaultHighlightColor = "#FFFF99";
Ajax.InPlaceEditor.prototype ={
 initialize: function(element, url, options){
 this.url = url;
 this.element = $(element);

 this.options = Object.extend({
 okButton: true,
 okText: "ok",
 cancelLink: true,
 cancelText: "cancel",
 savingText: "Saving...",
 clickToEditText: "Click to edit",
 okText: "ok",
 rows: 1,
 onComplete: function(transport, element){
 new Effect.Highlight(element,{startcolor: this.options.highlightcolor});
},
 onFailure: function(transport){
 alert("Error communicating with the server: " + transport.responseText.stripTags());
},
 callback: function(form){
 return Form.serialize(form);
},
 handleLineBreaks: true,
 loadingText: 'Loading...',
 savingClassName: 'inplaceeditor-saving',
 loadingClassName: 'inplaceeditor-loading',
 formClassName: 'inplaceeditor-form',
 highlightcolor: Ajax.InPlaceEditor.defaultHighlightColor,
 highlightendcolor: "#FFFFFF",
 externalControl: null,
 submitOnBlur: false,
 ajaxOptions:{},
 evalScripts: false
}, options ||{});

 if(!this.options.formId && this.element.id){
 this.options.formId = this.element.id + "-inplaceeditor";
 if ($(this.options.formId)){

 this.options.formId = null;
}
}
 
 if (this.options.externalControl){
 this.options.externalControl = $(this.options.externalControl);
}
 
 this.originalBackground = Element.getStyle(this.element, 'background-color');
 if (!this.originalBackground){
 this.originalBackground = "transparent";
}
 
 this.element.title = this.options.clickToEditText;
 
 this.onclickListener = this.enterEditMode.bindAsEventListener(this);
 this.mouseoverListener = this.enterHover.bindAsEventListener(this);
 this.mouseoutListener = this.leaveHover.bindAsEventListener(this);
 Event.observe(this.element, 'click', this.onclickListener);
 Event.observe(this.element, 'mouseover', this.mouseoverListener);
 Event.observe(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl){
 Event.observe(this.options.externalControl, 'click', this.onclickListener);
 Event.observe(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.observe(this.options.externalControl, 'mouseout', this.mouseoutListener);
}
},
 enterEditMode: function(evt){
 if (this.saving) return;
 if (this.editing) return;
 this.editing = true;
 this.onEnterEditMode();
 if (this.options.externalControl){
 Element.hide(this.options.externalControl);
}
 Element.hide(this.element);
 this.createForm();
 this.element.parentNode.insertBefore(this.form, this.element);
 Field.scrollFreeActivate(this.editField);

 if (evt){
 Event.stop(evt);
}
 return false;
},
 createForm: function(){
 this.form = document.createElement("form");
 this.form.id = this.options.formId;
 Element.addClassName(this.form, this.options.formClassName)
 this.form.onsubmit = this.onSubmit.bind(this);

 this.createEditField();

 if (this.options.textarea){
 var br = document.createElement("br");
 this.form.appendChild(br);
}

 if (this.options.okButton){
 okButton = document.createElement("input");
 okButton.type = "submit";
 okButton.value = this.options.okText;
 okButton.className = 'editor_ok_button';
 this.form.appendChild(okButton);
}

 if (this.options.cancelLink){
 cancelLink = document.createElement("a");
 cancelLink.href = "#";
 cancelLink.appendChild(document.createTextNode(this.options.cancelText));
 cancelLink.onclick = this.onclickCancel.bind(this);
 cancelLink.className = 'editor_cancel'; 
 this.form.appendChild(cancelLink);
}
},
 hasHTMLLineBreaks: function(string){
 if (!this.options.handleLineBreaks) return false;
 return string.match(/<br/i) || string.match(/<p>/i);
},
 convertHTMLLineBreaks: function(string){
 return string.replace(/<br>/gi, "\n").replace(/<br\/>/gi, "\n").replace(/<\/p>/gi, "\n").replace(/<p>/gi, "");
},
 createEditField: function(){
 var text;
 if(this.options.loadTextURL){
 text = this.options.loadingText;
}else{
 text = this.getText();
}

 var obj = this;
 
 if (this.options.rows == 1 && !this.hasHTMLLineBreaks(text)){
 this.options.textarea = false;
 var textField = document.createElement("input");
 textField.obj = this;
 textField.type = "text";
 textField.name = "value";
 textField.value = text;
 textField.style.backgroundColor = this.options.highlightcolor;
 textField.className = 'editor_field';
 var size = this.options.size || this.options.cols || 0;
 if (size != 0) textField.size = size;
 if (this.options.submitOnBlur)
 textField.onblur = this.onSubmit.bind(this);
 this.editField = textField;
}else{
 this.options.textarea = true;
 var textArea = document.createElement("textarea");
 textArea.obj = this;
 textArea.name = "value";
 textArea.value = this.convertHTMLLineBreaks(text);
 textArea.rows = this.options.rows;
 textArea.cols = this.options.cols || 40;
 textArea.className = 'editor_field'; 
 if (this.options.submitOnBlur)
 textArea.onblur = this.onSubmit.bind(this);
 this.editField = textArea;
}
 
 if(this.options.loadTextURL){
 this.loadExternalText();
}
 this.form.appendChild(this.editField);
},
 getText: function(){
 return this.element.innerHTML;
},
 loadExternalText: function(){
 Element.addClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = true;
 new Ajax.Request(
 this.options.loadTextURL,
 Object.extend({
 asynchronous: true,
 onComplete: this.onLoadedExternalText.bind(this)
}, this.options.ajaxOptions)
 );
},
 onLoadedExternalText: function(transport){
 Element.removeClassName(this.form, this.options.loadingClassName);
 this.editField.disabled = false;
 this.editField.value = transport.responseText.stripTags();
},
 onclickCancel: function(){
 this.onComplete();
 this.leaveEditMode();
 return false;
},
 onFailure: function(transport){
 this.options.onFailure(transport);
 if (this.oldInnerHTML){
 this.element.innerHTML = this.oldInnerHTML;
 this.oldInnerHTML = null;
}
 return false;
},
 onSubmit: function(){

 var form = this.form;
 var value = this.editField.value;



 this.onLoading();
 
 if (this.options.evalScripts){
 new Ajax.Request(
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this),
 asynchronous:true, 
 evalScripts:true
}, this.options.ajaxOptions));
}else{
 new Ajax.Updater(
{success: this.element,

 failure: null}, 
 this.url, Object.extend({
 parameters: this.options.callback(form, value),
 onComplete: this.onComplete.bind(this),
 onFailure: this.onFailure.bind(this)
}, this.options.ajaxOptions));
}

 if (arguments.length > 1){
 Event.stop(arguments[0]);
}
 return false;
},
 onLoading: function(){
 this.saving = true;
 this.removeForm();
 this.leaveHover();
 this.showSaving();
},
 showSaving: function(){
 this.oldInnerHTML = this.element.innerHTML;
 this.element.innerHTML = this.options.savingText;
 Element.addClassName(this.element, this.options.savingClassName);
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
},
 removeForm: function(){
 if(this.form){
 if (this.form.parentNode) Element.remove(this.form);
 this.form = null;
}
},
 enterHover: function(){
 if (this.saving) return;
 this.element.style.backgroundColor = this.options.highlightcolor;
 if (this.effect){
 this.effect.cancel();
}
 Element.addClassName(this.element, this.options.hoverClassName)
},
 leaveHover: function(){
 if (this.options.backgroundColor){
 this.element.style.backgroundColor = this.oldBackground;
}
 Element.removeClassName(this.element, this.options.hoverClassName)
 if (this.saving) return;
 this.effect = new Effect.Highlight(this.element,{
 startcolor: this.options.highlightcolor,
 endcolor: this.options.highlightendcolor,
 restorecolor: this.originalBackground
});
},
 leaveEditMode: function(){
 Element.removeClassName(this.element, this.options.savingClassName);
 this.removeForm();
 this.leaveHover();
 this.element.style.backgroundColor = this.originalBackground;
 Element.show(this.element);
 if (this.options.externalControl){
 Element.show(this.options.externalControl);
}
 this.editing = false;
 this.saving = false;
 this.oldInnerHTML = null;
 this.onLeaveEditMode();
},
 onComplete: function(transport){
 this.leaveEditMode();
 this.options.onComplete.bind(this)(transport, this.element);
},
 onEnterEditMode: function(){},
 onLeaveEditMode: function(){},
 dispose: function(){
 if (this.oldInnerHTML){
 this.element.innerHTML = this.oldInnerHTML;
}
 this.leaveEditMode();
 Event.stopObserving(this.element, 'click', this.onclickListener);
 Event.stopObserving(this.element, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.element, 'mouseout', this.mouseoutListener);
 if (this.options.externalControl){
 Event.stopObserving(this.options.externalControl, 'click', this.onclickListener);
 Event.stopObserving(this.options.externalControl, 'mouseover', this.mouseoverListener);
 Event.stopObserving(this.options.externalControl, 'mouseout', this.mouseoutListener);
}
}
};

Ajax.InPlaceCollectionEditor = Class.create();
Object.extend(Ajax.InPlaceCollectionEditor.prototype, Ajax.InPlaceEditor.prototype);
Object.extend(Ajax.InPlaceCollectionEditor.prototype,{
 createEditField: function(){
 if (!this.cached_selectTag){
 var selectTag = document.createElement("select");
 var collection = this.options.collection || [];
 var optionTag;
 collection.each(function(e,i){
 optionTag = document.createElement("option");
 optionTag.value = (e instanceof Array) ? e[0] : e;
 if(this.options.value==optionTag.value) optionTag.selected = true;
 optionTag.appendChild(document.createTextNode((e instanceof Array) ? e[1] : e));
 selectTag.appendChild(optionTag);
}.bind(this));
 this.cached_selectTag = selectTag;
}

 this.editField = this.cached_selectTag;
 if(this.options.loadTextURL) this.loadExternalText();
 this.form.appendChild(this.editField);
 this.options.callback = function(form, value){
 return "value=" + encodeURIComponent(value);
}
}
});




Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype ={
 initialize: function(element, delay, callback){
 this.delay = delay || 0.5;
 this.element = $(element);
 this.callback = callback;
 this.timer = null;
 this.lastValue = $F(this.element); 
 Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
},
 delayedListener: function(event){
 if(this.lastValue == $F(this.element)) return;
 if(this.timer) clearTimeout(this.timer);
 this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
 this.lastValue = $F(this.element);
},
 onTimerEvent: function(){
 this.timer = null;
 this.callback(this.element, $F(this.element));
}
};









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.collectTextNodes(node) : ''));
}).flatten().join('');
}

Element.setStyle = function(element, style){
 element = $(element);
 for(k in style) element.style[k.camelize()] = style[k];
}

Element.setContentZoom = function(element, percent){
 Element.setStyle(element,{fontSize: (percent/100) + 'em'}); 
 if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0); 
}

Element.getOpacity = function(element){
 var opacity;
 if (opacity = Element.getStyle(element, 'opacity')) 
 return parseFloat(opacity); 
 if (opacity = (Element.getStyle(element, 'filter') || '').match(/alpha\(opacity=(.*)\)/)) 
 if(opacity[1]) return parseFloat(opacity[1]) / 100; 
 return 1.0; 
}

Element.setOpacity = function(element, value){
 element= $(element); 
 if (value == 1){
 Element.setStyle(element,{opacity: 
 (/Gecko/.test(navigator.userAgent) && !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 
 0.999999 : null});
 if(/MSIE/.test(navigator.userAgent)) 
 Element.setStyle(element,{filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'')}); 
}else{
 if(value < 0.00001) value = 0; 
 Element.setStyle(element,{opacity: value});
 if(/MSIE/.test(navigator.userAgent)) 
 Element.setStyle(element, 
{filter: Element.getStyle(element,'filter').replace(/alpha\([^\)]*\)/gi,'') +
 'alpha(opacity='+value*100+')'}); 
}
}
 
Element.getInlineOpacity = function(element){
 return $(element).style.opacity || '';
}

Element.childrenWithClassName = function(element, className){
 return $A($(element).getElementsByTagName('*')).select(
 function(c){return Element.hasClassName(c, className)});
}

Array.prototype.call = function(){
 var args = arguments;
 this.each(function(f){f.apply(this, args)});
}


var Effect ={
 tagifyText: function(element){
 var tagifyStyle = 'position:relative';
 if(/MSIE/.test(navigator.userAgent)) tagifyStyle += ';zoom:1';
 element = $(element);
 $A(element.childNodes).each( function(child){
 if(child.nodeType==3){
 child.nodeValue.toArray().each( function(character){
 element.insertBefore(
 Builder.node('span',{style: tagifyStyle},
 character == ' ' ? String.fromCharCode(160) : character), 
 child);
});
 Element.remove(child);
}
});
},
 multiple: function(element, effect){
 var elements;
 if(((typeof element == 'object') || 
 (typeof element == 'function')) && 
 (element.length))
 elements = element;
 else
 elements = $(element).childNodes;
 
 var options = Object.extend({
 speed: 0.1,
 delay: 0.0
}, arguments[2] ||{});
 var masterDelay = options.delay;

 $A(elements).each( function(element, index){
 new effect(element, Object.extend(options,{delay: index * options.speed + masterDelay}));
});
},
 PAIRS:{
 'slide': ['SlideDown','SlideUp'],
 'blind': ['BlindDown','BlindUp'],
 'appear': ['Appear','Fade']
},
 toggle: function(element, effect){
 element = $(element);
 effect = (effect || 'appear').toLowerCase();
 var options = Object.extend({
 queue:{position:'end', scope:(element.id || 'global')}
}, arguments[2] ||{});
 Effect[Element.visible(element) ? 
 Effect.PAIRS[effect][1] : Effect.PAIRS[effect][0]](element, options);
}
};

var Effect2 = Effect; // deprecated


Effect.Transitions ={}

Effect.Transitions.linear = function(pos){
 return pos;
}
Effect.Transitions.sinoidal = function(pos){
 return (-Math.cos(pos*Math.PI)/2) + 0.5;
}
Effect.Transitions.reverse = function(pos){
 return 1-pos;
}
Effect.Transitions.flicker = function(pos){
 return ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
}
Effect.Transitions.wobble = function(pos){
 return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
}
Effect.Transitions.pulse = function(pos){
 return (Math.floor(pos*10) % 2 == 0 ? 
 (pos*10-Math.floor(pos*10)) : 1-(pos*10-Math.floor(pos*10)));
}
Effect.Transitions.none = function(pos){
 return 0;
}
Effect.Transitions.full = function(pos){
 return 1;
}


Effect.ScopedQueue = Class.create();
Object.extend(Object.extend(Effect.ScopedQueue.prototype, Enumerable),{
 initialize: function(){
 this.effects = [];
 this.interval = null;
},
 _each: function(iterator){
 this.effects._each(iterator);
},
 add: function(effect){
 var timestamp = new Date().getTime();
 
 var position = (typeof effect.options.queue == 'string') ? 
 effect.options.queue : effect.options.queue.position;
 
 switch(position){
 case 'front':

 this.effects.findAll(function(e){return e.state=='idle'}).each( function(e){
 e.startOn += effect.finishOn;
 e.finishOn += effect.finishOn;
});
 break;
 case 'end':

 timestamp = this.effects.pluck('finishOn').max() || timestamp;
 break;
}
 
 effect.startOn += timestamp;
 effect.finishOn += timestamp;
 this.effects.push(effect);
 if(!this.interval) 
 this.interval = setInterval(this.loop.bind(this), 40);
},
 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();
 this.effects.invoke('loop', timePos);
}
});

Effect.Queues ={
 instances: $H(),
 get: function(queueName){
 if(typeof queueName != 'string') return queueName;
 
 if(!this.instances[queueName])
 this.instances[queueName] = new Effect.ScopedQueue();
 
 return this.instances[queueName];
}
}
Effect.Queue = Effect.Queues.get('global');

Effect.DefaultOptions ={
 transition: Effect.Transitions.sinoidal,
 duration: 1.0, // seconds
 fps: 25.0, // max. 25fps due to Effect.Queue implementation
 sync: false, // true for combining
 from: 0.0,
 to: 1.0,
 delay: 0.0,
 queue: 'parallel'
}

Effect.Base = function(){};
Effect.Base.prototype ={
 position: null,
 start: function(options){
 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.event('beforeStart');
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).add(this);
},
 loop: function(timePos){
 if(timePos >= this.startOn){
 if(timePos >= this.finishOn){
 this.render(1.0);
 this.cancel();
 this.event('beforeFinish');
 if(this.finish) this.finish(); 
 this.event('afterFinish');
 return; 
}
 var pos = (timePos - this.startOn) / (this.finishOn - this.startOn);
 var frame = Math.round(pos * this.options.fps * this.options.duration);
 if(frame > this.currentFrame){
 this.render(pos);
 this.currentFrame = frame;
}
}
},
 render: function(pos){
 if(this.state == 'idle'){
 this.state = 'running';
 this.event('beforeSetup');
 if(this.setup) this.setup();
 this.event('afterSetup');
}
 if(this.state == 'running'){
 if(this.options.transition) pos = this.options.transition(pos);
 pos *= (this.options.to-this.options.from);
 pos += this.options.from;
 this.position = pos;
 this.event('beforeUpdate');
 if(this.update) this.update(pos);
 this.event('afterUpdate');
}
},
 cancel: function(){
 if(!this.options.sync)
 Effect.Queues.get(typeof this.options.queue == 'string' ? 
 'global' : this.options.queue.scope).remove(this);
 this.state = 'finished';
},
 event: function(eventName){
 if(this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
 if(this.options[eventName]) this.options[eventName](this);
},
 inspect: function(){
 return '#<Effect:' + $H(this).inspect() + ',options:' + $H(this.options).inspect() + '>';
}
}

Effect.Parallel = Class.create();
Object.extend(Object.extend(Effect.Parallel.prototype, Effect.Base.prototype),{
 initialize: function(effects){
 this.effects = effects || [];
 this.start(arguments[1]);
},
 update: function(position){
 this.effects.invoke('render', position);
},
 finish: function(position){
 this.effects.each( function(effect){
 effect.render(1.0);
 effect.cancel();
 effect.event('beforeFinish');
 if(effect.finish) effect.finish(position);
 effect.event('afterFinish');
});
}
});

Effect.Opacity = Class.create();
Object.extend(Object.extend(Effect.Opacity.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);

 if(/MSIE/.test(navigator.userAgent) && (!this.element.hasLayout))
 Element.setStyle(this.element,{zoom: 1});
 var options = Object.extend({
 from: Element.getOpacity(this.element) || 0.0,
 to: 1.0
}, arguments[1] ||{});
 this.start(options);
},
 update: function(position){
 Element.setOpacity(this.element, position);
}
});

Effect.Move = Class.create();
Object.extend(Object.extend(Effect.Move.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);
 var options = Object.extend({
 x: 0,
 y: 0,
 mode: 'relative'
}, arguments[1] ||{});
 this.start(options);
},
 setup: function(){




 Element.makePositioned(this.element);
 this.originalLeft = parseFloat(Element.getStyle(this.element,'left') || '0');
 this.originalTop = parseFloat(Element.getStyle(this.element,'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){
 Element.setStyle(this.element,{
 left: this.options.x * position + this.originalLeft + 'px',
 top: this.options.y * position + this.originalTop + 'px'
});
}
});

Effect.MoveBy = function(element, toTop, toLeft){
 return new Effect.Move(element, 
 Object.extend({x: toLeft, y: toTop}, arguments[3] ||{}));
};

Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype),{
 initialize: function(element, percent){
 this.element = $(element)
 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 = Element.getStyle(this.element,'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 = Element.getStyle(this.element,'font-size') || '100%';
 ['em','px','%'].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)
 Element.setStyle(this.element,{fontSize: this.fontSize * currentScale + this.fontSizeType});
 this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
},
 finish: function(position){
 if (this.restoreAfterFinish) Element.setStyle(this.element, this.originalStyle);
},
 setDimensions: function(height, width){
 var d ={};
 if(this.options.scaleX) d.width = width + 'px';
 if(this.options.scaleY) d.height = height + 'px';
 if(this.options.scaleFromCenter){
 var topd = (height - this.dims[0])/2;
 var leftd = (width - this.dims[1])/2;
 if(this.elementPositioning == 'absolute'){
 if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
 if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
}else{
 if(this.options.scaleY) d.top = -topd + 'px';
 if(this.options.scaleX) d.left = -leftd + 'px';
}
}
 Element.setStyle(this.element, d);
}
});

Effect.Highlight = Class.create();
Object.extend(Object.extend(Effect.Highlight.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);
 var options = Object.extend({startcolor: '#ffff99'}, arguments[1] ||{});
 this.start(options);
},
 setup: function(){

 if(Element.getStyle(this.element, 'display')=='none'){this.cancel(); return;}

 this.oldStyle ={
 backgroundImage: Element.getStyle(this.element, 'background-image')};
 Element.setStyle(this.element,{backgroundImage: 'none'});
 if(!this.options.endcolor)
 this.options.endcolor = Element.getStyle(this.element, 'background-color').parseColor('#ffffff');
 if(!this.options.restorecolor)
 this.options.restorecolor = Element.getStyle(this.element, 'background-color');

 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){
 Element.setStyle(this.element,{backgroundColor: $R(0,2).inject('#',function(m,v,i){
 return m+(Math.round(this._base[i]+(this._delta[i]*position)).toColorPart());}.bind(this))});
},
 finish: function(){
 Element.setStyle(this.element, Object.extend(this.oldStyle,{
 backgroundColor: this.options.restorecolor
}));
}
});

Effect.ScrollTo = Class.create();
Object.extend(Object.extend(Effect.ScrollTo.prototype, Effect.Base.prototype),{
 initialize: function(element){
 this.element = $(element);
 this.start(arguments[1] ||{});
},
 setup: function(){
 Position.prepare();
 var offsets = Position.cumulativeOffset(this.element);
 if(this.options.offset) offsets[1] += this.options.offset;
 var max = window.innerHeight ? 
 window.height - window.innerHeight :
 document.body.scrollHeight - 
 (document.documentElement.clientHeight ? 
 document.documentElement.clientHeight : document.body.clientHeight);
 this.scrollStart = Position.deltaY;
 this.delta = (offsets[1] > max ? max : offsets[1]) - this.scrollStart;
},
 update: function(position){
 Position.prepare();
 window.scrollTo(Position.deltaX, 
 this.scrollStart + (position*this.delta));
}
});


Effect.Fade = function(element){
 var oldOpacity = Element.getInlineOpacity(element);
 var options = Object.extend({
 from: Element.getOpacity(element) || 1.0,
 to: 0.0,
 afterFinishInternal: function(effect){with(Element){
 if(effect.options.to!=0) return;
 hide(effect.element);
 setStyle(effect.element,{opacity: oldOpacity});}}
}, arguments[1] ||{});
 return new Effect.Opacity(element,options);
}

Effect.Appear = function(element){
 var options = Object.extend({
 from: (Element.getStyle(element, 'display') == 'none' ? 0.0 : Element.getOpacity(element) || 0.0),
 to: 1.0,
 beforeSetup: function(effect){with(Element){
 setOpacity(effect.element, effect.options.from);
 show(effect.element);}}
}, arguments[1] ||{});
 return new Effect.Opacity(element,options);
}

Effect.Puff = function(element){
 element = $(element);
 var oldStyle ={opacity: Element.getInlineOpacity(element), position: Element.getStyle(element, 'position')};
 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){with(Element){
 setStyle(effect.effects[0].element,{position: 'absolute'});}},
 afterFinishInternal: function(effect){with(Element){
 hide(effect.effects[0].element);
 setStyle(effect.effects[0].element, oldStyle);}}
}, arguments[1] ||{})
 );
}

Effect.BlindUp = function(element){
 element = $(element);
 Element.makeClipping(element);
 return new Effect.Scale(element, 0, 
 Object.extend({scaleContent: false, 
 scaleX: false, 
 restoreAfterFinish: true,
 afterFinishInternal: function(effect){with(Element){
 [hide, undoClipping].call(effect.element);}}
}, arguments[1] ||{})
 );
}

Effect.BlindDown = function(element){
 element = $(element);
 var oldHeight = Element.getStyle(element, 'height');
 var elementDimensions = Element.getDimensions(element);
 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){with(Element){
 makeClipping(effect.element);
 setStyle(effect.element,{height: '0px'});
 show(effect.element); 
}}, 
 afterFinishInternal: function(effect){with(Element){
 undoClipping(effect.element);
 setStyle(effect.element,{height: oldHeight});
}}
}, arguments[1] ||{})
 );
}

Effect.SwitchOff = function(element){
 element = $(element);
 var oldOpacity = Element.getInlineOpacity(element);
 return new Effect.Appear(element,{
 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){with(Element){
 [makePositioned,makeClipping].call(effect.element);
}},
 afterFinishInternal: function(effect){with(Element){
 [hide,undoClipping,undoPositioned].call(effect.element);
 setStyle(effect.element,{opacity: oldOpacity});
}}
})
}
});
}

Effect.DropOut = function(element){
 element = $(element);
 var oldStyle ={
 top: Element.getStyle(element, 'top'),
 left: Element.getStyle(element, 'left'),
 opacity: Element.getInlineOpacity(element)};
 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){with(Element){
 makePositioned(effect.effects[0].element);}},
 afterFinishInternal: function(effect){with(Element){
 [hide, undoPositioned].call(effect.effects[0].element);
 setStyle(effect.effects[0].element, oldStyle);}}
}, arguments[1] ||{}));
}

Effect.Shake = function(element){
 element = $(element);
 var oldStyle ={
 top: Element.getStyle(element, 'top'),
 left: Element.getStyle(element, 'left')};
 return new Effect.Move(element, 
{x: 20, y: 0, duration: 0.05, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: -40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: 40, y: 0, duration: 0.1, afterFinishInternal: function(effect){
 new Effect.Move(effect.element,
{x: -20, y: 0, duration: 0.05, afterFinishInternal: function(effect){with(Element){
 undoPositioned(effect.element);
 setStyle(effect.element, oldStyle);
}}})}})}})}})}})}});
}

Effect.SlideDown = function(element){
 element = $(element);
 Element.cleanWhitespace(element);

 var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
 var elementDimensions = Element.getDimensions(element);
 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){with(Element){
 makePositioned(effect.element);
 makePositioned(effect.element.firstChild);
 if(window.opera) setStyle(effect.element,{top: ''});
 makeClipping(effect.element);
 setStyle(effect.element,{height: '0px'});
 show(element);}},
 afterUpdateInternal: function(effect){with(Element){
 setStyle(effect.element.firstChild,{bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px'});}},
 afterFinishInternal: function(effect){with(Element){
 undoClipping(effect.element); 
 undoPositioned(effect.element.firstChild);
 undoPositioned(effect.element);
 setStyle(effect.element.firstChild,{bottom: oldInnerBottom});}}
}, arguments[1] ||{})
 );
}
 
Effect.SlideUp = function(element){
 element = $(element);
 Element.cleanWhitespace(element);
 var oldInnerBottom = Element.getStyle(element.firstChild, 'bottom');
 return new Effect.Scale(element, 0, 
 Object.extend({scaleContent: false, 
 scaleX: false, 
 scaleMode: 'box',
 scaleFrom: 100,
 restoreAfterFinish: true,
 beforeStartInternal: function(effect){with(Element){
 makePositioned(effect.element);
 makePositioned(effect.element.firstChild);
 if(window.opera) setStyle(effect.element,{top: ''});
 makeClipping(effect.element);
 show(element);}}, 
 afterUpdateInternal: function(effect){with(Element){
 setStyle(effect.element.firstChild,{bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px'});}},
 afterFinishInternal: function(effect){with(Element){
 [hide, undoClipping].call(effect.element); 
 undoPositioned(effect.element.firstChild);
 undoPositioned(effect.element);
 setStyle(effect.element.firstChild,{bottom: oldInnerBottom});}}
}, arguments[1] ||{})
 );
}

Effect.Squish = function(element){
 return new Effect.Scale(element, window.opera ? 1 : 0, 
{restoreAfterFinish: true,
 beforeSetup: function(effect){with(Element){
 makeClipping(effect.element);}}, 
 afterFinishInternal: function(effect){with(Element){
 hide(effect.element); 
 undoClipping(effect.element);}}
});
}

Effect.Grow = function(element){
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransistion: 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(element)};

 var dims = Element.getDimensions(element); 
 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){with(Element){
 hide(effect.element);
 makeClipping(effect.element);
 makePositioned(effect.element);
}},
 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){with(Element){
 setStyle(effect.effects[0].element,{height: '0px'});
 show(effect.effects[0].element);}},
 afterFinishInternal: function(effect){with(Element){
 [undoClipping, undoPositioned].call(effect.effects[0].element); 
 setStyle(effect.effects[0].element, oldStyle);}}
}, options)
 )
}
});
}

Effect.Shrink = function(element){
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransistion: 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(element)};

 var dims = Element.getDimensions(element);
 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){with(Element){
 [makePositioned, makeClipping].call(effect.effects[0].element)}},
 afterFinishInternal: function(effect){with(Element){
 [hide, undoClipping, undoPositioned].call(effect.effects[0].element);
 setStyle(effect.effects[0].element, oldStyle);}}
}, options)
 );
}

Effect.Pulsate = function(element){
 element = $(element);
 var options = arguments[1] ||{};
 var oldOpacity = Element.getInlineOpacity(element);
 var transition = options.transition || Effect.Transitions.sinoidal;
 var reverser = function(pos){return transition(1-Effect.Transitions.pulse(pos))};
 reverser.bind(transition);
 return new Effect.Opacity(element, 
 Object.extend(Object.extend({duration: 3.0, from: 0,
 afterFinishInternal: function(effect){Element.setStyle(effect.element,{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(element);
 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){with(Element){
 [hide, undoClipping].call(effect.element); 
 setStyle(effect.element, oldStyle);
}}});
}}, arguments[1] ||{}));
}// Copyright (c) 2005 Thomas Fuchs (<a href="http://script.aculo.us">http://script.aculo.us</a>, <a href="http://mir.aculo.us">http://mir.aculo.us</a>)




















var Scriptaculous ={
 Version: '1.5.1',
 require: function(libraryName){

 document.write('<script type="text/javascript" src="'+libraryName+'"></script>');
},
 load: function(){
 if((typeof Prototype=='undefined') ||
 parseFloat(Prototype.Version.split(".")[0] + "." +
 Prototype.Version.split(".")[1]) < 1.4)
 throw("script.aculo.us requires the Prototype JavaScript framework >= 1.4.0");
 
 $A(document.getElementsByTagName("script")).findAll( function(s){
 return (s.src && s.src.match(/scriptaculous\.js(\?.*)?$/))
}).each( function(s){
 var path = s.src.replace(/scriptaculous\.js(\?.*)?$/,'');
 var includes = s.src.match(/\?.*load=([a-z,]*)/);
 (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider').split(',').each(
 function(include){Scriptaculous.require(path+include+'.js')});
});
}
}

Scriptaculous.load();




















var fileLoadingImage = "/images/miracle/lightbox/loading.gif"; 
var fileBottomNavCloseImage = "/images/miracle/lightbox/closelabel.gif";

var resizeSpeed = 7; // controls the speed of the image resizing (1=slowest and 10=fastest)

var borderSize = 10; //if you adjust the padding in the CSS, you will need to update this variable




var imageArray = new Array;
var activeImage;

if(resizeSpeed > 10){resizeSpeed = 10;}
if(resizeSpeed < 1){resizeSpeed = 1;}
resizeDuration = (11 - resizeSpeed) * 0.15;





Object.extend(Element,{
 getWidth: function(element){
 element = $(element);
 return element.offsetWidth; 
},
 setWidth: function(element,w){
 element = $(element);
 element.style.width = w +"px";
},
 setHeight: function(element,h){
 element = $(element);
 element.style.height = h +"px";
},
 setTop: function(element,t){
 element = $(element);
 element.style.top = t +"px";
},
 setSrc: function(element,src){
 element = $(element);
 element.src = src; 
},
 setHref: function(element,href){
 element = $(element);
 element.href = href; 
},
 setInnerHTML: function(element,content){
 element = $(element);
 element.innerHTML = content;
}
});






Array.prototype.removeDuplicates = function (){
 for(i = 1; i < this.length; i++){
 if(this[i][0] == this[i-1][0]){
 this.splice(i,1);
}
}
}


Array.prototype.empty = function (){
 for(i = 0; i <= this.length; i++){
 this.shift();
}
}


















var Lightbox = Class.create();

Lightbox.prototype ={






 initialize: function(){
 if (!document.getElementsByTagName){return;}
 var anchors = document.getElementsByTagName('a');

 for (var i=0; i<anchors.length; i++){
 var anchor = anchors[i];
 
 var relAttribute = String(anchor.getAttribute('rel'));

 if (anchor.getAttribute('href') && (relAttribute.toLowerCase().match('lightbox'))){
 anchor.onclick = function (){myLightbox.start(this); return false;}
}
}


































 var objBody = document.getElementsByTagName("body").item(0);
 
 var objOverlay = document.createElement("div");
 objOverlay.setAttribute('id','overlay');
 objOverlay.style.display = 'none';
 objOverlay.onclick = function(){myLightbox.end(); return false;}
 objBody.appendChild(objOverlay);
 
 var objLightbox = document.createElement("div");
 objLightbox.setAttribute('id','lightbox');
 objLightbox.style.display = 'none';
 objBody.appendChild(objLightbox);
 
 var objOuterImageContainer = document.createElement("div");
 objOuterImageContainer.setAttribute('id','outerImageContainer');
 objLightbox.appendChild(objOuterImageContainer);

 var objImageContainer = document.createElement("div");
 objImageContainer.setAttribute('id','imageContainer');
 objOuterImageContainer.appendChild(objImageContainer);
 
 var objLightboxImage = document.createElement("img");
 objLightboxImage.setAttribute('id','lightboxImage');
 objImageContainer.appendChild(objLightboxImage);
 
 var objHoverNav = document.createElement("div");
 objHoverNav.setAttribute('id','hoverNav');
 objImageContainer.appendChild(objHoverNav);
 
 var objPrevLink = document.createElement("a");
 objPrevLink.setAttribute('id','prevLink');
 objPrevLink.setAttribute('href','#');
 objHoverNav.appendChild(objPrevLink);
 
 var objNextLink = document.createElement("a");
 objNextLink.setAttribute('id','nextLink');
 objNextLink.setAttribute('href','#');
 objHoverNav.appendChild(objNextLink);
 
 var objLoading = document.createElement("div");
 objLoading.setAttribute('id','loading');
 objImageContainer.appendChild(objLoading);
 
 var objLoadingLink = document.createElement("a");
 objLoadingLink.setAttribute('id','loadingLink');
 objLoadingLink.setAttribute('href','#');
 objLoadingLink.onclick = function(){myLightbox.end(); return false;}
 objLoading.appendChild(objLoadingLink);
 
 var objLoadingImage = document.createElement("img");
 objLoadingImage.setAttribute('src', fileLoadingImage);
 objLoadingLink.appendChild(objLoadingImage);

 var objImageDataContainer = document.createElement("div");
 objImageDataContainer.setAttribute('id','imageDataContainer');
 objImageDataContainer.className = 'clearfix';
 objLightbox.appendChild(objImageDataContainer);

 var objImageData = document.createElement("div");
 objImageData.setAttribute('id','imageData');
 objImageDataContainer.appendChild(objImageData);
 
 var objImageDetails = document.createElement("div");
 objImageDetails.setAttribute('id','imageDetails');
 objImageData.appendChild(objImageDetails);
 
 var objCaption = document.createElement("span");
 objCaption.setAttribute('id','caption');
 objImageDetails.appendChild(objCaption);
 
 var objNumberDisplay = document.createElement("span");
 objNumberDisplay.setAttribute('id','numberDisplay');
 objImageDetails.appendChild(objNumberDisplay);
 
 var objBottomNav = document.createElement("div");
 objBottomNav.setAttribute('id','bottomNav');
 objImageData.appendChild(objBottomNav);
 
 var objBottomNavCloseLink = document.createElement("a");
 objBottomNavCloseLink.setAttribute('id','bottomNavClose');
 objBottomNavCloseLink.setAttribute('href','#');
 objBottomNavCloseLink.onclick = function(){myLightbox.end(); return false;}
 objBottomNav.appendChild(objBottomNavCloseLink);
 
 var objBottomNavCloseImage = document.createElement("img");
 objBottomNavCloseImage.setAttribute('src', fileBottomNavCloseImage);
 objBottomNavCloseLink.appendChild(objBottomNavCloseImage);
},




 start: function(imageLink){

 hideSelectBoxes();

 var arrayPageSize = getPageSize();
 Element.setHeight('overlay', arrayPageSize[1]);
 new Effect.Appear('overlay',{duration: 0.2, from: 0.0, to: 0.8});

 imageArray = [];
 imageNum = 0; 

 if (!document.getElementsByTagName){return;}
 var anchors = document.getElementsByTagName('a');

 if((imageLink.getAttribute('rel') == 'lightbox')){

 imageArray.push(new Array(imageLink.getAttribute('href'), imageLink.getAttribute('title'))); 
}else{


 for (var i=0; i<anchors.length; i++){
 var anchor = anchors[i];
 if (anchor.getAttribute('href') && (anchor.getAttribute('rel') == imageLink.getAttribute('rel'))){
 imageArray.push(new Array(anchor.getAttribute('href'), anchor.getAttribute('title')));
}
}
 imageArray.removeDuplicates();
 while(imageArray[imageNum][0] != imageLink.getAttribute('href')){imageNum++;}
}

 var arrayPageSize = getPageSize();
 var arrayPageScroll = getPageScroll();
 var lightboxTop = arrayPageScroll[1] + (arrayPageSize[3] / 15);

 Element.setTop('lightbox', lightboxTop);
 Element.show('lightbox');
 
 this.changeImage(imageNum);
},




 changeImage: function(imageNum){
 
 activeImage = imageNum; // update global var

 Element.show('loading');
 Element.hide('lightboxImage');
 Element.hide('hoverNav');
 Element.hide('prevLink');
 Element.hide('nextLink');
 Element.hide('imageDataContainer');
 Element.hide('numberDisplay'); 
 
 imgPreloader = new Image();

 imgPreloader.onload=function(){
 Element.setSrc('lightboxImage', imageArray[activeImage][0]);
 myLightbox.resizeImageContainer(imgPreloader.width, imgPreloader.height);
}
 imgPreloader.src = imageArray[activeImage][0];
},



 resizeImageContainer: function( imgWidth, imgHeight){

 this.wCur = Element.getWidth('outerImageContainer');
 this.hCur = Element.getHeight('outerImageContainer');

 this.xScale = ((imgWidth + (borderSize * 2)) / this.wCur) * 100;
 this.yScale = ((imgHeight + (borderSize * 2)) / this.hCur) * 100;

 wDiff = (this.wCur - borderSize * 2) - imgWidth;
 hDiff = (this.hCur - borderSize * 2) - imgHeight;

 if(!( hDiff == 0)){new Effect.Scale('outerImageContainer', this.yScale,{scaleX: false, duration: resizeDuration, queue: 'front'});}
 if(!( wDiff == 0)){new Effect.Scale('outerImageContainer', this.xScale,{scaleY: false, delay: resizeDuration, duration: resizeDuration});}


 if((hDiff == 0) && (wDiff == 0)){
 if (navigator.appVersion.indexOf("MSIE")!=-1){pause(250);}else{pause(100);}
}

 Element.setHeight('prevLink', imgHeight);
 Element.setHeight('nextLink', imgHeight);
 Element.setWidth( 'imageDataContainer', imgWidth + (borderSize * 2));

 this.showImage();
},




 showImage: function(){
 Element.hide('loading');
 new Effect.Appear('lightboxImage',{duration: 0.5, queue: 'end', afterFinish: function(){myLightbox.updateDetails();}});
 this.preloadNeighborImages();
},




 updateDetails: function(){
 
 Element.show('caption');
 Element.setInnerHTML( 'caption', imageArray[activeImage][1]);

 if(imageArray.length > 1){
 Element.show('numberDisplay');
 Element.setInnerHTML( 'numberDisplay', "Image " + eval(activeImage + 1) + " of " + imageArray.length);
}

 new Effect.Parallel(
 [ new Effect.SlideDown( 'imageDataContainer',{sync: true, duration: resizeDuration + 0.25, from: 0.0, to: 1.0}), 
 new Effect.Appear('imageDataContainer',{sync: true, duration: 1.0}) ], 
{duration: 0.65, afterFinish: function(){myLightbox.updateNav();}}
 );
},




 updateNav: function(){

 Element.show('hoverNav'); 

 if(activeImage != 0){
 Element.show('prevLink');
 document.getElementById('prevLink').onclick = function(){
 myLightbox.changeImage(activeImage - 1); return false;
}
}

 if(activeImage != (imageArray.length - 1)){
 Element.show('nextLink');
 document.getElementById('nextLink').onclick = function(){
 myLightbox.changeImage(activeImage + 1); return false;
}
}
 
 this.enableKeyboardNav();
},



 enableKeyboardNav: function(){
 document.onkeydown = this.keyboardAction; 
},



 disableKeyboardNav: function(){
 document.onkeydown = '';
},



 keyboardAction: function(e){
 if (e == null){// ie
 keycode = event.keyCode;
}else{// mozilla
 keycode = e.which;
}

 key = String.fromCharCode(keycode).toLowerCase();
 
 if((key == 'x') || (key == 'o') || (key == 'c')){// close lightbox
 myLightbox.end();
}else if(key == 'p'){// display previous image
 if(activeImage != 0){
 myLightbox.disableKeyboardNav();
 myLightbox.changeImage(activeImage - 1);
}
}else if(key == 'n'){// display next image
 if(activeImage != (imageArray.length - 1)){
 myLightbox.disableKeyboardNav();
 myLightbox.changeImage(activeImage + 1);
}
}


},




 preloadNeighborImages: function(){

 if((imageArray.length - 1) > activeImage){
 preloadNextImage = new Image();
 preloadNextImage.src = imageArray[activeImage + 1][0];
}
 if(activeImage > 0){
 preloadPrevImage = new Image();
 preloadPrevImage.src = imageArray[activeImage - 1][0];
}
 
},



 end: function(){
 this.disableKeyboardNav();
 Element.hide('lightbox');
 new Effect.Fade('overlay',{duration: 0.2});
 showSelectBoxes();
}
}






function getPageScroll(){

 var yScroll;

 if (self.pageYOffset){
 yScroll = self.pageYOffset;
}else if (document.documentElement && document.documentElement.scrollTop){// Explorer 6 Strict
 yScroll = document.documentElement.scrollTop;
}else if (document.body){// all other Explorers
 yScroll = document.body.scrollTop;
}

 arrayPageScroll = new Array('',yScroll) 
 return arrayPageScroll;
}







function getPageSize(){
 
 var xScroll, yScroll;
 
 if (window.innerHeight && window.scrollMaxY){
 xScroll = document.body.scrollWidth;
 yScroll = window.innerHeight + window.scrollMaxY;
}else if (document.body.scrollHeight > document.body.offsetHeight){// all but Explorer Mac
 xScroll = document.body.scrollWidth;
 yScroll = document.body.scrollHeight;
}else{// Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
 xScroll = document.body.offsetWidth;
 yScroll = document.body.offsetHeight;
}
 
 var windowWidth, windowHeight;
 if (self.innerHeight){// all except Explorer
 windowWidth = self.innerWidth;
 windowHeight = self.innerHeight;
}else if (document.documentElement && document.documentElement.clientHeight){// Explorer 6 Strict Mode
 windowWidth = document.documentElement.clientWidth;
 windowHeight = document.documentElement.clientHeight;
}else if (document.body){// other Explorers
 windowWidth = document.body.clientWidth;
 windowHeight = document.body.clientHeight;
}

 if(yScroll < windowHeight){
 pageHeight = windowHeight;
}else{
 pageHeight = yScroll;
}

 if(xScroll < windowWidth){
 pageWidth = windowWidth;
}else{
 pageWidth = xScroll;
}


 arrayPageSize = new Array(pageWidth,pageHeight,windowWidth,windowHeight) 
 return arrayPageSize;
}





function getKey(e){
 if (e == null){// ie
 keycode = event.keyCode;
}else{// mozilla
 keycode = e.which;
}
 key = String.fromCharCode(keycode).toLowerCase();
 
 if(key == 'x'){
}
}




function listenKey (){document.onkeypress = getKey;}


function showSelectBoxes(){
 selects = document.getElementsByTagName("select");
 for (i = 0; i != selects.length; i++){
 selects[i].style.visibility = "visible";
}
}


function hideSelectBoxes(){
 selects = document.getElementsByTagName("select");
 for (i = 0; i != selects.length; i++){
 selects[i].style.visibility = "hidden";
}
}






function pause(numberMillis){
 var now = new Date();
 var exitTime = now.getTime() + numberMillis;
 while (true){
 now = new Date();
 if (now.getTime() > exitTime)
 return;
}
}







var JSON ={
 copyright: '(c)2005 JSON.org',
 license: '<a href="http://www.crockford.com/JSON/license.html">http://www.crockford.com/JSON/license.html</a>',

 stringify: function (v){
 var a = [];


 function e(s){
 a[a.length] = s;
}


 function g(x){
 var c, i, l, v;

 switch (typeof x){
 case 'object':
 if (x){
 if (x instanceof Array){
 e('[');
 l = a.length;
 for (i = 0; i < x.length; i += 1){
 v = x[i];
 if (typeof v != 'undefined' &&
 typeof v != 'function'){
 if (l < a.length){
 e(',');
}
 g(v);
}
}
 e(']');
 return;
}else if (typeof x.valueOf == 'function'){
 e('{');
 l = a.length;
 for (i in x){
 v = x[i];
 if (typeof v != 'undefined' &&
 typeof v != 'function' &&
 (!v || typeof v != 'object' ||
 typeof v.valueOf == 'function')){
 if (l < a.length){
 e(',');
}
 g(i);
 e(':');
 g(v);
}
}
 return e('}');
}
}
 e('null');
 return;
 case 'number':
 e(isFinite(x) ? +x : 'null');
 return;
 case 'string':
 l = x.length;
 e('"');
 for (i = 0; i < l; i += 1){
 c = x.charAt(i);
 if (c >= ' '){
 if (c == '\\' || c == '"'){
 e('\\');
}
 e(c);
}else{
 switch (c){
 case '\b':
 e('\\b');
 break;
 case '\f':
 e('\\f');
 break;
 case '\n':
 e('\\n');
 break;
 case '\r':
 e('\\r');
 break;
 case '\t':
 e('\\t');
 break;
 default:
 c = c.charCodeAt();
 e('\\u00' + Math.floor(c / 16).toString(16) +
 (c % 16).toString(16));
}
}
}
 e('"');
 return;
 case 'boolean':
 e(String(x));
 return;
 default:
 e('null');
 return;
}
}
 g(v);
 return a.join('');
},

 parse: function (text){
 return (/^(\s+|[,:{}\[\]]|"(\\["\\\/bfnrtu]|[^\x00-\x1f"\\]+)*"|-?\d+(\.\d*)?([eE][+-]?\d+)?|true|false|null)+$/.test(text)) &&
 eval('(' + text + ')');
}
};


var addEvent;
if (document.addEventListener){
 addEvent = function(element, type, handler){
 element.addEventListener(type, handler, null);
};
}else if (document.attachEvent){
 addEvent = function(element, type, handler){
 element.attachEvent("on" + type, handler);
};
}else{
 addEvent = new Function; // not supported
}

function strReplace(from, to, str){
 var idx = str.indexOf( from );
 while ( idx > -1 ){
 str = str.replace( from, to );
 idx = str.indexOf( from );
}

 return str;
}

document.getElementsByTagNameAndAttribute = function(tagname, attribute, value){
 if (!value) value="/.+/";
 var elements=new Array();
 var inputs=document.getElementsByTagName(tagname);
 var j=0;
 if (value.substring(0,1)!="/"){
 value=new RegExp("^"+value+"$", "i");
}else{
 value=new RegExp(value.substring(1, value.length-1), "i");
}
 for (var i=0; i<inputs.length; i++){
 var attr=inputs[i].getAttribute(attribute);
 if (!attr) continue; // ha nincs ilyen attributum akkor megyunk tovabb
 var sattr=new String(attr);
 if (sattr.match(value)){
 elements[j]=inputs[i];
 j++;
}
}
 return elements;
}

if (typeof(HTMLElement)!="undefined"){
 HTMLElement.prototype.getElementsByTagNameAndAttribute = document.getElementsByTagNameAndAttribute;
}

function printfire(){
 if (window.atob && document.createEvent){
 printfire.args = arguments;
 var ev = document.createEvent("Events");
 ev.initEvent("printfire", false, true);
 dispatchEvent(ev);
}
}

function encode_utf8(rohtext){

 rohtext = rohtext.replace(/\r\n/g,"\n");
 var utftext = "";
 for(var n=0; n<rohtext.length; n++)
{

 var c=rohtext.charCodeAt(n);

 if (c<128)
 utftext += String.fromCharCode(c);

 else if((c>127) && (c<2048)){
 utftext += String.fromCharCode((c>>6)|192);
 utftext += String.fromCharCode((c&63)|128);}

 else{
 utftext += String.fromCharCode((c>>12)|224);
 utftext += String.fromCharCode(((c>>6)&63)|128);
 utftext += String.fromCharCode((c&63)|128);}
}
 return utftext;
}

String.prototype.trim = function(){
 return(this.replace(/^\s+/,'').replace(/\s+$/,''));
}

function createCookie(name,value,days){
 if (days){
 var date = new Date();
 date.setTime(date.getTime()+(days*24*60*60*1000));
 var expires = "; expires="+date.toGMTString();
}else 
 expires = "";

 document.cookie = name+"="+value+expires+"; path=/";
}

function readCookie(name){
 var nameEQ = name + "=";
 var ca = document.cookie.split(';');
 for (var i=0;i < ca.length;i++){
 var c = ca[i];
 while (c.charAt(0)==' ') c = c.substring(1,c.length);
 if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length,c.length);
}
 return null;
}

function lz(nr){
 if (nr < 10) nr = "0" + nr;
 return nr;
}

function DOM_InsertAfter(afterNode, thisNode){
 var parent=afterNode.parentNode;
 if (parent.lastChild==afterNode){
 return parent.appendChild(thisNode);
}else{
 return parent.insertBefore(thisNode, afterNode.nextSibling);
}
}

function $N(value, nan){
 if (typeof(nan) == "undefined") nan = 0;
 var tmp = (tmp = parseInt(value)) ? tmp : nan;
 return tmp;
}

var browser ={

 isIE: !!document.protocol,
 isGecko: !!window.atob,
 isOpera: !!window.opera,

 name: (
 document.protocol ? "ie" : (
 window.atob ? "gecko" : ( window.opera ? "opera" : undefined )
 )),

 version: (
 document.protocol ? (
 window.XMLHttpRequest ? 7 : (
 document.createComment ? 6 : (
 window.createPopup ? 5.5 : (
 window.clipboardData ? 5 : (
 window.showModalDialog ? 4 : undefined
 )
 )
 )
 )
 ) : undefined
 )

}
function Popup(activeLink){
 
 this.activeLink=activeLink;
 this.href=this.activeLink.getAttribute("href");
 this.screenWidth=screen.width;
 this.screenHeight=screen.height;
 this.popupWidth=this.activeLink.getAttribute("popupwidth");
 this.popupHeight=this.activeLink.getAttribute("popupheight");
 this.scroll=this.activeLink.getAttribute("popupscroll");


 var parts=this.href.split(".");
 if ((parts[1]=="jpg") || (parts[1]=="gif") || (parts[1]=="png")){
 this.imageURL=this.href;
 this.createImage();
}

 this.left=(this.screenWidth-this.img.width)/2; 
 this.top=(this.screenHeight-this.img.height)/2-20;

 this.settings="toolbars='no'";
 this.settings+=",width="+this.img.width;
 this.settings+=",height="+this.img.height;
 this.settings+=",left="+this.left;
 this.settings+=",top="+this.top;
 if (this.scroll) this.settings+=",scrollbars=1";

 this.setTitle();
 this.openCenteredWindow();
}

Popup.prototype.setTitle=function(){
 this.title=this.activeLink.firstChild.getAttribute("title");
 if (!this.title){
 this.title="";
}
}



Popup.prototype.createImage=function(){
 this.maxWidth=Math.round(this.screenWidth*0.97);
 this.maxHeight=Math.round(this.screenHeight*0.86);
 this.img=document.createElement("img");
 this.img.src=this.imageURL;
 this.ratio=this.popupWidth/this.popupHeight;
 this.maxRatio=this.maxWidth/this.maxHeight;

 if ( (this.popupWidth>this.maxWidth) || (this.popupHeight>this.maxHeight) ){
 if (this.ratio<this.maxRatio){
 this.img.width=Math.round(this.popupWidth*(this.maxHeight/this.popupHeight));
 this.img.height=this.maxHeight;
}else{
 this.img.height=Math.round(this.popupHeight*(this.maxWidth/this.popupWidth));
 this.img.width=this.maxWidth;
}
}else{
 
 this.img.width=this.popupWidth;
 this.img.height=this.popupHeight;
}
}


Popup.prototype.openCenteredWindow=function(){

 this.name=this.imageURL.split("/");
 this.name=this.name[this.name.length-1].replace(".", "_");

 var popup=window.open("", this.name, this.settings);


 var pd=popup.document;




 var innerHTML="<head><title>"+this.title+"</title></head><body style='margin: 0px; padding: 0px;'><table cellspacing=0 cellpadding=0 style='margin: 0; padding: 0; width: 100%; height: 100%;'><tr><td style='vertical-align: middle;'><img src='"+this.imageURL+"' style='display: block;'></td></tr></table></body>";
 pd.open();
 pd.write(innerHTML);
 pd.close();


 popup.focus();
}





function PopupHTML(activeLink){
 
 if (isArray(activeLink)){
 this.href=activeLink[0];
 this.popupWidth=activeLink[1];
 this.popupHeight=activeLink[2];
 this.scroll=activeLink[3];
}else{
 this.activeLink=activeLink;
 this.href=this.activeLink.getAttribute("href");
 this.popupWidth=this.activeLink.getAttribute("popupwidth");
 this.popupHeight=this.activeLink.getAttribute("popupheight");
 this.scroll=this.activeLink.getAttribute("popupscroll");
}
 
 this.screenWidth=screen.width;
 this.screenHeight=screen.height;
 this.left=(this.screenWidth-this.popupWidth)/2; 
 this.top=(this.screenHeight-this.popupHeight)/2-20;

 this.settings="toolbars='no'";
 this.settings+=",width="+this.popupWidth;
 this.settings+=",height="+this.popupHeight;
 this.settings+=",left="+this.left;
 this.settings+=",top="+this.top;

 if (this.scroll) this.settings+=",scrollbars=yes";
 
 this.openCenteredWindow();
 
}

PopupHTML.prototype.openCenteredWindow=function(){








 var tmp="";

 this.name=this.href;

 for (i=0; i<this.name.length; i++){
 if (
 (this.name.charAt(i)<'a') ||
 (this.name.charAt(i)>'z')
 ){
 tmp=tmp+"";
}else{
 tmp=this.name.charAt(i).toLowerCase();
}
}
 this.name=tmp;


 
 this.mywindow=window.open(this.href, this.name, this.settings);


 if (window.focus){
 this.mywindow.focus(); 
}
 
 return false;
}


function init_Popups(){
 var links=document.getElementsByTagName("a");
 for (var i=0; i<links.length; i++){
 if (links[i].getAttribute("rel")=="popup"){
 var parts=links[i].getAttribute("href").split(".");
 if (
 (parts[1]=="jpg") || (parts[1]=="gif") || (parts[1]=="png")
 ){
 var onclick_function=function (ev){
 if (!ev) var ev = window.event;


 new Popup(this);

 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation();
}else{
 ev.cancelBubble = true; ev.returnValue = false;
}
 return false;
}
}else{
 var onclick_function=function (ev){
 if (!ev) var ev = window.event;

 new PopupHTML(this);

 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation();
}else{
 ev.cancelBubble = true; ev.returnValue = false;
}
 return false;
}
}
 links[i].onclick=onclick_function;
}
}
}
var openedIDs;

function init_treemenu(divID)
{

 if (!document.getElementsByTagName) return; 

 var wtm_cookie='openedIDs';

 var buttonclass='wtmbutton';

 var imgOpen='/images/plus.png';
 var imgClose='/images/minus.png';
 var imgWidth=9;

 openedIDs=new Array();

 openedIDs=(document.getElementById('wtmactualid'))?document.getElementById('wtmactualid').value.split(','):[];

 openedIDs=(readCookie(wtm_cookie)?readCookie(wtm_cookie).split(','):openedIDs);



 if (!document.getElementById(divID)){return;}
 var wtmDIV = document.getElementById(divID); 
 var lists = wtmDIV.getElementsByTagName("li"); 
 for (var i=0; i<lists.length; i++) 
{
 var list=lists[i];
 list.menuid=i;

 if (list.getElementsByTagName('ul').length>0)
{

 var as=list.getElementsByTagName("a");

 for (var k=0; k<as.length; k++){

 var sHREF=as[k].getAttribute("href");
 var tHREF=document.location.pathname;

 if (sHREF.substr(sHREF.length-tHREF.length)==tHREF){


 openedIDs[openedIDs.length]=i;
}
}





 if (browser.isGecko){
 newimg=document.createElement('img');
 newimg.src=imgOpen;
 newimg.setAttribute("class", buttonclass);

 list.insertBefore(newimg, list.firstChild);


}else{
 list.innerHTML='<img src='+imgOpen+' class="'+buttonclass+'"> '+list.innerHTML;
}

 var img=list.getElementsByTagName("img")[0];

 if (inArray(openedIDs,i))
{
 ul=list.getElementsByTagName("ul")[0];
 img.src=(ul.style.display=='block'?imgOpen:imgClose);
 ul.style.display=(ul.style.display=='block'?'none':'block');
}


}else 
{
 list.style.paddingLeft=(imgWidth+5)+"px";
}// endif
}// endfor


 var imgs=wtmDIV.getElementsByTagName("img"); 


 for (var i=0; i<imgs.length; i++) 
{
 var img=imgs[i];
 if (
 (img.getAttribute("className") == buttonclass) || // IE
 (img.getAttribute("class") == buttonclass) // NS
 )
{// Ha talalunk felprogramozzunk az onclick-et
 img.onclick=function()
{


 var li=this.parentNode;

 ul=li.getElementsByTagName("ul")[0];

 this.src=(ul.style.display=='block'?imgOpen:imgClose);

 ul.style.display=(ul.style.display=='block'?'none':'block');

 if (ul.style.display=='block') 
{

 openedIDs[openedIDs.length]=li.menuid;
}else
{// vagy a csukast, azaz kitoroljuk a tombbol

 openedIDs=delElementWithValue(openedIDs,li.menuid);
}





 createCookie(wtm_cookie,openedIDs);
}// end of onclick function

}// end if class is good
}// end for img tags

}// end of w_treemenu_Init


function miracleSelector(id, submitid){


if (document.getElementById(id)){
 this.fieldset = document.getElementById(id);
}else{
 return false;
}

if (document.getElementById(submitid)){
 this.submit = document.getElementById(submitid);
}else{
 return false;
}

this.panels = new Array();
this.buttons = new Array();
this.original_si = new Array();

this.initPanels();
this.initButtons();
this.initSubmit();

}


miracleSelector.prototype.Move = function(str){
 alert(str);
}

miracleSelector.prototype.initPanels = function(){
 var panels=this.fieldset.getElementsByTagName("select");
 for (var i=0; i<panels.length; i++){
 this.panels[ panels[i].className ] = panels[i];
}
 var buttons=this.buttons;
 this.panels["left"].onfocus=function(){
 buttons["remove"].style.display="none";
 buttons["add"].style.display="inline";
}
 this.panels["right"].onfocus=function(){
 buttons["add"].style.display="none";
 buttons["remove"].style.display="inline";
}
}

miracleSelector.prototype.initButtons = function(){
 var buttons=this.fieldset.getElementsByTagName("button");
 for (var i=0; i<buttons.length; i++){
 this.buttons[ buttons[i].className ] = buttons[i];
}

 var selector=this;
 this.buttons["add"].onclick=function(){

 selector.moveOptions("left", "right");
 return false;
}
 this.buttons["remove"].onclick=function(){

 selector.moveOptions("right", "left");
 return false;
}
}

miracleSelector.prototype.moveOptions = function(from, to){
 var selected=getSelectedOptions(this.panels[from]);
 var selected_ids=new Array();

 var todo="add";
 if (to=="left") todo="del";

 for (var i=0; i<selected.length; i++){
 var si=selected[i]-i;
 var option=this.panels[from][si];
 
 selected_ids[i]=option.value;
 
 var clone=option.cloneNode(true);
 this.panels[from].removeChild(option);
 var firstbigger=getFirstBiggerOption(this.panels[to], option.firstChild.nodeValue);
 this.panels[to].insertBefore(clone, firstbigger);
}
 
 handleUDRM(selected_ids,todo);





}



miracleSelector.prototype.initSubmit = function(){
 var selector=this;
 this.submit.onclick=function(){
 var select=selector.panels["right"];
 for (var i=0; i<select.length; i++){
 select[i].selected=true;
}
 return true;
}
}


addEvent(window, 'load', init_tabs);

function init_tabs(){
 tabBoxes=new Array();
 var tabPanels=document.getElementsByTagNameAndAttribute("*", "tabbox", "/.+/");
 for (var i=0; i<tabPanels.length; i++){
 var tabPanel=tabPanels[i];


 if (tabPanel.getAttribute("tabpanel")) continue;
 
 var tabBox_name=tabPanel.getAttribute("tabbox");
 if (!tabBoxes[tabBox_name]){
 tabBoxes[tabBox_name]=new tabBox(tabBox_name);
}
 tabBoxes[tabBox_name].addTabPanel(tabPanel);
}
}


function tabBox(name){

this.name = name;
this.panels = new Array();
this.tabs = new Array();

}

tabBox.prototype.addTabPanel = function(panel){

 var id=new String(panel.getAttribute("id"));
 if (!id.match(/tab_.+_.+/)){
 return alert("MIRACLE_TABS: Error in panel name id attribute: "+id);
}
 var panelName=panel.getAttribute("id").split("_")[2];
 this.panels[panelName]=panel;
 this.addTabForPanel(panelName);
}

tabBox.prototype.addTabForPanel = function(panelName){

 var tabs=document.getElementsByTagNameAndAttribute("*", "tabpanel", panelName);

 for (var i=0; i<tabs.length; i++){
 if (tabs[i].getAttribute("tabbox")==this.name) break;
}
 if (tabs[i].getAttribute("tabbox")==this.name){
 this.tabs[panelName]=tabs[i];
}

 var panels=this.panels;
 this.tabs[panelName].onclick=function(){
 var panelName=this.getAttribute("tabpanel");
 for (var i in panels){
 if (i==panelName){
 panels[i].style.display="block";
}else{
 panels[i].style.display="none";
}
}
}// end of onclick
}


addEvent(window, 'load', init_FSCB);

function init_FSCB(){
 fieldsets=new Array();
 var fieldsets=document.getElementsByTagNameAndAttribute("fieldset", "class", "checkbox");
 for (var i=0; i<fieldsets.length; i++){
 var id=fieldsets[i].getAttribute("id");
 fieldsets[id]=new FSCB(id);
 fieldsets[id].addButtons();
}
}


function FSCB(id){

this.name = name;
this.fieldset = document.getElementById(id);

}

FSCB.prototype.addButtons = function(id){

 var fieldset=this.fieldset;
 var div=document.createElement("DIV");

}


addEvent(window, 'load', initPlugIns);

function initPlugIns(){
 if (miracle.config['miracle_plug-in']){

 var form=document.getElementsByTagName("form")[0];
 if (form){
 miracleSetFormButtonElements(form);

 Event.observe(form, "submit", function(event){
 this.submit();


 var parameters=new Array();
 parameters[0]=getBlockId();
 parameters[1]=arrayValues(miracleGetValuesFromForm(this));
 window.opener.miraclePlugInReturnValue=server_action("newsletter", "block_return", parameters, false);


 window.close();
 return false;
});

}
}
}

function getBlockId(){

 var url=new String(document.location).split("?");
 url=url[0];
 urlParts=new String(url).split("/");
 var tmp=urlParts[urlParts.length-1];

 return tmp;
}

function miracleSetFormButtonElements(form){
 var buttons=form.getElementsByTagName("button");
 for (var i in buttons){
 buttons[i].onclick=function(){
 form.submitButton=this.value;
}
}
}

function miracleGetValuesFromForm(form){
 var values=new Array();
 for (var i=0; i<form.elements.length; i++){
 var element=form.elements[i];
 var name=element.getAttribute("name");
 if (!name) continue; // ha nincs neve, akkor megyunk tovabb
 var value;
 switch (element.tagName){
 case "BUTTON":
 value=form.submitButton;
 break;
 default:
 value=element.value;
 break;
}
 values[name]=encode_utf8(value);
}
 return values;
}

var fileUpload=Class.create();



fileUpload.prototype ={

 initialize: function (fieldSetId){
 this.fieldSet=$(fieldSetId);
 this.id=this.fieldSet.getAttribute("id");
 this.legend=this.fieldSet.getElementsByTagName("legend")[0];
 this.files=this.fieldSet.getElementsByTagName("fieldset")[0];
 this.fileInputs=$(this.id+"_fileinput");
 this.maxFiles=this.fieldSet.getAttribute("maximum_files");

 this.fileInput=Form.getInputs(this.fieldSet, "file")[0];
 if (this.fileInput.getAttribute("accept")){
 this.accept=this.fileInput.getAttribute("accept").split(",");
 for (var i=0; i<this.accept.length; i++){
 this.accept[i]=this.accept[i].replace(/^\s+|\s+$/, '').toLowerCase();
}
}else{
 this.accept=new Array();
}

 this.fileInput.onchange=this.addFile.bindAsEventListener(this);

},

 fileExtension: function (filename){
 var tmp=filename.split(".");
 return tmp[tmp.length-1].toLowerCase();
},

 fileExists: function (filename){
 var files=Form.getInputs(this.files);
 for (var i=0; i<files.length; i++){
 if (files[i].value==filename){
 return true;
}
}
 return false;
},

 removeFile: function(e){
 var _this=Event.element(e);
 for (var i=0; i<this.selectedFiles.length; i++){
 if (this.selectedFiles[i].value==_this.id){
 new Element.remove(this.selectedFiles[i]);
 new Element.remove(_this.id);
 new Element.remove("fileinput_"+_this.id);
 this.fileInput.disabled=false;
}
}

 return false; 
},

 acceptableFile: function(filename){
 if (value.substring(0,1)!="/"){
 value=new RegExp("^"+value+"$", "i");
}else{
 value=new RegExp(value.substring(1, value.length-1), "i");
}
},


 addFile: function(e){
 if (this.fileExists(this.fileInput.value)){
 if ($("error")) new Element.remove("error");
 new Insertion.After(this.fileInput, '<span id="error">Ismétlés</span>')
}else{
 if ($("error")) new Element.remove("error");

 if (
 this.accept.length>0 &&
 !inArray(this.accept, this.fileExtension(this.fileInput.value))
 ){
 new Insertion.After(this.fileInput, '<span id="error">Érvénytelen fájltípus!</span>')
}else{

 if (this.maxFiles==1){
 this.fileInput.setAttribute('name', this.id);
}else{
 this.fileInput.setAttribute('name', this.id+"[]");
}

 var newInput = document.createElement("input");
 newInput.setAttribute('type', 'file');
 newInput.setAttribute('class', 'fileinput');
 $(this.fileInputs).appendChild(newInput);

 this.fileInput.setAttribute('id', "fileinput_"+this.fileInput.value);
 this.fileInput.style.display="none";

 var newDisplayInput=document.createElement("input");

 newDisplayInput.value=this.fileInput.value;
 this.files.appendChild(newDisplayInput);
 new Insertion.After(newDisplayInput, '<button id="'+newDisplayInput.value+'">Törlés</button>')
 $(newDisplayInput.value).onclick=this.removeFile.bindAsEventListener(this);
 this.selectedFiles=Form.getInputs(this.files);
 
 this.fileInput=newInput;
 this.fileInput.onchange=this.addFile.bindAsEventListener(this);
 if (this.selectedFiles.length==this.maxFiles){
 this.fileInput.disabled=true;
}
}
}
}

};

var miracleAjaxUpdater = Class.create();

miracleAjaxUpdater.prototype ={
 
 initialize: function(){


 this.elements = document.getElementsByTagNameAndAttribute("a", "ajax_target", "/.+/");
 this.elements.each(
 function(element){
 Event.observe(element, "click", this.onClick.bindAsEventListener(this));
}.bind(this)
 );

 Ajax.Responders.register({
 onComplete: function(){

 document.body.style.cursor = 'default';
}
})
},

 onClick: function(event){
 var source = Event.element(event);
 document.body.style.cursor = 'wait';
 source.style.cursor = 'wait';

 new Ajax.Updater(
 source.getAttribute("ajax_target"),
 source.href, 
{
 method: "get", 
 requestHeaders: ["X-Miracle-Request", "ajax_html"],
 evalScripts: true
});
 Event.stop(event);
 return false;
}

}


var miracleCheckbox = Class.create();

miracleCheckbox.prototype ={
 
 initialize: function(){

 this.miracleId=0;
 this.imageDirectory = "/images/";


 this.checkboxes = document.getElementsByTagNameAndAttribute("input", "src", "/.+/");
 this.checkboxes.each(
 function(checkbox){
 checkbox.miracle ={
 id : this.miracleId,
 onImage : this.imageDirectory+checkbox.getAttribute("src")+"_on.gif",
 offImage : this.imageDirectory+checkbox.getAttribute("src")+"_off.gif",
 image : document.createElement("img")
};

 checkbox.miracle.image.style.display = "inline";
 checkbox.miracle.image.src = checkbox.checked ? checkbox.miracle.onImage : checkbox.miracle.offImage;
 checkbox.miracle.image.miracle ={
 id : this.miracleId
}

 checkbox.parentNode.insertBefore(checkbox.miracle.image, checkbox.nextSibling);

 Event.observe(checkbox, "click", this.onClick.bindAsEventListener(this));
 Event.observe(checkbox.miracle.image, "click", this.onClick.bindAsEventListener(this));
 Element.hide(checkbox);
 this.miracleId++;
}.bind(this)
 );

},

 onClick: function(event){
 var source = Event.element(event);
 var id = source.miracle.id;
 var target = this.checkboxes[id];
 if (source.tagName == "IMG"){
 target.checked = !target.checked;
}
 target.miracle.image.src = target.checked ? target.miracle.onImage : target.miracle.offImage;
}

}


var miracleForm = Class.create();

miracleForm.prototype ={
 
 initialize: function(){
 this.repeats ={};
},

 init: function(){

 this.formAcceptNumeric();
 this.initAutoComplete();
 this.initAddress();
},

 replaceWithSelect: function(element){
 return this.replaceWith("select", element);
},

 replaceWithInput: function(element){
 return this.replaceWith("input", element);
},

 replaceWith: function(newElementType, element){
 var newElement = document.createElement(newElementType);
 newElement.id = element.id;
 newElement.name = element.name;
 element.parentNode.insertBefore(newElement, element);
 new Element.remove(element);
 return newElement;
},

 initAddress: function(){
 this.address = Class.create();
 this.address.prototype ={

 initialize: function (fieldset){
 this.fieldset = fieldset;
 this.zipCode = document.getElementsByClassName("zipcode", fieldset).first();
 this.city = document.getElementsByClassName("city", fieldset).first();
 this.streets = document.getElementsByClassName("streets", fieldset).first();
 this.streettypes = document.getElementsByClassName("streettypes", fieldset).first();
 this.streetNumber = document.getElementsByClassName("street_number", fieldset).first();
 Event.observe(this.zipCode, "change", this.updateCities.bindAsEventListener(this));
 Event.observe(this.streetNumber, "change", this.validateAddress.bindAsEventListener(this));
},

 validateAddress: function(event){
 var p ={
 zipcode: this.zipCode.value,
 city_id: this.city[this.city.selectedIndex].value,
 street_id: this.streets[this.streets.selectedIndex].value,
 street_type_id: this.streettypes[this.streettypes.selectedIndex].value,
 street_number: parseInt(this.streetNumber.value)
};

 var p2 = $H(p).values().findAll(
 function(value){
 return (value > 0);
}
 );
 if (p2.length == $H(p).values().length){
 miracle.ajax("miracle", "validate_address", p,

 function(address){
 if (address.first().street_number){
 this.streetNumber.value = address.first().street_number;
}
}.bind(this)
 );
}else{
 this.streetNumber.value = $N(this.streetNumber.value, "");
}
},

 updateCities: function(event){
 var zipCode = Event.element(event);
 miracle.ajax("miracle", "get_cities_by_zipcode", 
{
 zipcode: zipCode.value
}, 

 function(cities){
 var errors = document.getElementsByClassName("error", this.fieldset);
 if (cities.length > 0){
 if (errors.first()){
 this.fieldset.removeChild(errors.first());
}
 this.city = miracle.form.replaceWithSelect(this.city);
 miracle.form.updateSelect(this.city, cities);
 Event.observe(this.city, "change", this.updateStreets.bindAsEventListener(this));
 this.updateStreets();
}else{
 if (errors.length == 0){
 new Insertion.Bottom(this.fieldset, "<div class=error>Nincs ilyen iranyitoszam.</div>");
}
 this.city.value = "";
 this.zipCode.value = "";
 this.zipCode.focus();
}
}.bind(this)
 );
},

 updateStreets: function(event){
 var cityId = this.city.options[this.city.selectedIndex].value;
 miracle.ajax("miracle", "get_streets_by_zipcode_and_cityid", 
{
 zipcode: this.zipCode.value,
 city_id: cityId
}, 

 function(streets){
 this.streets = miracle.form.replaceWithSelect(this.streets);
 miracle.form.updateSelect(this.streets, streets);
 Event.observe(this.streets, "change", this.updateStreetTypes.bindAsEventListener(this));
 this.updateStreetTypes();
}.bind(this)
 );
},
 
 updateStreetTypes: function(event){
 var streetId = this.streets.options[this.streets.selectedIndex].value;
 var cityId = this.city.options[this.city.selectedIndex].value;
 miracle.ajax("miracle", "get_street_types_by_zipcode_and_cityid_and_streetid", 
{
 zipcode: this.zipCode.value,
 city_id: cityId,
 street_id: streetId
}, 

 function(streettypes){
 this.streettypes = miracle.form.replaceWithSelect(this.streettypes);
 miracle.form.updateSelect(this.streettypes, streettypes);
}.bind(this)
 );
}
}

 $$("fieldset.miracle_address").each(function(fieldset){
 new this.address(fieldset);
}.bind(this));

},

 initAutoComplete: function(){
 $$("input[miracle_autocomplete]").each(function(input){
 var updateDivId = input.id + "_autocomplete";
 new Insertion.After(input, '<div id="' + updateDivId + '" class="miracle_autocomplete"></div>');
 new Ajax.Autocompleter(input.id, updateDivId, '/-',{
 paramName: "autocomplete://" + input.getAttribute("miracle_autocomplete").replace(".", "/")
});
});
},

 autoSubmit: function(event){
 Event.findElement(event || window.event, "form").submit();
},

 formFixRadios: function(){
 if (!document.getElementsByTagName("input")) return false;
 miracle.addEventSelectorRule(
 "input[type=radio]:click", function(input, event){
 if (!input.miracleFirst){
 input.miracleFirst = true;
 input.miracleChecked = input.checked;
}else{
 input.miracle = !input.miracle;
 input.checked = input.miracle; 
}
}
 );
},

 OBSOLATE_formAcceptNumeric: function(){
 if (!document.getElementsByTagName("input")) return false;
 miracle.addEventSelectorRule(
 "input[accept=numeric]:keypress", function(input, event){
 var key = event.which || event.keyCode;
 printfire(event);
 printfire(event.which);
 printfire(event.keyCode);
 printfire(event.charCode);
 alert("WHICH " + event.which);
 alert("KEYCODE" + event.keyCode);
 alert("CHARCODE" + event.charCode);

 if (event.charCode == 0){
 alert("charCode 0");
 printfire("charCode 0");
 return true;
}
 if ( (event.charCode != 0) && [
 Event.KEY_BACKSPACE,
 Event.KEY_TAB,
 Event.KEY_RETURN,
 Event.KEY_ESC,
 Event.KEY_LEFT,
 Event.KEY_UP,
 Event.KEY_RIGHT,
 Event.KEY_DOWN,
 Event.KEY_DELETE,
 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, // szamok
 96, 97, 98, 99, 100, 101, 102, 103, 104, 105
 ].member(key) == false){
 Event.stop(event);
 printfire("denied");
}else{
 printfire("allowed");
}
}
 );
},

 XXX_formAcceptNumeric: function(){
 if (!document.getElementsByTagName("input")) return false;
 miracle.addEventSelectorRule(
 "input[accept=numeric]:keydown", function(input, event){
 var returnValue = false;
 printfire(event);
 printfire(event.which);
 printfire(event.keyCode);
 printfire(event.charCode);
 var keyCode = (event.which) ? event.which : event.keyCode;

 if ( ((keyCode >= 48) && (keyCode <= 57)) || // All numerics
 (keyCode == 8) || // Backspace
 (keyCode == 13) 
 ){
 returnValue = true;
}

 if (event.returnValue){
 event.returnValue = returnValue;
}

 return returnValue; 
}
 );
},

 CCCC_formAcceptNumeric: function(){
 return true;
 if (!document.getElementsByTagName("input")) return false;
 miracle.addEventSelectorRule(
 "input[accept=numeric]:change", function(input, event){
 printfire(input.value);
 if (parseInt(input.value, 10) != input.value){
 input.value = 
 input.miraclePreviousValue ? input.miraclePreviousValue : "";
 Event.stop(event);
}else{
 input.miraclePreviousValue = input.value;
}
}
 );
},

 formAcceptNumeric: function(){
 if (!document.getElementsByTagName("input")) return false;
 miracle.addEventSelectorRule(
 "input[accept=numeric]:keypress", function(input, event){
 miracle.form.maskInput(input, event, "9^");
}
 );

},


 getRequiredFields: function(parent){
 var parent = parent || document;
 var tmp = document.getElementsByClassName("required", parent);
 return tmp;
},

 getValue: function(element){



 if ($(element.getAttribute("htmlfor"))){
 var input = $(element.getAttribute("htmlfor"));
 return input.value;
}
 if ($(element.getAttribute("for"))){
 var input = $(element.getAttribute("for"));
 return input.value;
}

 if (Element.hasClassName(element, "radio")){
 return this._getValueForRadio(element);
}

 if (Element.hasClassName(element, "checkbox")){
 return this._getValueForCheckbox(element);
}

 if (element.tagName.toLowerCase() == "select"){
 var tmp = element.options[element.options.selectedIndex].value;
 tmp = (tmp == "NULL") ? false : tmp;
 return tmp;
}

 tmp = !tmp ? null : tmp;
 return tmp;
},

 _getValueForRadio: function(parent){
 return this._getValueForInputSelector(parent, "radio");
},

 _getValueForCheckbox: function(parent){
 return this._getValueForInputSelector(parent, "checkbox");
},

 _getValueForInputSelector: function(parent, type){
 var tmp;
 var checked = Form.getInputs(parent, type).find(function(radio){
 return radio.checked;
});
 if (checked) tmp = checked.value;
 return tmp;
},

 findParentNode: function(element, parentNodeTagName){
 var parentNodeTagName = parentNodeTagName || "div";
 while (
 element.parentNode 
 && (!element.tagName 
 || (element.tagName.toUpperCase() != parentNodeTagName.toUpperCase()))
 ){
 element = element.parentNode;
}
 return element;
},

 errorForField: function(element, parentNodeTagName, action){
 var parentNode = this.findParentNode(element, parentNodeTagName);
 (action == "add" ) ? 
 Element.addClassName(parentNode, "error") :
 Element.removeClassName(parentNode, "error");
},

 isRequiredFieldsFilled: function(parent){
 printfire(this.getRequiredFields(parent).length + " required field");
 var tmp = this.getRequiredFields(parent).all(function(element){
 var value = miracle.form.getValue(element);
 if (!value){
 miracle.form.errorForField(element, "td", "add");

}else{
 miracle.form.errorForField(element, "td", "remove");
}
 return value;
});
 printfire("isReq: " + tmp);
 return tmp;
},


 maskInput: function (f, e, m){
 e.key = (e.which + 1 || e.keyCode + 1) - 1 || 0;
 printfire(f.value);
 printfire(e.key);
 printfire(m);
 var patterns ={"1": /[A-Z]/i, "2": /[0-9]/, "4": /[A-y]/i, "8": /./};
 var rules ={"a": 3, "A": 7, "9": 2, "C":5, "c": 1, "*": 8};

 function accept(c, rule){
 for (var i = 1, r = rules[rule] || 0; i <= r; i<<=1)
 if (r & i && patterns[i].test(c)) break;
 return i <= r || c == rule;
}

 var k, mC, r, c = String.fromCharCode(k = e.key), l = f.value.length;
 (!k || k == 8 ? 1 : (r = /^(.)\^(.*)$/.exec(m)) && (r[0] = r[2].indexOf(c) + 1) + 1 ?
 r[1] == "O" ? r[0] : r[1] == "E" ? !r[0] : accept(c, r[1]) || r[0]
 : (l = (f.value += m.substr(l, (r = /[A|9|C|\*]/i.exec(m.substr(l))) ?
 r.index : l)).length) < m.length && accept(c, m.charAt(l))) || e.preventDefault();
},


 updateSelect: function(id, options){
 var i = options.length;

 if (!(select = $(id))) return false;
 select.options.length = 0;




 var innerHTM = "";
 for (var i = 0; i<options.length; i++){



 select.options[i] = new Option(options[i].option, options[i].value);
}


 return true;
},

 addOptions: function(id, options){
 if (!(select = $(id))) return false;
 var startLength = select.options.length;
 for (var i = 0; i<options.length; i++){
 select.options[startLength + i] = new Option(options[i].option, options[i].value);
}
}

}// end of class

var miracleTabs = Class.create();

miracleTabs.prototype ={

 initialize: function(){

 this.containers = document.getElementsByClassName("miracle_tab_container");

 this.containers.each(function(container, i){



 container.miracle ={
 id: i
};
 this.initializeContainer(container);
}.bind(this)); 


},

 initializeContainer: function(container){

 var ulId = "miracle_tab_control_" + (container.miracle.id + 1);

 var tabControlHTML = "<ul id='"+ulId+"' class='miracle_tab_control'>";

 container.setAttribute("id", "miracle_tab_container_" + (container.miracle.id + 1));

 container.panels = $$("#" + container.id + " .miracle_tab_panel");
 var titles = $$("#" + container.id + " h1");

 container.panels.each(function(panel, i){

 panel.miracle ={
 id: i
};

 if (!Element.hasClassName(panel, "active")){
 Element.hide(panel);
 var active = " class='tab_" + (i + 1) + "'";
 var id = " id='" + ulId + "_tab_" + (i + 1) + "'";
}else{

 var active = " class='active tab_" + (i + 1) + "'";
 var id = " id='" + ulId + "_tab_" + (i + 1) + "_active'";
}


 tabControlHTML = tabControlHTML + "<li " + id + active + "><span><a href='#'>" + (titles[i].innerHTML) + "</a></span></li>";
 Element.hide(titles[i]);

}.bind(this)); // ugyanazert van itt a bind, bar most eppen nem hasznaltuk ki

 tabControlHTML = tabControlHTML + "</ul>";

 new Insertion.Top(container, tabControlHTML);

 container.tabControl = $(ulId);

 this.initializeTabControl(container);
},

 initializeTabControl: function(tabContainer){

 $$("#"+tabContainer.tabControl.id+" li a").each(function(aTab, i){


 Event.observe(aTab, "click", this.switchTab.bindAsEventListener(this));

 aTab.miracle ={
 container: tabContainer,
 panel: tabContainer.panels[i]
};

 tabContainer.panels[i].miracle ={
 tab: aTab
};
}.bind(this)); // itt se hasznaltunk this-t, de ez mar megszokas... :)
},

 switchTab: function(event){

 var source = Event.element(event);

 Event.stop(event);

 if (Element.hasClassName(source.parentNode, "active")){

 source.parentNode.firstChild.blur();

 return false;
}

 var control = source.parentNode.parentNode.parentNode;

 var previousNotFilled;
 var actived;


 $$("#" + control.id + " li").any(function(liTab, i){

 var tab = liTab.firstChild.firstChild;

 

 $A(tab.miracle.panel.getElementsByTagName("td")).each(function(cell){
 Element.removeClassName(cell, "error");
});

 var notFilled = !miracle.form.isRequiredFieldsFilled(tab.miracle.panel);

 if ( (tab == source) ){
 actived = i;
 printfire(i + "add active");

 Element.addClassName(liTab, "active");
 liTab.setAttribute("id", liTab.getAttribute("id").replace("_active", "") + "_active");

 Element.show(tab.miracle.panel);
 printfire("Show: " + tab.miracle.panel);

 liTab.firstChild.blur();
 if (notFilled) return notFilled;
}else{
 printfire("I: "+i);
 printfire("ACTIVED: "+actived);

 if (!notFilled || (i > actived)){

 printfire(i + "remove active");
 Element.removeClassName(liTab, "active");
 liTab.setAttribute("id", liTab.getAttribute("id").replace("_active", ""));

 Element.hide(tab.miracle.panel);
}
}

 previousNotFilled = notFilled;
 return notFilled;
});

 return false;
}

}// end of class




var hexcase = 0; 
var b64pad = "";
var chrsz = 8; 


function hex_md5(s){return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
function b64_md5(s){return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
function str_md5(s){return binl2str(core_md5(str2binl(s), s.length * chrsz));}
function hex_hmac_md5(key, data){return binl2hex(core_hmac_md5(key, data));}
function b64_hmac_md5(key, data){return binl2b64(core_hmac_md5(key, data));}
function str_hmac_md5(key, data){return binl2str(core_hmac_md5(key, data));}


function md5_vm_test()
{
 return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
}


function core_md5(x, len)
{
 
 x[len >> 5] |= 0x80 << ((len) % 32);
 x[(((len + 64) >>> 9) << 4) + 14] = len;

 var a = 1732584193;
 var b = -271733879;
 var c = -1732584194;
 var d = 271733878;

 for(var i = 0; i < x.length; i += 16)
{
 var olda = a;
 var oldb = b;
 var oldc = c;
 var oldd = d;

 a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
 d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
 c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
 b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
 a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
 d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
 c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
 b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
 a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
 d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
 c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
 b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
 a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
 d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
 c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
 b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);

 a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
 d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
 c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
 b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
 a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
 d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
 c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
 b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
 a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
 d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
 c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
 b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
 a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
 d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
 c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
 b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);

 a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
 d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
 c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
 b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
 a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
 d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
 c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
 b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
 a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
 d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
 c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
 b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
 a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
 d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
 c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
 b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);

 a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
 d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
 c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
 b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
 a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
 d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
 c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
 b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
 a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
 d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
 c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
 b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
 a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
 d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
 c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
 b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);

 a = safe_add(a, olda);
 b = safe_add(b, oldb);
 c = safe_add(c, oldc);
 d = safe_add(d, oldd);
}
 return Array(a, b, c, d);

}


function md5_cmn(q, a, b, x, s, t)
{
 return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
 return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
 return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
 return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
 return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}


function core_hmac_md5(key, data)
{
 var bkey = str2binl(key);
 if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);

 var ipad = Array(16), opad = Array(16);
 for(var i = 0; i < 16; i++)
{
 ipad[i] = bkey[i] ^ 0x36363636;
 opad[i] = bkey[i] ^ 0x5C5C5C5C;
}

 var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
 return core_md5(opad.concat(hash), 512 + 128);
}


function safe_add(x, y)
{
 var lsw = (x & 0xFFFF) + (y & 0xFFFF);
 var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
 return (msw << 16) | (lsw & 0xFFFF);
}


function bit_rol(num, cnt)
{
 return (num << cnt) | (num >>> (32 - cnt));
}


function str2binl(str)
{
 var bin = Array();
 var mask = (1 << chrsz) - 1;
 for(var i = 0; i < str.length * chrsz; i += chrsz)
 bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
 return bin;
}


function binl2str(bin)
{
 var str = "";
 var mask = (1 << chrsz) - 1;
 for(var i = 0; i < bin.length * 32; i += chrsz)
 str += String.fromCharCode((bin[i>>5] >>> (i % 32)) & mask);
 return str;
}


function binl2hex(binarray)
{
 var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
 var str = "";
 for(var i = 0; i < binarray.length * 4; i++)
{
 str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
 hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
}
 return str;
}


function binl2b64(binarray)
{
 var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 var str = "";
 for(var i = 0; i < binarray.length * 4; i += 3)
{
 var triplet = (((binarray[i >> 2] >> 8 * ( i %4)) & 0xFF) << 16)
 | (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
 | ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
 for(var j = 0; j < 4; j++)
{
 if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
 else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
}
}
 return str;
}
//Sweet Titles (c) Creative Commons 2005



Array.prototype.inArray = function (value){
 var i;
 for (i=0; i < this.length; i++){
 if (this[i] === value){
 return true;
}
}
 return false;
};


var sweetTitles ={
 xCord : 0, // @Number: x pixel value of current cursor position
 yCord : 0, // @Number: y pixel value of current cursor position
 tipElements : ['abbr','acronym', 'img'], // @Array: Allowable elements that can have the toolTip
 obj : Object, // @Element: That of which you're hovering over
 tip : Object, // @Element: The actual toolTip itself
 active : 0, // @Number: 0: Not Active || 1: Active
 init : function(){
 if ( !document.getElementById ||
 !document.createElement ||
 !document.getElementsByTagName ){
 return;
}
 var i,j;
 this.tip = document.createElement('div');
 this.tip.id = 'toolTip';
 document.getElementsByTagName('body')[0].appendChild(this.tip);
 this.tip.style.top = '0';
 this.tip.style.visibility = 'hidden';
 var tipLen = this.tipElements.length;
 for ( i=0; i<tipLen; i++ ){
 var current = document.getElementsByTagName(this.tipElements[i]);
 var curLen = current.length;
 for ( j=0; j<curLen; j++ ){
 if (current[j].title){
 addEvent(current[j],'mouseover',this.tipOver);
 addEvent(current[j],'mouseout',this.tipOut);
 current[j].setAttribute('tip',current[j].title);
 current[j].removeAttribute('title');
}
}
}
},
 updateXY : function(e){
 if ( document.captureEvents ){
 sweetTitles.xCord = e.pageX;
 sweetTitles.yCord = e.pageY;
}else if ( window.event.clientX ){
 sweetTitles.xCord = window.event.clientX+document.documentElement.scrollLeft;
 sweetTitles.yCord = window.event.clientY+document.documentElement.scrollTop;
}
},
 tipOut: function(){
 if ( window.tID ){
 clearTimeout(tID);
}
 if ( window.opacityID ){
 clearTimeout(opacityID);
}
 sweetTitles.tip.style.visibility = 'hidden';
},
 checkNode : function(){
 var trueObj = this.obj;
 
 if ( this.tipElements.inArray(trueObj.nodeName.toLowerCase()) ){
 return trueObj;
}else{
 return trueObj.parentNode;
}
},
 
 tipOver : function(e){
 sweetTitles.obj = this;
 tID = window.setTimeout("sweetTitles.tipShow()", 10);
 sweetTitles.updateXY(e);
},
 tipShow : function(){
 var scrX = Number(this.xCord);
 var scrY = Number(this.yCord);
 var tp = parseInt(scrY+15);
 var lt = parseInt(scrX+10);
 var anch = this.checkNode();
 var addy = '';
 var access = '';
 if ( anch.nodeName.toLowerCase() == 'a' ){
 addy = (anch.href.length > 25 ? anch.href.toString().substring(0,25)+"..." : anch.href);
 var access = ( anch.accessKey ? ' <span>['+anch.accessKey+']</span> ' : '' );
}else{
 if (anch.firstChild){
 addy = anch.firstChild.nodeValue;
}
}
 this.tip.innerHTML = "<p>"+anch.getAttribute('tip')+"<em>"+access+addy+"</em></p>";
 if ( parseInt(document.documentElement.clientWidth+document.documentElement.scrollLeft) < parseInt(this.tip.offsetWidth+lt) ){
 this.tip.style.left = parseInt(lt-(this.tip.offsetWidth+10))+'px';
}else{
 this.tip.style.left = lt+'px';
}
 if ( parseInt(document.documentElement.clientHeight+document.documentElement.scrollTop) < parseInt(this.tip.offsetHeight+tp) ){
 this.tip.style.top = parseInt(tp-(this.tip.offsetHeight+10))+'px';
}else{
 this.tip.style.top = tp+'px';
}
 this.tip.style.visibility = 'visible';
 this.tip.style.opacity = '.1';
 this.tipFade(10);
},
 tipFade: function(opac){
 var passed = parseInt(opac);
 var newOpac = parseInt(passed+10);
 if ( newOpac < 80 ){
 this.tip.style.opacity = '.'+newOpac;
 this.tip.style.filter = "alpha(opacity:"+newOpac+")";
 opacityID = window.setTimeout("sweetTitles.tipFade('"+newOpac+"')",20);
}
 else{
 this.tip.style.opacity = '.80';
 this.tip.style.filter = "alpha(opacity:80)";
}
}
};



var d = document;

var miracleConfig=new Array();

var FORBIDDEN="[[-- FORBIDDEN --]";

var Miracle = Class.create();

Miracle.prototype ={


 initialize: function(){
 this.initActions = new Array();

 this.eventSelectorRules = new Object();
 this.isEventSelectorRules = false;
 this.initDone = false;


 this.isIE = document.all && window.attachEvent ? true : false;

 this.config = new Array();
 this.config.fleXcroll=new Array();
 this.config.miracleHoverEmulation=new Array();

 this.config.fixEolas = true;
 this.config.initExtensions = new Array();
 this.config.initExtensions.lightBox = false;

 this.config.initExtensions.calendar = true;
 this.config.initExtensions.fleXcroll = true;
 this.config.initExtensions.mooFX = false;
 this.config.initExtensions.sweetTitles = false;
 this.config.initExtensions.wysiwyg = true;

 this.config.initExtensions.miracleAjaxUpdater = false;
 this.config.initExtensions.miracleCheckbox = false;
 this.config.initExtensions.miraclePopup = false;
 this.config.initExtensions.miracleTab = false;
 this.config.initExtensions.miracleHover = true;
 this.config.initExtensions.miracleTargetBlank = true;

 this.config.initExtensions.miracleFileUploads = true;

 this.form ={};
 this.tabs ={};
 this.tree ={};


},

 
 init: function(){

 if (this.initDone) return;

 this.initDone=true;

 if (_timer){
 clearInterval(_timer);
 _timer = null;
}

 this.loadMetaConfig();

 this.fixEolas();

 if (this.config.initExtensions.lightBox){
 myLightbox = new Lightbox();
}

 if (this.config.initExtensions.calendar){
 this.initCalendar();
}

 if (this.config.initExtensions.fleXcroll){
 this.initFleXcroll();
}

 if (this.config.initExtensions.mooFX){
 this.initMooFX();
}

 if (this.config.initExtensions.sweetTitles){
 sweetTitles.init();
}

 if (this.config.initExtensions.wysiwyg){
 this.initWysiwyg();
}

 if (this.config.initExtensions.miracleAjaxUpdater){
 new miracleAjaxUpdater();
}

 if (this.config.initExtensions.miracleCheckbox){
 new miracleCheckbox();
}

 if (this.config.initExtensions.miracleHover){
 this.initMiracleHover();
}

 if (this.config.initExtensions.miracleFileUploads){
 this.initMiracleFileUploads();
}

 if (this.config.initExtensions.miraclePopup){
 this.initMiraclePopups();
}

 if (this.config.initExtensions.miracleTab){
 this.tabs = new miracleTabs();
}

 if (this.config.initExtensions.miracleTargetBlank){
 this.initMiracleTargetBlank();
}

 for (var i=0; this.initActions.length>i; i++){
 if (typeof this.initActions[i] == "function"){
 this.initActions[i]();
}
}

 this.initAjax();
 this.form.init();

 this.startEventSelectors();
},

 forceInit: function(){
 this.initDone = false;
 this.init();
},

 

 
 addEventSelectorRule: function (selector, eventFunction){
 this.eventSelectorRules[selector] = eventFunction;
},

 
 ajax: function(module, method, parameters, callback){
 miracle.ajaxIndicator(true);
 var callback = callback || false;
 var options ={
 asynchronous: false, 
 method: "post",
 parameters: "module=" + module
 + "&method=" + method
 + "&parameters=" + JSON.stringify(parameters)
};
 if (callback){
 options.asynchronous = true;
 options.onSuccess = function (xmlhttp){
 var response = eval(xmlhttp.responseText);
 callback(response);
 miracle.ajaxIndicator(false);
}
}
 var myAjax = new Ajax.Request("/-/", options);
 if (callback){
 return true;
}
 console.log(options);
 var tmp = myAjax.success() ? eval(myAjax.transport.responseText) : "";
 miracle.ajaxIndicator(false);
 return tmp;
},

 ajaxAction: function(element, module, action, entity){
 if (browser.isOpera){
 action = action.split("/").last();
}
 var params = new Array();
 for (var i=4; i<arguments.length; i++){
 params[i-4]=arguments[i];
}
 if (!element.src){// ha nem kep
 var checked = element.getAttribute("inverse") ? !element.checked : element.checked;
 params.push(checked);
}
 if (
 (action.substring(0, 6)!="delete") ||
 (action.substring(0, 6)=="delete" && confirm("Biztos törlöd?")) 
 ){
 var tmp = miracle.ajax(module, action, params, false);
}

 switch (tmp){
 case FORBIDDEN: 
 if (!element.src){// ha nem kep
 element.checked=!element.checked;
}
 alert("Letiltva!");
 return false;
 break;

 case false:
 alert("Error... :(");
 return false;
 break;

 case null:
 case "":
 alert("Error in function call... :(");
 return false;
 break;
}

 if (tmp && (action=="delete" || action=="delete_"+entity)){
 var trId=entity+"_"+element.getAttribute("recordid")+"_tr";
 var tr=document.getElementById(trId);
 var parent=tr;
 if (parent){
 do{
 parent=parent.parentNode;
}while (parent.tagName != "TABLE");
 parent.deleteRow(tr.rowIndex);
 var recordCountId = "miracle_pager_record_count";
 if ($(recordCountId)){
 $(recordCountId).innerHTML = 
 $(recordCountId).innerHTML - 1;
}
}else{
 alert("Error! #"+trId+" not found! Can't delete the row!");
}
}
},

 ajaxIndicator: function(status){
 var indicatorId = "miracle_ajax_indicator";
 var indicator = $(indicatorId);
 if (indicator){
 if (status == false){
 Element.hide(indicator);
}else{
 Element.show(indicator);
}
}else{
 new Insertion.Top("body", "<div id='" + indicatorId + "' class='fixed'><img src='/images/miracle/icon_ajax.gif' /></div>");
}
},

 ajaxMessage: function(message){
 var id="miracle_ajax_message";
 var ajaxMessage = $(id);
 var fakeBody = $$("body div")[0];
 if (!ajaxMessage){
 var HTML="<div id='" + id + "'>" + message+ "</div>";
 new Insertion.Top(fakeBody, HTML);
}else{
 Effect.Appear('miracle_ajax_message',{duration: 0.0});
 ajaxMessage.innerHTML=message;
}
 window.setTimeout("Effect.Fade('miracle_ajax_message')", 4000);
},

 

 fixEolas: function(){
 if (!this.config.fixEolas || !this.isIE) return;
 $A(document.getElementsByTagName("noscript")).each(function(node){
 if (node.className == "eolas"){
 node.outerHTML = node.innerHTML.replace("<![endif]-->", "");
}
});
},

 ieFixQuotes: function(){
 var quotes = document.getElementsByTagName("q");
 printfire(quotes);
},

 
 hoverEmulation: function(id){
 this.config.miracleHoverEmulation[this.config.miracleHoverEmulation.length] = id;
},

 
 fleXcroll: function(id){
 this.config.fleXcroll[this.config.fleXcroll.length]=id;
},




 include: function(url){
 var myAjax = new Ajax.Request(url,{
 method: "get",
 asynchronous: false
});

 var tmp = myAjax.responseIsSuccess() ? myAjax.transport.responseText : "";
 return tmp;
},

 includeExternalCSS: function(url){

 var node=document.createElement("link");
 node.setAttribute("rel", "stylesheet");
 node.setAttribute("type", "text/css");
 node.setAttribute("media", "screen");
 node.setAttribute("href", url);
 document.getElementsByTagName("head")[0].appendChild(node);
},

 initAction: function(event){
 this.initActions.push(event);
},

 
 initAjax: function(){
 $A($$("table.lister")).each(function(lister){
 var module = lister.getAttribute("module");
 var entity = lister.getAttribute("entity");
 if (!entity) entity = "record";

 if (lister.getAttribute("ajax")){
 $A(lister.getElementsByTagName("*")).each(function(element){
 var action = element.getAttribute("action");
 var parameters = element.getAttribute("parameters");
 if (action && parameters){
 var message = element.getAttribute("message");
 Event.observe(element, 'click', function(){
 if (message) miracle.ajaxMessage(message);
 miracle.ajaxAction(this, module, action, entity, parameters);
});
}
});
}
});
 
},

 initCalendar: function(){


 var dates=document.getElementsByTagNameAndAttribute("input", "accept", "/date|datetime/");
 if (dates.length==0) return false;
 eval(this.include("/jscalendar/calendar.js"));

 if (typeof(Calendar)!="function") return false;

 this.includeExternalCSS("/jscalendar/calendar-blue2.css");

 var icon=document.createElement("img");
 icon.setAttribute("src", "/images/miracle/icon_calendar.png");
 icon.setAttribute("width", 16);
 icon.setAttribute("height", 16);
 icon.setAttribute("class", "calendar");
 
 eval(this.include("/jscalendar/lang/calendar-hu-utf8.js"));
 eval(this.include("/jscalendar/calendar-setup.js"));

 for (var i=0; i<dates.length; i++){
 var id=dates[i].getAttribute("id");
 var imgId=id+"-calendar";
 switch (dates[i].getAttribute("accept")){
 case "datetime":
 var showsTime=true;
 var ifFormat="%Y-%m-%d %H:%M:%S";
 break;
 case "date":
 var showsTime=false;
 var ifFormat="%Y-%m-%d";
 break;
}
 var newIcon=icon.cloneNode(true);
 newIcon.setAttribute("id", imgId);
 DOM_InsertAfter(dates[i], newIcon);
 Calendar.setup({
 inputField: id, // id of the input field
 ifFormat: ifFormat, // format of the input field
 showsTime: showsTime, // will display a time selector
 button: imgId, // trigger for the calendar (button ID)
 singleClick: false, // double-click mode
 step: 1, // show all years in drop-down boxes (instead of every other year as default)
 timeFormat: 24,
 showOthers: true
});
}
}, // end of initCalendar


 initFleXcroll: function(){
 var tmp = new Array();
 this.config.fleXcroll.each(function(id){
 if (document.getElementById(id)){
 tmp[tmp.length] = id;
}
});
 if (tmp.length > 0){
 eval(this.include("/js/flexcroll.js"));

 if (typeof(CSBfleXcroll) != "function") return false;

 tmp.each(function(id){
 if (document.getElementById(id)){
 CSBfleXcroll(id);
}
});
}
},

 initMiracleCheckbox: function(){
 var inputs=document.getElementsByTagNameAndAttribute("input", "src", "/.+/");
 for (var i=0; i<inputs.length; i++){
 new miracleCheckbox(inputs[i]);
}

},

 initMiracleFileUploads: function(){
 var fups=new Array();
 var j=0;
 var elements=document.getElementsByTagNameAndAttribute("fieldset", "class", "file_upload");
 for (var i=0; i<elements.length; i++){
 fups[j]=new fileUpload(elements[i].getAttribute("id"));
 j++;
}
},

 initMiracleHover: function(){
 if (!this.isIE) return;
 this.config.miracleHoverEmulation.each(function(selector){
 $A($(selector).getElementsByTagName("li")).each(function(node){
 Event.observe(node, 'mouseover', function(){
 Element.addClassName(this, "hover");
}.bindAsEventListener(node), false);
 Event.observe(node, 'mouseout', function(){
 Element.removeClassName(this, "hover");
}.bindAsEventListener(node), false);
});
});
},

 initMiraclePopups: function(){

 init_Popups();
},

 
 initMiracleTargetBlank: function(){
 var nodes=document.getElementsByTagName("a");
 for (var i=0; i<nodes.length; i++){
 if (nodes[i].getAttribute("rel")=="external"){
 nodes[i].target = "_blank";
}
}
},

 initMooFX: function(){


},


 initWysiwyg: function(){
 this.addEventSelectorRule(
 'textarea', function (element){
 var editor=element.getAttribute("wysiwyg");
 if (editor){
 var fn="miracle.initWysiwyg_"+editor;
 if (eval(fn)){
 eval(fn+"(element);");
}
}
}
 );
},

 initWysiwyg_fckeditor: function(textarea){
 window.oFCKeditors=new Array();
 if (typeof(FCKeditor)=="undefined"){
 eval(this.include("/fckeditor/fckeditor.js"));
}
 if (typeof(FCKeditor)!="undefined"){
 var name=textarea.getAttribute("name");
 var id=textarea.getAttribute("id");
 var height=textarea.getAttribute("wysiwyg_height");
 textarea.setAttribute("id", name);
 window.oFCKeditors[id]=new FCKeditor(name, "100%", height);
 window.oFCKeditors[id].Config['CustomConfigurationsPath']='/fckeditor/miracle_fckconfig.js';
 window.oFCKeditors[id].ToolbarSet = textarea.getAttribute("wysiwyg_toolbar") || "Default";
 window.oFCKeditors[id].ReplaceTextarea();
 textarea.setAttribute("id", id);
}
},

 isImagesOn: function(){
 if (this.imagesOn){
 return true;
}
 this.imagesOn=false;
 var test = new Image();
 var tmp = new Date();
 var suffix = tmp.getTime();
 test.src = '/favicon.ico?'+suffix;
 test.onload = function(){
 miracle.imagesOn=true;
};
},

 loadMetaConfig: function(){
 var metas=document.getElementsByTagName("meta");
 for (var i=0; i<metas.length; i++){
 var name=new String(metas[i].getAttribute("name"));
 var content=metas[i].getAttribute("content");
 if (name.substring(0, 8)=="miracle_"){
 this.config[name]=content;
}
}
},

 
 startEventSelectors: function(){
 EventSelectors.start(this.eventSelectorRules);
}

}





var miracle = new Miracle();

miracle.form = new miracleForm();


miracle.tree = Class.create();

miracle.tree.prototype ={
 
 initialize: function(id){

 if (!$(id)) return false;

 miracle.tree[id] = this;
 this.tree = $(id);
 Element.addClassName(this.tree, "miracle_tree");

 this.image ={
 open : "/images/plus.png",
 close :"/images/minus.png",
 width : 9
};

 $A(this.tree.getElementsByTagName("li")).each(function(liNode, liId){
 if (liNode.getElementsByTagName("ul").length > 0){
 this.addImage(liNode);
 $A(liNode.getElementsByTagName("a")).each(function(aNode, aId){
 if (aNode.href == document.location){

}
}.bind(this));
}
}.bind(this));
},

 addImage: function(liNode){
 var open = Element.visible(this.getSubMenu(liNode));
 var newImg = document.createElement('img');
 newImg.src = open ? this.image.close : this.image.open;
 Element.addClassName(newImg, "miracle_tree");
 liNode.insertBefore(newImg, liNode.firstChild);
 Event.observe(liNode, "click", this.doClick.bindAsEventListener(this));
},

 doClick: function(event){
 var liNode = Event.findElement(event, "li");
 Element.toggle(this.getSubMenu(liNode));
 this.getImageIcon(liNode).src = Element.visible(this.getSubMenu(liNode)) ?
 this.image.close : this.image.open;
},

 getImageIcon: function(liNode){
 return liNode.getElementsByTagName("img")[0];
},

 getSubMenu: function(liNode){
 return liNode.getElementsByTagName("ul")[0];
}


}// end of class
miracle.form.repeat = Class.create();

miracle.form.repeat.prototype ={
 
 initialize: function(id, counter, counterRegExp){
 if (!d.getElementById(id)) return false;
 this.maxCounter = counter || 999;
 this.counter = 0;
 this.counterRegExp = counterRegExp || "[]";
 miracle.form.repeats[id] = this;
 this.id = id;
 this.container = $(this.id);
 this.masterHTML = this.createMaster();
 this.addNewButton();
 this.doAdd();
 this.newButtonId = this.id + "_new_button";
},

 addNewButton: function(){



 this.newButton = document.createElement("button");
 this.newButton.id = this.newButtonId;
 this.newButton.innerHTML = "Add";
 this.container.appendChild(this.newButton);


 Event.observe(this.newButton, "click", this.doAdd.bindAsEventListener(this));
},


 createMaster: function(){
 var master = $(this.id).innerHTML;
 $(this.id).innerHTML = "";
 return master;
},

 doAdd: function(event){



 var removeButton = document.createElement("button");
 removeButton.innerHTML = "Remove";
 Event.observe(removeButton, "click", this.doRemove.bindAsEventListener(this));


 var newBlock = document.createElement("div");

 new Insertion.Top(newBlock, this.masterHTML);




 newBlock.appendChild(removeButton);
 Element.addClassName(newBlock, "repeat");



 var elements = Form.getElements(newBlock);
 elements.each(function(elem){
 var oldPattern = this.counterRegExp.replace("@", "");
 var newPattern = this.counterRegExp.replace("@", "[" + this.counter + "]");
 var newName = elem.getAttribute("name").replace(oldPattern, newPattern);
 elem.setAttribute("name", newName)
}.bind(this));

 this.container.insertBefore(newBlock, this.newButton);

 this.counter++;
 if (this.counter == this.maxCounter){
 Element.hide(this.newButton);
}
 if (event) Event.stop(event);
 return false;
},

 doRemove: function(event){

 var block = Event.element(event).parentNode;

 block.parentNode.removeChild(block);
 this.counter--;
 if (this.counter < this.maxCounter){
 Element.show(this.newButton);
}
 return false;
}


}// end of class


function init(){
 miracle.init();
}


if (document.addEventListener){
 document.addEventListener("DOMContentLoaded", init, false);
}

if (browser.isIE){
 document.write("<script id=__ie_onload defer src=javascript:void(0)><\/script>");
 var script = document.getElementById("__ie_onload");
 script.onreadystatechange = function(){
 if (this.readyState == "complete"){
 init(); // call the onload handler
}
};
}


if (/WebKit/i.test(navigator.userAgent)){// sniff
 var _timer = setInterval(function(){
 if (/loaded|complete/.test(document.readyState)){
 init(); // call the onload handler
}
}, 10);
}


window.onload = init;


function server_action(module, method, parameters){
 return miracle.ajax(module, method, parameters);
}
 // ez lesz a he osztaly, igazabol csak nevterkent hasznaljuk, nincs tenyleges peldanya
HE ={




 init: function(){
 miracle.initAction(this.initAction.bind(this));
},

 initAction: function(){
 this.initBooking();
},

 initBooking: function(){


 $A(document.getElementsByClassName("addtocart")).each(function(img){

 Event.observe(img, "click", this.addCart.bindAsEventListener(this));
}.bind(this));

 this.cart = $("cart");
 this.cart_content = false;
 if (this.cart == null){
 this.cart = $("cart_content");
 this.cart_content = true;
}
 this.cartCurrencyChange = $("cart_currency_change");
 this.cart_content_currency = false;
 if (this.cartCurrencyChange == null){
 this.cartCurrencyChange = $("cart_content_currency_change");
 this.cart_content_currency = true;
}
 if (this.cart){
 Event.observe(this.cart, "click", this.doCartClick.bindAsEventListener(this));
}
 if (this.cartCurrencyChange){
 Event.observe(this.cartCurrencyChange, "change", this.doChangeCurrency.bindAsEventListener(this));
}

},

 addCart: function(event){

 var form = Event.element(event).up("form", 0);
 var data = form.serialize().parseQuery();


 var parameters = [
 form.className, 
 form.id.substring(2), 
 data.participants,
 data.chicks
 ];


 if ($N(data.participants) > 0){
 this.scroll = true;
 miracle.ajax(
 "he_base", 
 "add_cart", 
 parameters,
 this.refreshCart.bind(this)
 );
}
 Event.stop(event);
},


 refreshCart: function(response){

 this.cart.innerHTML = response;

 if (this.scroll){
 Element.scrollTo(this.cart);
 this.scroll = false;
}
},

 doCartClick: function(event){
 var target = Event.element(event);

 if (target.tagName == "IMG" && this[target.alt.toLowerCase() + "Cart"]){
 this[target.alt.toLowerCase() + "Cart"](event);
}
 if (target.tagName == "A" && this[target.name.toLowerCase() + "Cart"]){
 this[target.name.toLowerCase() + "Cart"](event);
}
},

 incCart: function(event){
 this.modifyCart(1, event);
},

 decCart: function(event){
 this.modifyCart(-1, event);
},

 removeCart: function(event){
 this.modifyCart(0, event);
},

 modifyCart: function(count, event){
 var parts = Event.element(event).id.split("_");
 if (!parts) return;
 var parameters = [
 count,
 parts[0], // type
 parts[1], // id
 !!parts[2],
 this.cart_content
 ];

 Event.stop(event);
 miracle.ajax(
 "he_base", 
 "modify_cart", 
 parameters,
 this.refreshCart.bind(this)
 );
},

 doChangeCurrency: function(event){
 miracle.ajax(
 "he_base", 
 "currency_change", 
 [ Form.Element.getValue(Event.element(event)), !!$("cart_content") ],
 this.refreshCart.bind(this)
 );
}

}

HE.init();