/**
 * javascript by Miracle 2.1
 * copyright (c) eWorld - 2004-2010
 */






var Prototype ={
 Version: '1.4.0',
 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 (property in source){
 destination[property] = source[property];
}
 return destination;
}

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

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;
 return function(event){
 return __method.call(object, event || window.event);
}
}

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; i < arguments.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(){
 setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},

 onTimerEvent: function(){
 if (!this.currentlyExecuting){
 try{
 this.currentlyExecuting = true;
 this.callback();
}finally{
 this.currentlyExecuting = false;
}
}
}
}



function $(){
 var elements = new Array();

 for (var i = 0; i < arguments.length; i++){
 var element = arguments[i];
 if (typeof element == 'string')
 element = document.getElementById(element);

 if (arguments.length == 1)
 return element;

 elements.push(element);
}

 return elements;
}
Object.extend(String.prototype,{
 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(eval);
},

 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[0].nodeValue : '';
},

 toQueryParams: function(){
 var pairs = this.match(/^\??(.*)$/)[1].split('&');
 return pairs.inject({}, function(params, pairString){
 var pair = pairString.split('=');
 params[pair[0]] = pair[1];
 return params;
});
},

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

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

 var camelizedString = this.indexOf('-') == 0
 ? oStringList[0].charAt(0).toUpperCase() + oStringList[0].substring(1)
 : oStringList[0];

 for (var i = 1, len = oStringList.length; i < len; i++){
 var s = oStringList[i];
 camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
}

 return camelizedString;
},

 inspect: function(){
 return "'" + this.replace('\\', '\\\\').replace("'", '\\\'') + "'";
}
});

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

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

 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 = true;
 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(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;
},

 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.collect(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 (value >= (result || value))
 result = value;
});
 return result;
},

 min: function(iterator){
 var result;
 this.each(function(value, index){
 value = (iterator || Prototype.K)(value, index);
 if (value <= (result || value))
 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.collect(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.collect(Prototype.K);
},

 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){
 iterator(value = collections.pluck(index));
 return value;
});
},

 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; i < iterable.length; i++)
 results.push(iterable[i]);
 return results;
}
}

Object.extend(Array.prototype, Enumerable);

Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype,{
 _each: function(iterator){
 for (var i = 0; i < this.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 != undefined || value != null;
});
},

 flatten: function(){
 return this.inject([], function(array, value){
 return array.concat(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; i < this.length; i++)
 if (this[i] == object) return i;
 return -1;
},

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

 shift: function(){
 var result = this[0];
 for (var i = 0; i < this.length - 1; i++)
 this[i] = this[i + 1];
 this.length--;
 return result;
},

 inspect: function(){
 return '[' + this.map(Object.inspect).join(', ') + ']';
}
});
var Hash ={
 _each: function(iterator){
 for (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($H(this), function(mergedHash, pair){
 mergedHash[pair.key] = pair.value;
 return mergedHash;
});
},

 toQueryString: function(){
 return this.map(function(pair){
 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;
 do{
 iterator(value);
 value = value.succ();
}while (this.include(value));
},

 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 ActiveXObject('Msxml2.XMLHTTP')},
 function(){return new ActiveXObject('Microsoft.XMLHTTP')},
 function(){return new XMLHttpRequest()}
 ) || false;
},

 activeRequestCount: 0
}

Ajax.Responders ={
 responders: [],

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

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

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

 dispatch: function(callback, request, transport, json){
 this.each(function(responder){
 if (responder[callback] && 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,
 parameters: ''
}
 Object.extend(this.options, options ||{});
},

 responseIsSuccess: function(){
 return this.transport.status == undefined
 || this.transport.status == 0
 || (this.transport.status >= 200 && this.transport.status < 300);
},

 responseIsFailure: function(){
 return !this.responseIsSuccess();
}
}

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

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

 request: function(url){
 var parameters = this.options.parameters || '';
 if (parameters.length > 0) parameters += '&_=';

 try{
 this.url = url;
 if (this.options.method == 'get' && parameters.length > 0)
 this.url += (this.url.match(/\?/) ? '&' : '?') + parameters;

 Ajax.Responders.dispatch('onCreate', this, this.transport);

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

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

 this.setRequestHeaders();

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

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

 setRequestHeaders: function(){
 var requestHeaders =
 ['X-Requested-With', 'XMLHttpRequest',
 'X-Prototype-Version', Prototype.Version];

 if (this.options.method == 'post'){
 requestHeaders.push('Content-type',
 'application/x-www-form-urlencoded');

 
 if (this.transport.overrideMimeType)
 requestHeaders.push('Connection', 'close');
}

 if (this.options.requestHeaders)
 requestHeaders.push.apply(requestHeaders, this.options.requestHeaders);

 for (var i = 0; i < requestHeaders.length; i += 2)
 this.transport.setRequestHeader(requestHeaders[i], requestHeaders[i+1]);
},

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

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

 evalJSON: function(){
 try{
 return eval(this.header('X-JSON'));
}catch (e){}
},

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

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

 if (event == 'Complete'){
 try{
 (this.options['on' + this.transport.status]
 || this.options['on' + (this.responseIsSuccess() ? 'Success' : 'Failure')]
 || Prototype.emptyFunction)(transport, json);
}catch (e){
 this.dispatchException(e);
}

 if ((this.header('Content-type') || '').match(/^text\/javascript/i))
 this.evalResponse();
}

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

 
 if (event == 'Complete')
 this.transport.onreadystatechange = Prototype.emptyFunction;
},

 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.containers ={
 success: container.success ? $(container.success) : $(container),
 failure: 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, object){
 this.updateContent();
 onComplete(transport, object);
}).bind(this);

 this.request(url);
},

 updateContent: function(){
 var receiver = this.responseIsSuccess() ?
 this.containers.success : this.containers.failure;
 var response = this.transport.responseText;

 if (!this.options.evalScripts)
 response = response.stripScripts();

 if (receiver){
 if (this.options.insertion){
 new this.options.insertion(receiver, response);
}else{
 Element.update(receiver, response);
}
}

 if (this.responseIsSuccess()){
 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.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);
}
});

document.getElementsByClassName = function(className, parentElement){
 var children = ($(parentElement) || document.body).getElementsByTagName('*');
 return $A(children).inject([], function(elements, child){
 if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
 elements.push(child);
 return elements;
});
}






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

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

 toggle: function(){
 for (var i = 0; i < arguments.length; i++){
 var element = $(arguments[i]);
 Element[Element.visible(element) ? 'hide' : 'show'](element);
}
},

 hide: function(){
 for (var i = 0; i < arguments.length; i++){
 var element = $(arguments[i]);
 element.style.display = 'none';
}
},

 show: function(){
 for (var i = 0; i < arguments.length; i++){
 var element = $(arguments[i]);
 element.style.display = '';
}
},

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

 update: function(element, html){
 $(element).innerHTML = html.stripScripts();
 setTimeout(function(){html.evalScripts()}, 10);
},

 getHeight: function(element){
 element = $(element);
 return element.offsetHeight;
},

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

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

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

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

 cleanWhitespace: function(element){
 element = $(element);
 for (var i = 0; i < element.childNodes.length; i++){
 var node = element.childNodes[i];
 if (node.nodeType == 3 && !/\S/.test(node.nodeValue))
 Element.remove(node);
}
},

 empty: function(element){
 return $(element).innerHTML.match(/^\s*$/);
},

 scrollTo: function(element){
 element = $(element);
 var x = element.x ? element.x : element.offsetLeft,
 y = element.y ? element.y : element.offsetTop;
 window.scrollTo(x, y);
},

 getStyle: function(element, style){
 element = $(element);
 var value = element.style[style.camelize()];
 if (!value){
 if (document.defaultView && document.defaultView.getComputedStyle){
 var css = document.defaultView.getComputedStyle(element, null);
 value = css ? css.getPropertyValue(style) : null;
}else if (element.currentStyle){
 value = element.currentStyle[style.camelize()];
}
}

 if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
 if (Element.getStyle(element, 'position') == 'static') value = 'auto';

 return value == 'auto' ? null : value;
},

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

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

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

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

 undoClipping: function(element){
 element = $(element);
 if (element._overflow) return;
 element.style.overflow = element._overflow;
 element._overflow = undefined;
}
});

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){
 if (this.element.tagName.toLowerCase() == 'tbody'){
 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(this.toArray().concat(classNameToAdd).join(' '));
},

 remove: function(classNameToRemove){
 if (!this.include(classNameToRemove)) return;
 this.set(this.select(function(className){
 return className != classNameToRemove;
}).join(' '));
},

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

Object.extend(Element.ClassNames.prototype, Enumerable);
var Field ={
 clear: function(){
 for (var i = 0; i < arguments.length; i++)
 $(arguments[i]).value = '';
},

 focus: function(element){
 $(element).focus();
},

 present: function(){
 for (var i = 0; i < arguments.length; i++)
 if ($(arguments[i]).value == '') return false;
 return true;
},

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

 activate: function(element){
 element = $(element);
 element.focus();
 if (element.select)
 element.select();
}
}



var Form ={
 serialize: function(form){
 var elements = Form.getElements($(form));
 var queryComponents = new Array();

 for (var i = 0; i < elements.length; i++){
 var queryComponent = Form.Element.serialize(elements[i]);
 if (queryComponent)
 queryComponents.push(queryComponent);
}

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

 getElements: function(form){
 form = $(form);
 var elements = new Array();

 for (tagName in Form.Element.Serializers){
 var tagElements = form.getElementsByTagName(tagName);
 for (var j = 0; j < tagElements.length; j++)
 elements.push(tagElements[j]);
}
 return elements;
},

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

 if (!typeName && !name)
 return inputs;

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

 return matchingInputs;
},

 disable: function(form){
 var elements = Form.getElements(form);
 for (var i = 0; i < elements.length; i++){
 var element = elements[i];
 element.blur();
 element.disabled = 'true';
}
},

 enable: function(form){
 var elements = Form.getElements(form);
 for (var i = 0; i < elements.length; i++){
 var element = elements[i];
 element.disabled = '';
}
},

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

 focusFirstElement: function(form){
 Field.activate(Form.findFirstElement(form));
},

 reset: function(form){
 $(form).reset();
}
}

Form.Element ={
 serialize: function(element){
 element = $(element);
 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];
}
}

Form.Element.Serializers ={
 input: function(element){
 switch (element.type.toLowerCase()){
 case 'submit':
 case 'hidden':
 case 'password':
 case 'text':
 return Form.Element.Serializers.textarea(element);
 case 'checkbox':
 case 'radio':
 return Form.Element.Serializers.inputSelector(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.options[index];
 value = opt.value;
 if (!value && !('value' in opt))
 value = opt.text;
}
 return [element.name, value];
},

 selectMany: function(element){
 var value = new Array();
 for (var i = 0; i < element.length; i++){
 var opt = element.options[i];
 if (opt.selected){
 var optValue = opt.value;
 if (!optValue && !('value' in opt))
 optValue = opt.text;
 value.push(optValue);
}
}
 return [element.name, value];
}
}



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();
 if (this.lastValue != value){
 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(){
 var elements = Form.getElements(this.element);
 for (var i = 0; i < elements.length; i++)
 this.registerCallback(elements[i]);
},

 registerCallback: function(element){
 if (element.type){
 switch (element.type.toLowerCase()){
 case 'checkbox':
 case 'radio':
 Event.observe(element, 'click', this.onElementEvent.bind(this));
 break;
 case 'password':
 case 'text':
 case 'textarea':
 case 'select-one':
 case 'select-multiple':
 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,

 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; i < Event.observers.length; i++){
 Event.stopObserving.apply(this, Event.observers[i]);
 Event.observers[i][0] = null;
}
 Event.observers = false;
},

 observe: function(element, name, observer, useCapture){
 var element = $(element);
 useCapture = useCapture || false;

 if (name == 'keypress' &&
 (navigator.appVersion.match(/Konqueror|Safari|KHTML/)
 || element.attachEvent))
 name = 'keydown';

 this._observeAndCache(element, name, observer, useCapture);
},

 stopObserving: function(element, name, observer, useCapture){
 var 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){
 element.detachEvent('on' + name, observer);
}
}
});


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

 clone: function(source, target){
 source = $(source);
 target = $(target);
 target.style.position = 'absolute';
 var offsets = this.cumulativeOffset(source);
 target.style.top = offsets[1] + 'px';
 target.style.left = offsets[0] + 'px';
 target.style.width = source.offsetWidth + 'px';
 target.style.height = source.offsetHeight + 'px';
},

 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{
 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];
}
}
var undefined;
var DOTS = "#define x_width 2\n#define x_height 1\nstatic char x_bits[]={0x01}";
var FORBIDDEN="[[-- FORBIDDEN --]";
var miracleConfig=new Array();


function init(){

 if (arguments.callee.done) return;

 arguments.callee.done = true;
 for(var i=0; arguments.callee.actions.length>i; i++){
 arguments.callee.actions[i]();
}
};
init.actions=[];

function initAction(event){
 init.actions.push(event);
}


function fixObjects(){
 var theObjects = document.getElementsByTagName("object");
 for (var i = 0; i < theObjects.length; i++){
 theObjects[i].outerHTML = theObjects[i].outerHTML;
}
}









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
}


addEvent(window, 'load', miracle_init);


String.prototype.reverse = function(){
 var s = "";
 var i = this.length;
 while (i>0){
 s += this.substring(i-1,i);
 i--;
}
 return s;
}

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

String.prototype.toInt = function(){
 var a = new Array();
 for (var i = 0; i < this.length; i++){
 a[i] = this.charCodeAt(i);
}
 return a;
}


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

 if (browser.isIE && attribute=="class"){
 attribute="className";
}
 
 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 = function(tagname, attribute, value){
 if (!value) value="/.+/";
 var elements=new Array();
 var inputs=this.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;
}
}








String.prototype.matchAll = function (re){
 var res = [];
 
 this.replace(re, function(){
 for(var i = 0; i < arguments.length - 2; i++)
 (res[i] || (res[i] = [])).push(arguments[i]);
});
 
 return res;
}

if (typeof(Node)!="undefined"){
Node.prototype.swapSiblings = function(node){
 if (this.parentNode!=node.parentNode) return;
 var parent=this.parentNode;
 if (this.sourceIndex()<node.sourceIndex()){// a node lejjebb van
 parent.insertBefore(node, this); // mozgasd be a 'node'-ot 'ez' ele
}else{// feljebb van amivel cserelnunk kell
 parent.insertBefore(this, node); // mozgasd be 'ezt' a node
}
}
}

if (typeof(Node)!="undefined"){
Node.prototype.sourceIndex = function(){
 var elements=document.getElementsByTagName("*");
 for (var i=0; i<elements.length; i++){
 if (this==elements[i]) return i;
}
 return false;
}
}

function isAlien(a){
 return isObject(a) && typeof a.constructor != 'function';
}

function isArray(a){
 return isObject(a) && a.constructor == Array;
}

function isBoolean(a){
 return typeof a == 'boolean';
}

function isEmpty(o){
 var i, v;
 if (isObject(o)){
 for (i in o){
 v = o[i];
 if (isUndefined(v) && isFunction(v)){
 return false;
}
}
}
 return true;
}

function isFunction(a){
 return typeof a == 'function';
}

function isNull(a){
 return typeof a == 'object' && !a;
}

function isNumber(a){
 return typeof a == 'number' && isFinite(a);
}

function isObject(a){
 return (a && typeof a == 'object') || isFunction(a);
}

function isString(a){
 return typeof a == 'string';
}

function isUndefined(a){
 return typeof a == 'undefined';
}

function arrayValues(array){
 var tmp=new Array();
 var j=0;
 for (var i in array){
 tmp[j]=array[i];
 j=j+1;
}
 return tmp;
}

function arrayAlert(array){
 var tmp="";
 for (var i in array){
 tmp=tmp+"["+i+"] - "+array[i],"\n\r";
}
 alert(tmp);
}


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





function BrowserDetect(){
 var ua = navigator.userAgent.toLowerCase(); 

 this.isGecko = (ua.indexOf('gecko') != -1 && ua.indexOf('safari') == -1);
 this.isAppleWebKit = (ua.indexOf('applewebkit') != -1);

 this.isKonqueror = (ua.indexOf('konqueror') != -1); 
 this.isSafari = (ua.indexOf('safari') != - 1);
 this.isOmniweb = (ua.indexOf('omniweb') != - 1);
 this.isOpera = (ua.indexOf('opera') != -1); 
 this.isIcab = (ua.indexOf('icab') != -1); 
 this.isAol = (ua.indexOf('aol') != -1); 
 this.isIE = (ua.indexOf('msie') != -1 && !this.isOpera && (ua.indexOf('webtv') == -1) ); 
 this.isMozilla = (this.isGecko && ua.indexOf('gecko/') + 14 == ua.length);
 this.isFirebird = (ua.indexOf('firebird/') != -1);
 this.isFirefox = (ua.indexOf('firefox/') != -1);
 this.isNS = ( (this.isGecko) ? (ua.indexOf('netscape') != -1) : ( (ua.indexOf('mozilla') != -1) && !this.isOpera && !this.isSafari && (ua.indexOf('spoofer') == -1) && (ua.indexOf('compatible') == -1) && (ua.indexOf('webtv') == -1) && (ua.indexOf('hotjava') == -1) ) );

 this.isIECompatible = ( (ua.indexOf('msie') != -1) && !this.isIE);
 this.isNSCompatible = ( (ua.indexOf('mozilla') != -1) && !this.isNS && !this.isMozilla);

 this.geckoVersion = ( (this.isGecko) ? ua.substring( (ua.lastIndexOf('gecko/') + 6), (ua.lastIndexOf('gecko/') + 14) ) : -1 );
 this.equivalentMozilla = ( (this.isGecko) ? parseFloat( ua.substring( ua.indexOf('rv:') + 3 ) ) : -1 );
 this.appleWebKitVersion = ( (this.isAppleWebKit) ? parseFloat( ua.substring( ua.indexOf('applewebkit/') + 12) ) : -1 );

 this.versionMinor = parseFloat(navigator.appVersion); 

 if (this.isGecko && !this.isMozilla){
 this.versionMinor = parseFloat( ua.substring( ua.indexOf('/', ua.indexOf('gecko/') + 6) + 1 ) );
}
 else if (this.isMozilla){
 this.versionMinor = parseFloat( ua.substring( ua.indexOf('rv:') + 3 ) );
}
 else if (this.isIE && this.versionMinor >= 4){
 this.versionMinor = parseFloat( ua.substring( ua.indexOf('msie ') + 5 ) );
}
 else if (this.isKonqueror){
 this.versionMinor = parseFloat( ua.substring( ua.indexOf('konqueror/') + 10 ) );
}
 else if (this.isSafari){
 this.versionMinor = parseFloat( ua.substring( ua.lastIndexOf('safari/') + 7 ) );
}
 else if (this.isOmniweb){
 this.versionMinor = parseFloat( ua.substring( ua.lastIndexOf('omniweb/') + 8 ) );
}
 else if (this.isOpera){
 this.versionMinor = parseFloat( ua.substring( ua.indexOf('opera') + 6 ) );
}
 else if (this.isIcab){
 this.versionMinor = parseFloat( ua.substring( ua.indexOf('icab') + 5 ) );
}
 
 this.versionMajor = parseInt(this.versionMinor); 

 this.isDOM1 = (document.getElementById);
 this.isDOM2Event = (document.addEventListener && document.removeEventListener);

 this.mode = document.compatMode ? document.compatMode : 'BackCompat';

 this.isWin = (ua.indexOf('win') != -1);
 this.isWin32 = (this.isWin && ( ua.indexOf('95') != -1 || ua.indexOf('98') != -1 || ua.indexOf('nt') != -1 || ua.indexOf('win32') != -1 || ua.indexOf('32bit') != -1 || ua.indexOf('xp') != -1) );
 this.isMac = (ua.indexOf('mac') != -1);
 this.isUnix = (ua.indexOf('unix') != -1 || ua.indexOf('sunos') != -1 || ua.indexOf('bsd') != -1 || ua.indexOf('x11') != -1);
 this.isLinux = (ua.indexOf('linux') != -1);

 this.isNS4x = (this.isNS && this.versionMajor == 4);
 this.isNS40x = (this.isNS4x && this.versionMinor < 4.5);
 this.isNS47x = (this.isNS4x && this.versionMinor >= 4.7);
 this.isNS4up = (this.isNS && this.versionMinor >= 4);
 this.isNS6x = (this.isNS && this.versionMajor == 6);
 this.isNS6up = (this.isNS && this.versionMajor >= 6);
 this.isNS7x = (this.isNS && this.versionMajor == 7);
 this.isNS7up = (this.isNS && this.versionMajor >= 7);
 
 this.isIE4x = (this.isIE && this.versionMajor == 4);
 this.isIE4up = (this.isIE && this.versionMajor >= 4);
 this.isIE5x = (this.isIE && this.versionMajor == 5);
 this.isIE55 = (this.isIE && this.versionMinor == 5.5);
 this.isIE5up = (this.isIE && this.versionMajor >= 5);
 this.isIE6x = (this.isIE && this.versionMajor == 6);
 this.isIE6up = (this.isIE && this.versionMajor >= 6);
 
 this.isIE4xMac = (this.isIE4x && this.isMac);
}
var browser = new BrowserDetect();


var antispam_pattern_1=/\/KUKAC\//gi;
var antispam_replacement_1="@";
var antispam_pattern_2=/email:\/\//gi;
var antispam_replacement_2="mailto:";




function antispam(){
 if (browser.isGecko){
 addEvent(window,'load',antispam_dom);
}else{
 addEvent(window,'load',antispam_innerhtml);
}
}


function antispam_innerhtml(){
 ihtml=document.body.innerHTML;
 ihtml=ihtml.replace(antispam_pattern_1,antispam_replacement_1);
 ihtml=ihtml.replace(antispam_pattern_2,antispam_replacement_2);
 document.body.innerHTML=ihtml;
}


function antispam_dom(){

 var as=document.getElementsByTagName("a");
 for (i=0; i<as.length; i++){
 var href=as[i].href;
 href=href.replace(antispam_pattern_1,antispam_replacement_1);
 href=href.replace(antispam_pattern_2,antispam_replacement_2);
 as[i].href=href;
}
 traverse(document.body);
}


function traverse(node){

 if ( (node.nodeName=="textarea") ||
 (node.nodeName=="input") 
 ){
 node.value=node.value.replace(antispam_pattern_1,antispam_replacement_1);
}
 if (node.nodeType == 3){
 node.nodeValue=node.nodeValue.replace(antispam_pattern_1,antispam_replacement_1);
}else{
 if (node.childNodes != null){
 for (var i=0; i < node.childNodes.length; i++){
 traverse(node.childNodes.item(i));
}
}
}
}





var stat=new Stat();



function call_stat(){
 var src="/client_stat.png";

 var img=new Image().src=src+"?"
 +"&screen=" +this.screen_size
 +"&javascript=" +'y'
 +"&images=" +(document.images?'y':'n')
 +"&cookies=" +(navigator.cookieEnabled?'y':'n')
 +"&color_depth="+(screen.colorDepth?screen.colorDepth:'NULL')
 ;

 createCookie("client_stat", true);
}


function Stat(){
 this.screen_width=(typeof(screen.width)!="undefined")?screen.width:"NULL";
 this.screen_height=(typeof(screen.height)!="undefined")?screen.height:"NULL";
 this.screen_size=(typeof(screen.height)!="undefined")?this.screen_width+"x"+this.screen_height:"NULL";
 this.call_stat=call_stat;
 if (!readCookie("client_stat")){
 this.call_stat();
}
}



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(){

 this.name=this.href.split("/");
 this.name=this.name[this.name.length-1].toLowerCase();


 var tmp="";
 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);
 this.mywindow.onload=function(){


}
 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


addEvent(window, 'load', form_init);

function form_init(){
 init_inputs();
}

var button_add_one_image_maxfiles;

function forms_button_add_one_image(maxfiles){

 button_add_one_image_maxfiles=maxfiles;
 addbutton=document.getElementById("add_one_image");
 if (addbutton){
 addbutton.onclick=forms_button_add_one_image_onclick;
}
}


function forms_button_add_one_image_onclick(){
 fieldset=document.getElementById("fileinput");
 allinput=fieldset.getElementsByTagName("input");
 j=0;
 inputs=new Array();
 for (i=0; i<allinput.length; i++){
 if (allinput[i].type=="file"){
 inputs[j]=allinput[i];
 j++;
}
}

 
 if (inputs.length<=button_add_one_image_maxfiles){
 i=inputs.length;
 do{
 i=i-1;
 lastinput=inputs[i];
}while (lastinput.type!="file");

 lastid=parseInt(lastinput.name.match(/[\d+]/g));

 newinput=document.createElement('input');
 newinput.type="file";
 newinput.className="file";
 newid=lastid+1;

 newinput.name=lastinput.name.replace(/\[\d\]/g, "["+newid+"]");


 fieldset.insertBefore(newinput, this);
}
 return false; // ne submitoljon a gomb...
}

function miracle_form_accept_numeric(node){
 node.onkeypress=function(ev){
 if (!ev) var ev=window.event;


 key = (ev.keyCode>0) ? ev.keyCode : ev.which;

 if (
 (key==null) || (key==0) || (key==8) || (key==9) || (key==13) || (key==27) 
 ){
 return true;
}

 if ((key<48) || (key>57)){

 if (ev.preventDefault){// w3c
 ev.preventDefault(); ev.stopPropagation();
}else{// ie
 ev.cancelBubble = true; ev.returnValue = false;
}
 tmp=false;
}else{
 tmp=true;
}

 return tmp;
}
}

function init_inputs(){
 allinput=document.getElementsByTagName("input");
 for (i=0; i<allinput.length; i++){
 accept=allinput[i].getAttribute("accept");
 switch (accept){
 case "numeric":
 miracle_form_accept_numeric(allinput[i]);
 break;
}
}
}


function init_MyDTD(){
 var start = new Date();

 var elements=document.getElementsByTagName("*");
 for (var i=0; i<elements.length; i++){

 if (elements[i].getAttribute("id")){
 var id=elements[i].getAttribute("id");
 var e=elements[i];

 if (elements[i].getAttribute("id").substring(0,2)=="::"){

 attributes=id.split("::");

 if (attributes[1]) e.setAttribute("id", attributes[1]);

 for (var j=2; j<attributes.length; j++){
 pair=attributes[j].split("--");
 e.setAttribute(pair[0], pair[1]);
}
}
}
}
 var end = new Date();

}

oFCKeditors=new Array();


function init_fckeditor(textarea){
 if (typeof(FCKeditor)!="undefined"){
 var name=textarea.getAttribute("name");
 var id=textarea.getAttribute("id");
 var height=textarea.getAttribute("wysiwyg_height");
 textarea.setAttribute("id", name);
 oFCKeditors[id]=new FCKeditor(name, "100%", height);
 oFCKeditors[id].Config['CustomConfigurationsPath']='/fckeditor/miracle_fckconfig.js';
 oFCKeditors[id].ReplaceTextarea();
 textarea.setAttribute("id", id);
}
}


function init_wysiwyg(){
 var textareas=document.getElementsByTagName("textarea");
 for (var i=0; i<textareas.length; i++){
 var editor=textareas[i].getAttribute("wysiwyg");
 if (editor){
 var fn="init_"+editor;
 if (eval("window."+fn)){
 eval(fn+"(textareas[i]);");
}
}
}

}


function init_tinymce(){

}

if (typeof(tinyMCE)=="object"){
 tinyMCE.init({
 mode : "textareas",
 theme : "advanced",
 plugins : "table,save,advhr,advimage,advlink,emotions,iespell,insertdatetime,preview,zoom,flash,searchreplace,print",
 theme_advanced_buttons1_add_before : "save,separator",
 theme_advanced_buttons1_add : "fontselect,fontsizeselect",
 theme_advanced_buttons2_add : "separator,insertdate,inserttime,preview,zoom,separator,forecolor,backcolor",
 theme_advanced_buttons2_add_before: "cut,copy,paste,separator,search,replace,separator",
 theme_advanced_buttons3_add_before : "tablecontrols,separator",
 theme_advanced_buttons3_add : "emotions,iespell,flash,advhr,separator,print",
 theme_advanced_toolbar_location : "top",
 theme_advanced_toolbar_align : "left",
 theme_advanced_path_location : "bottom",
 content_css : "example_full.css",
 plugin_insertdate_dateFormat : "%Y-%m-%d",
 plugin_insertdate_timeFormat : "%H:%M:%S",
 extended_valid_elements : "a[name|href|target|title|onclick],img[class|src|border=0|alt|title|hspace|vspace|width|height|align|onmouseover|onmouseout|name],hr[class|width|size|noshade],font[face|size|color|style],span[class|align|style]",
 external_link_list_url : "example_link_list.js",
 external_image_list_url : "example_image_list.js",
 flash_external_list_url : "example_flash_list.js",
 file_browser_callback : "fileBrowserCallBack"
});
}

 function fileBrowserCallBack(field_name, url, type){

 alert("Filebrowser callback: " + field_name + "," + url + "," + type);
}



if (typeof(HTMLArea)!="undefined"){
 HTMLAreas=new Array();

 HTMLArea.loadPlugin("ImageManager");
}

function init_htmlarea(textarea){
 textarea.style.height="400px";
 var id=textarea.getAttribute("id");
 HTMLArea[id] = new HTMLArea(id);

 HTMLArea[id].registerPlugin(ImageManager);
 HTMLArea[id].generate();
}



function Selector(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();

}


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

Selector.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";
}
}

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

Selector.prototype.moveOptions = function(from, to){
 var selected=getSelectedOptions(this.panels[from]);
 for (var i=0; i<selected.length; i++){
 var si=selected[i]-i;
 var option=this.panels[from][si];
 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);
}





}





Selector.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_ajax);

function init_ajax(){

 var listers=document.getElementsByTagNameAndAttribute("table", "class", "lister");
 for (l=0; l<listers.length; l++){
 var lister=listers[l];
 var ajax=lister.getAttribute("ajax");
 var module=lister.getAttribute("module");
 var entity=lister.getAttribute("entity");
 if (!entity) entity="record";
 if (ajax){
 var elements=lister.getElementsByTagName("*");
 for (i=0; i<elements.length; i++){
 var element=elements[i];
 var action=element.getAttribute("action");
 var parameters=element.getAttribute("parameters");


 if (action && parameters){
 var code="element.onclick=function (){ajax_action(this, '"+module+"', '"+action+"', '"+entity+"', "+parameters+");}";

 eval(code);
}
}
}
}
}

function ajax_action(element, module, action, entity){
 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=server_action(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:
 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);
}else{
 alert("Error! #"+trId+" not found! Can't delete the row!");
}
}

}



function printPage(){
 if (window.print){
 setTimeout('window.print();', 200);
}
 else if (agt.indexOf("mac") != -1){
 alert("Az oldal nyomtatƤsƤhoz nyomd meg a 'Cmd+p' gombokat!");
}
 else{
 alert("Az oldal nyomtatƤsƤhoz nyomd meg a 'Ctrl+p' gombokat!");
}
}
if (typeof(Calendar)=="function"){
 addEvent(window, "load", initDate);
}

function initDate(){
 var dates=document.getElementsByTagNameAndAttribute("input", "accept", "/date|datetime/");
 if (dates.length==0) return;

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

 loadExternalCSS("/jscalendar/calendar-blue2.css");



 for (var i in dates){

 if (typeof dates[i]=="function") continue;
 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
});
}
}


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";
 this.fixFCKEditor(panels[i]);
}else{
 panels[i].style.display="none";
}
}
}// end of onclick

}

tabBox.prototype.fixFCKEditor = function(panel){
 alert(panel);
}


addEvent(window, 'load', initPlugIns);

function initPlugIns(){
 if (miracleConfig['miracle_plug-in']){

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

 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;
 alert(element.tagName);
 switch (element.tagName){
 case "BUTTON":
 value=form.submitButton;
 break;
 default:
 value=element.value;
 break;
}
 alert(value);
 values[name]=encode_utf8(value);
}
 return values;
}


var fileUpload=Class.create();

addEvent(window, 'load', initFileUploads);

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

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

};
initAction(initTreeView);

var miracle;

function initTreeView(){
 miracle = new Miracle();
 var trees = $A(document.getElementsByClassName("miracleTree")).each(
 function(tree){
 new miracleTree(tree);
}
 )
}

var Miracle = Class.create();

Miracle.prototype ={

 initialize: function(){
 this.setConstants();
},

 setConstants: function(){
 this.MIRACLE_IMAGE_DIR="/images/miracle/";
 this.DOMAIN_TYPE=this.setDomainType();

},

 setDomainType: function(){
 document.domain;
},

 miracleInDomain: function(){
 
}



}

var miracleTree = Class.create();

miracleTree.prototype ={

 initialize: function(DOMElement){
 this.nodeElement = "li";
 this.treeElement = "ul";
 this.root=DOMElement;
 this.imageDir=miracle.MIRACLE_IMAGE_DIR+"miracletree/";
 var nodes=$A(this.root.getElementsByTagName("li"));

 nodes.each(
 function (node){
 this.addImage(node);
 if (this.hasDescendant(node)){
 new miracleTree(this.getFirstBranch(node));
}else{
 
}

}.bind(this)
 );
},

 getFirstBranch: function(node){
 var descendants = $A(node.getElementsByTagName(this.treeElement));
 if (descendants[0]){
 var tmp=descendants[0];
}
 return tmp;
},

 hasDescendant: function(node){
 if (!node) return false;
 var descendants = $A(node.getElementsByTagName(this.treeElement));
 var tmp = descendants.length>0 ? true : false;
 return tmp;
},

 addImage: function(node){
 var imageHTML="<img src="+this.imageDir+"lp.gif class=miracleTreeIcon />";
 node.innerHTML=imageHTML+node.innerHTML;
},

 toggle: function(event){
 alert(Event.element(event).nodeName);

}


};





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



function getDomDocumentPrefix(){
 if (getDomDocumentPrefix.prefix)
 return getDomDocumentPrefix.prefix;
 
 var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
 var o;
 for (var i = 0; i < prefixes.length; i++){
 try{

 o = new ActiveXObject(prefixes[i] + ".DomDocument");
 return getDomDocumentPrefix.prefix = prefixes[i];
}
 catch (ex){};
}
 
 throw new Error("Could not find an installed XML parser");
}

function getXmlHttpPrefix(){
 if (getXmlHttpPrefix.prefix)
 return getXmlHttpPrefix.prefix;
 
 var prefixes = ["MSXML2", "Microsoft", "MSXML", "MSXML3"];
 var o;
 for (var i = 0; i < prefixes.length; i++){
 try{

 o = new ActiveXObject(prefixes[i] + ".XmlHttp");
 return getXmlHttpPrefix.prefix = prefixes[i];
}
 catch (ex){};
}
 
 throw new Error("Could not find an installed XML parser");
}




function XmlHttp(){}

XmlHttp.create = function (){
 try{
 if (window.XMLHttpRequest){
 var req = new XMLHttpRequest();


 if (req.readyState == null){
 req.readyState = 1;
 req.addEventListener("load", function (){
 req.readyState = 4;
 if (typeof req.onreadystatechange == "function")
 req.onreadystatechange();
}, false);
}
 
 return req;
}
 if (window.ActiveXObject){
 return new ActiveXObject(getXmlHttpPrefix() + ".XmlHttp");
}
}
 catch (ex){}

 throw new Error("Your browser does not support XmlHttp objects");
};

function XmlDocument(){}

XmlDocument.create = function (){
 try{

 if (document.implementation && document.implementation.createDocument){
 var doc = document.implementation.createDocument("", "", null);


 if (doc.readyState == null){
 doc.readyState = 1;
 doc.addEventListener("load", function (){
 doc.readyState = 4;
 if (typeof doc.onreadystatechange == "function")
 doc.onreadystatechange();
}, false);
}
 
 return doc;
}
 if (window.ActiveXObject)
 return new ActiveXObject(getDomDocumentPrefix() + ".DomDocument");
}
 catch (ex){}
 throw new Error("Your browser does not support XmlDocument objects");
};

if (window.DOMParser &&
 window.XMLSerializer &&
 window.Node && Node.prototype && Node.prototype.__defineGetter__){



 Document.prototype.loadXML = function (s){

 var doc2 = (new DOMParser()).parseFromString(s, "text/xml");

 while (this.hasChildNodes())
 this.removeChild(this.lastChild);

 for (var i = 0; i < doc2.childNodes.length; i++){
 this.appendChild(this.importNode(doc2.childNodes[i], true));
}
};


 
 Document.prototype.__defineGetter__("xml", function (){
 return (new XMLSerializer()).serializeToString(this);
});
}///////////////////////////////////////////////////////////////////////////

















function wddxSerializer_serializeValue(obj)
{
 var bSuccess = true;
 var val;

 if (obj == null)
{

 this.write("<null/>");
}
 else if (typeof(val = obj.valueOf()) == "string")
{

 this.serializeString(val);
}
 else if (typeof(val = obj.valueOf()) == "number")
{


 if (
 typeof(obj.getTimezoneOffset) == "function" &&
 typeof(obj.toGMTString) == "function")
{



 this.write("<dateTime>" + 
 (obj.getYear() < 1000 ? 1900+obj.getYear() : obj.getYear()) + "-" + (obj.getMonth() + 1) + "-" + obj.getDate() +
 "T" + obj.getHours() + ":" + obj.getMinutes() + ":" + obj.getSeconds());
 if (this.useTimezoneInfo)
{
 this.write(this.timezoneString);
}
 this.write("</dateTime>");
}
 else
{

 this.write("<number>" + val + "</number>");
}
}
 else if (typeof(val = obj.valueOf()) == "boolean")
{

 this.write("<boolean value='" + val + "'/>");
}
 else if (typeof(obj) == "object")
{
 if (typeof(obj.wddxSerialize) == "function")
{

 bSuccess = obj.wddxSerialize(this);
}
 else if (
 typeof(obj.join) == "function" &&
 typeof(obj.reverse) == "function" &&
 typeof(obj.sort) == "function" &&
 typeof(obj.length) == "number")
{

 this.write("<array length='" + obj.length + "'>");
 for (var i = 0; bSuccess && i < obj.length; ++i)
{
 bSuccess = this.serializeValue(obj[i]);
}
 this.write("</array>");
}
 else
{


 if (typeof(obj.wddxSerializationType) == 'string')
{
 this.write('<struct type="'+ obj.wddxSerializationType +'">')
}
 else
{
 this.write("<struct>");
}
 
 for (var prop in obj)
{
 if (prop != 'wddxSerializationType')
{
 bSuccess = this.serializeVariable(prop, obj[prop]);
 if (! bSuccess)
{
 break;
}
}
}
 
 this.write("</struct>");
}
}
 else
{

 bSuccess = false;
}

 return bSuccess;
}



function wddxSerializer_serializeAttr(s)
{
 for (var i = 0; i < s.length; ++i)
{
 this.write(this.at[s.charAt(i)]);
}
}




function wddxSerializer_serializeAttrOld(s)
{
 this.write(s);
}



function wddxSerializer_serializeString(s)
{
 this.write("<string>");
 for (var i = 0; i < s.length; ++i)
{
 this.write(this.et[s.charAt(i)]);
}
 this.write("</string>");
}



function wddxSerializer_serializeStringOld(s)
{
 this.write("<string><![CDATA[");
 
 pos = s.indexOf("]]>");
 if (pos != -1)
{
 startPos = 0;
 while (pos != -1)
{
 this.write(s.substring(startPos, pos) + "]]>]]&gt;<![CDATA[");
 
 startPos = pos + 3;
 if (startPos < s.length)
{
 pos = s.indexOf("]]>", startPos);
}
 else
{


 pos = -1;
}
}
 this.write(s.substring(startPos, s.length));
}
 else
{
 this.write(s);
}
 
 this.write("]]></string>");
}



function wddxSerializer_serializeVariable(name, obj)
{
 var bSuccess = true;
 
 if (typeof(obj) != "function")
{
 this.write("<var name='");
 this.preserveVarCase ? this.serializeAttr(name) : this.serializeAttr(name.toLowerCase());
 this.write("'>");

 bSuccess = this.serializeValue(obj);
 this.write("</var>");
}

 return bSuccess;
}


function wddxSerializer_write(str)
{
 this.wddxPacket += str;
}



function wddxSerializer_serialize(rootObj)
{
 this.wddxPacket = "";

 this.write("<wddxPacket version='1.0'><header/><data>");
 var bSuccess = this.serializeValue(rootObj);
 this.write("</data></wddxPacket>");

 if (bSuccess)
{
 return this.wddxPacket;
}
 else
{
 return null;
}
}


function WddxSerializer()
{

 if (navigator.appVersion != "" && navigator.appVersion.indexOf("MSIE 3.") == -1)
{


 var et = new Array();


 var n2c = new Array();
 var c2n = new Array();

 var at = new Array();

 for (var i = 0; i < 256; ++i)
{

 var d1 = Math.floor(i/64);
 var d2 = Math.floor((i%64)/8);
 var d3 = i%8;
 var c = eval("\"\\" + d1.toString(10) + d2.toString(10) + d3.toString(10) + "\"");

 n2c[i] = c;
 c2n[c] = i; 

 if (i < 32 && i != 9 && i != 10 && i != 13)
{


 var hex = i.toString(16);
 if (hex.length == 1)
{
 hex = "0" + hex;
}
 
 et[n2c[i]] = "<char code='" + hex + "'/>";

 at[n2c[i]] = "";

}
 else if (i < 128)
{

 et[n2c[i]] = n2c[i];

 at[n2c[i]] = n2c[i];
}
 else
{

 et[n2c[i]] = "&#x" + i.toString(16) + ";";
 at[n2c[i]] = "&#x" + i.toString(16) + ";";
}
}

 et["<"] = "&lt;";
 et[">"] = "&gt;";
 et["&"] = "&amp;";

 at["<"] = "&lt;";
 at[">"] = "&gt;";
 at["&"] = "&amp;";
 at["'"] = "&apos;";
 at["\""] = "&quot;";

 this.n2c = n2c;
 this.c2n = c2n;
 this.et = et; 
 this.at = at;

 this.serializeString = wddxSerializer_serializeString;
 this.serializeAttr = wddxSerializer_serializeAttr;
}
 else
{

 this.serializeString = wddxSerializer_serializeStringOld;
 this.serializeAttr = wddxSerializer_serializeAttrOld;
}

 
 var tzOffset = (new Date()).getTimezoneOffset();

 if (tzOffset >= 0)
{
 this.timezoneString = '-';
}
 else
{
 this.timezoneString = '+';
}
 this.timezoneString += Math.floor(Math.abs(tzOffset) / 60) + ":" + (Math.abs(tzOffset) % 60);

 this.preserveVarCase = false;
 this.useTimezoneInfo = true;

 this.serialize = wddxSerializer_serialize;
 this.serializeValue = wddxSerializer_serializeValue;
 this.serializeVariable = wddxSerializer_serializeVariable;
 this.write = wddxSerializer_write;
}







function wddxRecordset_isColumn(name)
{



 return (typeof(this[name]) == "object" && 
 name.indexOf("_private_") == -1);
}


function wddxRecordset_getRowCount()
{
 var nRowCount = 0;
 for (var col in this)
{
 if (this.isColumn(col))
{
 nRowCount = this[col].length;
 break;
}
}
 return nRowCount;
}


function wddxRecordset_addColumn(name)
{
 var nLen = this.getRowCount();
 var colValue = new Array(nLen);
 for (var i = 0; i < nLen; ++i)
{
 colValue[i] = null;
}
 this[this.preserveFieldCase ? name : name.toLowerCase()] = colValue;
}


function wddxRecordset_addRows(n)
{
 for (var col in this)
{
 if (this.isColumn(col))
{
 var nLen = this[col].length;
 for (var i = nLen; i < nLen + n; ++i)
{
 this[col][i] = null;
}
}
}
}


function wddxRecordset_getField(row, col)
{
 return this[this.preserveFieldCase ? col : col.toLowerCase()][row];
}


function wddxRecordset_setField(row, col, value)
{
 this[this.preserveFieldCase ? col : col.toLowerCase()][row] = value;
}



function wddxRecordset_wddxSerialize(serializer)
{

 var colNamesList = "";
 var colNames = new Array();
 var i = 0;
 for (var col in this)
{
 if (this.isColumn(col))
{
 colNames[i++] = col;

 if (colNamesList.length > 0)
{
 colNamesList += ",";
}
 colNamesList += col; 
}
}
 
 var nRows = this.getRowCount();
 
 serializer.write("<recordset rowCount='" + nRows + "' fieldNames='" + colNamesList + "'>");
 
 var bSuccess = true;
 for (i = 0; bSuccess && i < colNames.length; i++)
{
 var name = colNames[i];
 serializer.write("<field name='" + name + "'>");
 
 for (var row = 0; bSuccess && row < nRows; row++)
{
 bSuccess = serializer.serializeValue(this[name][row]);
}
 
 serializer.write("</field>");
}
 
 serializer.write("</recordset>");
 
 return bSuccess;
}





function wddxRecordset_dump(escapeStrings)
{

 var nRows = this.getRowCount();

 var colNames = new Array();
 var i = 0;
 for (var col in this)
{
 if (typeof(this[col]) == "object")
{
 colNames[i++] = col;
}
}

 var o = "<table border=1><tr><td><b>RowNumber</b></td>";
 for (i = 0; i < colNames.length; ++i)
{
 o += "<td><b>" + colNames[i] + "</b></td>";
}
 o += "</tr>";

 for (var row = 0; row < nRows; ++row)
{
 o += "<tr><td>" + row + "</td>";
 for (i = 0; i < colNames.length; ++i)
{
 var elem = this.getField(row, colNames[i]);
 if (escapeStrings && typeof(elem) == "string")
{
 var str = "";
 for (var j = 0; j < elem.length; ++j)
{
 var ch = elem.charAt(j);
 if (ch == '<')
{
 str += "&lt;";
}
 else if (ch == '>')
{
 str += "&gt;";
}
 else if (ch == '&')
{
 str += "&amp;";
}
 else
{
 str += ch;
}
}
 o += ("<td>" + str + "</td>");
}
 else
{
 o += ("<td>" + elem + "</td>");
}
}
 o += "</tr>";
}

 o += "</table>";

 return o; 
}









function WddxRecordset()
{

 this.preserveFieldCase = false;

 if (typeof(wddxRecordsetExtensions) == "object")
{
 for (var prop in wddxRecordsetExtensions)
{

 this[prop] = wddxRecordsetExtensions[prop]
}
}

 this.getRowCount = wddxRecordset_getRowCount;
 this.addColumn = wddxRecordset_addColumn;
 this.addRows = wddxRecordset_addRows;
 this.isColumn = wddxRecordset_isColumn;
 this.getField = wddxRecordset_getField;
 this.setField = wddxRecordset_setField;
 this.wddxSerialize = wddxRecordset_wddxSerialize;
 this.dump = wddxRecordset_dump;

 if (WddxRecordset.arguments.length > 0)
{
 if (typeof(val = WddxRecordset.arguments[0].valueOf()) == "boolean")
{

 this.preserveFieldCase = WddxRecordset.arguments[0];
}
 else
{

 var cols = WddxRecordset.arguments[0];

 var nLen = 0;
 if (WddxRecordset.arguments.length > 1)
{
 if (typeof(val = WddxRecordset.arguments[1].valueOf()) == "boolean")
{

 this.preserveFieldCase = WddxRecordset.arguments[1];
}
 else
{

 nLen = WddxRecordset.arguments[1];

 if (WddxRecordset.arguments.length > 2)
{

 this.preserveFieldCase = WddxRecordset.arguments[2];
}
}
}
 
 for (var i = 0; i < cols.length; ++i)
{
 var colValue = new Array(nLen);
 for (var j = 0; j < nLen; ++j)
{
 colValue[j] = null;
}
 
 this[this.preserveFieldCase ? cols[i] : cols[i].toLowerCase()] = colValue;
}
}
}
}










































function registerWddxRecordsetExtension(name, func)
{

 if (typeof(name) == "string" && typeof(func) == "function")
{

 if (typeof(wddxRecordsetExtensions) != "object")
{

 wddxRecordsetExtensions = new Object();
}

 wddxRecordsetExtensions[name] = func;
}
}








function wddxBinary_wddxSerialize(serializer) 
{
 serializer.write(
 "<binary encoding='" + this.encoding + "'>" + this.data + "</binary>");
 return true;
}




function WddxBinary(data, encoding)
{
 this.data = data != null ? data : "";
 this.encoding = encoding != null ? encoding : "base64";

 this.wddxSerialize = wddxBinary_wddxSerialize;
}












function wddxDeserializer_parseSimpleType (Contents){//hi

 var DataType = Contents.name;

 if (DataType == 'boolean'){
 return (Contents.attributes["value"]=='true');

}else{

 var Value = Contents.contents.length > 0 ? Contents.contents[0].value : '';

 if (DataType == 'string'){
 if (Contents.contents.length > 1){
 Value = '';
 for (StrItem = 0; StrItem < Contents.contents.length; StrItem++){
 if (Contents.contents[StrItem].type == 'chardata')
 Value = Value + Contents.contents[StrItem].value;
 else if (Contents.contents[StrItem].name == 'char'){
 Code = Contents.contents[StrItem].attributes["code"];
 if (Code == '0D') Value = Value + '\r';
 else if (Code == '0C') Value = Value + '\f';
 else if (Code == '0A') Value = Value + '\n';
 else if (Code == '09') Value = Value + '\t';
}
}
}
 return Value;
}

 else if (DataType == 'number'){
 return parseFloat(Value);
}

 else if (DataType == 'null'){
 return null;
}

 else if (DataType == 'dateTime'){

 var Value = splitAny(Value, 'T');
 var dtDateParts = splitAny(Value[0], '-');
 var NewDate;
 

 if ( (Value[1].indexOf('-') == -1) & (Value[1].indexOf('+') == -1) ){

 var dtTimeParts = splitAny(Value[1], ':');
 NewDate = new Date(dtDateParts[0], dtDateParts[1]-1, dtDateParts[2], dtTimeParts[0], dtTimeParts[1], dtTimeParts[2]);
 
}else{


 if (Value[1].indexOf('-') > -1) dtTimeTZParts = splitAny(Value[1], '-');
 else dtTimeTZParts = splitAny(Value[1], '+');
 var dtTimeParts = splitAny(dtTimeTZParts[0], ':');

 NewDate = new Date(dtDateParts[0], dtDateParts[1]-1, dtDateParts[2], dtTimeParts[0], dtTimeParts[1], dtTimeParts[2]);

 if (this.useTimezoneInfo == true){
 var dtTZParts = splitAny(dtTimeTZParts[1], ':');
 var dtOffsetHours = parseInt(dtTZParts[0]);
 var dtOffsetMins = parseInt(dtTZParts[1]);
 if (Value[1].indexOf('-') > -1){
 dtOffsetHours = this.timezoneOffsetHours - dtOffsetHours;
 dtOffsetMins = this.timezoneOffsetMinutes - dtOffsetMins;
}else{
 dtOffsetHours = this.timezoneOffsetHours + dtOffsetHours;
 dtOffsetMins = this.timezoneOffsetMinutes + dtOffsetMins;
}
 NewDate.setHours(NewDate.getHours() - dtOffsetHours);
 NewDate.setMinutes(NewDate.getMinutes() - dtOffsetMins);
}
 
}
 return NewDate;

}
}
 return null;
}





function wddxDeserializer_parseArray(ArrayAsWDDX){


 var JSArray = new Array();
 var ArrayLength = parseInt(ArrayAsWDDX.attributes["length"]);


 for (var Count = 0; Count < ArrayLength; Count++){
 JSArray[Count] = this.parseElement(ArrayAsWDDX.contents[Count]);
}

 return JSArray;
}





function wddxDeserializer_parseStruct(StructAsWDDX){

 var JSObject;

 var StructLength = StructAsWDDX.contents.length;



 var bCustom = false;
 
 if (typeof(StructAsWDDX.attributes["type"]) == 'string'){
 var ConstructorTest = 'typeof(' +StructAsWDDX.attributes["type"]+ ')';
 if ( eval(ConstructorTest) == 'function' )
 bCustom = true;
}

 if (bCustom) JSObject = eval('new '+ StructAsWDDX.attributes["type"]);
 else JSObject = new Object;



 for (var Count = 0; Count < StructLength; Count++){
 var StructIndex = (this.preserveVarCase == true) ? StructAsWDDX.contents[Count].attributes["name"] : (this.varCaseToUpper == true) ? StructAsWDDX.contents[Count].attributes["name"].toUpperCase() : StructAsWDDX.contents[Count].attributes["name"].toLowerCase(); 
 JSObject[StructIndex] = this.parseElement(StructAsWDDX.contents[Count].contents[0]);
}

 return JSObject;
}





function wddxDeserializer_parseRecordset(RSAsWDDX){




 var RSInfo = RSAsWDDX;
 var RSColNames = RSInfo.attributes["fieldNames"].toLowerCase();
 var RSCols = splitAny(RSColNames, ',');
 var RSRows = parseInt(RSInfo.attributes["rowCount"]);
 var ThisRS = new WddxRecordset(RSCols, RSRows); // Note dependency on external wddx.js source file



 for (var ColNo = 0; ColNo < RSCols.length; ColNo++){
 ThisCol = RSCols[ColNo];
 ColArray = new Array();

 for (var RowNo = 0; RowNo < RSRows; RowNo++){
 ColArray[RowNo] = this.parseSimpleType(RSInfo.contents[ColNo].contents[RowNo]);
}

 ThisRS[ThisCol] = ColArray;
}

 return ThisRS;
}





function wddxDeserializer_parseElement(Element){


 if (Element.name == 'recordset'){
 return this.parseRecordset(Element);
}

 else if (Element.name == 'array'){
 return this.parseArray(Element);
}

 else if (Element.name == 'struct'){
 return this.parseStruct(Element);
}

 else if (Element.name == 'binary'){
 var Bin = new WddxBinary;
 Bin.encoding = (typeof(Element.attributes["encoding"]) == 'string') ? Element.attributes["encoding"] : 'base64'; 
 
 if (this.preserveBinaryData){
 Bin.data = (typeof(Element.contents[0].value) == 'string') ? Element.contents[0].value : ''; 
};
 
 return Bin;
}


 else{
 return this.parseSimpleType(Element);
};

 return '';
}




function splitAny(String, Sep){
 if (String.split) SplitArray = String.split(Sep);
 else SplitArray = splitOld(String, Sep);
 
 return SplitArray;
}




function joinAny(theArray, Sep){
 if (theArray.join) JoinedString = theArray.join(Sep);
 else JoinedString = joinOld(theArray, Sep);
 
 return JoinedString;
}



function wddxDeserializer_deserialize(WDDXPacket){

 this.varCaseToUpper = (this.defaultVarCase.toLowerCase() != 'lower');

 this.topLevelDatatype = null; 

 this.timezoneOffsetHours = Math.round(this.timezoneOffset/60);
 this.timezoneOffsetMinutes = (this.timezoneOffset % 60);

 _Xparse_count = 0; // "Resets" the Xparse parser
 var XMLRoot = Xparse(WDDXPacket); // Returns XML object structure 
 WDDXPacket = ''; // Discards WDDXPacket variable




 for (var item = 0; item < XMLRoot.index.length; item++){
 var ThisItem = XMLRoot.index[item];
 if (ThisItem.name == 'data'){
 this.topLevelDatatype = ThisItem.contents[0].name;

 if (this.parseActualData == true){
 return this.parseElement(ThisItem.contents[0]);
 break;
}
}
}

 return null;
}



function wddxDeserializer_deserializeUrl(url){
 var i, pipe, result, packet, posStart, posEnd;
 var tokStart = '<wddxPacket';
 var tokEnd = '</wddxPacket>';


 if (url.indexOf('http') != 0){
 var ThisURL = window.location.href;
 var BaseURL = ThisURL.substring(0, ThisURL.lastIndexOf('/'));
 url = BaseURL + '/' + url;
}

 for (i = 0; i < document.applets.length; i++){

 if ( (typeof document.applets[i].getClass != 'undefined') && (document.applets[i].getClass() == 'class urlPipe') ){
 pipe = document.applets[i];
 pipe.catchPage = true;

 bAdded = false;
 if (typeof(this.urlData) == 'object'){
 for (prop in this.urlData){
 pipe.addParam( escape(prop.toString()), escape(this.urlData[prop].toString()) );
 bAdded = true;
};
};

 if (bAdded == false) pipe.addParam('dummyParam', 1);

 pipe.post( url ); 
 packet = new String(pipe.getPage());
 posStart = packet.indexOf(tokStart);
 posEnd = packet.indexOf(tokEnd, posStart);

 if (posEnd > posStart){
 packet = packet.substring( posStart, (posEnd + tokEnd.length) ); 
 result = this.deserialize(packet);
}

 this.urlData = new Object;

 break;
};
};

 return result;
};




function WddxDeserializer(){


 this.preserveVarCase = false;
 this.defaultVarCase = 'upper';

 this.preserveBinaryData = true;

 this.useTimezoneInfo = false;


 var TempDate = new Date;
 this.timezoneOffset = TempDate.getTimezoneOffset();

 this.topLevelDatatype = null;
 this.parseActualData = true;

 this.urlData = new Object;

 this.parseElement = wddxDeserializer_parseElement;
 this.parseSimpleType = wddxDeserializer_parseSimpleType;
 this.parseArray = wddxDeserializer_parseArray;
 this.parseStruct = wddxDeserializer_parseStruct;
 this.parseRecordset = wddxDeserializer_parseRecordset;

 this.deserialize = wddxDeserializer_deserialize;
 this.deserializeUrl = wddxDeserializer_deserializeUrl;

 this.implementation = 'JS';
}



function WDDXDeserialize(Packet){
 var Deser = new WddxDeserializer;
 return Deser.deserialize(Packet);
}



























function _element()
{
 this.type = "element";
 this.name = new String();
 this.attributes = new Array();
 this.contents = new Array();
 this.uid = _Xparse_count++;
 _Xparse_index[this.uid]=this;
}

function _chardata()
{
 this.type = "chardata";
 this.value = new String();
}

function _pi()
{
 this.type = "pi";
 this.value = new String();
}

function _comment()
{
 this.type = "comment";
 this.value = new String();
}

function _frag()
{
 this.str = new String();
 this.ary = new Array();
 this.end = new String();
}


var _Xparse_count = 0;
var _Xparse_index = new Array();

var _Xparse_isSplitSupported = ('Testing'.split && _Xparse_index.join);
var _Xparse_isFromCharCodeSupported = ('Testing'.fromCharCode == 'function');





function Xparse(src)
{
 var frag = new _frag();

 frag.str = _prolog(src);

 var root = new _element();
 root.name="ROOT";

 frag = _compile(frag);

 root.contents = frag.ary;
 root.index = _Xparse_index;
 _Xparse_index = new Array();
 return root;
}



function _compile(frag)
{

 while(1)
{

 if(frag.str.length == 0)
{
 return frag;
}

 var TagStart = frag.str.indexOf("<");

 if(TagStart != 0)
{

 var thisary = frag.ary.length;
 frag.ary[thisary] = new _chardata();
 if(TagStart == -1)
{
 frag.ary[thisary].value = _entity(frag.str);
 frag.str = "";
}
 else
{
 frag.ary[thisary].value = _entity(frag.str.substring(0,TagStart));
 frag.str = frag.str.substring(TagStart,frag.str.length);
}
}
 else
{

 if(frag.str.substring(1,2) == "?")
{
 frag = _tag_pi(frag);
}
 else
{
 if(frag.str.substring(1,4) == "!--")
{
 frag = _tag_comment(frag);
}
 else
{
 if(frag.str.substring(1,9) == "![CDATA[")
{
 frag = _tag_cdata(frag);
}
 else
{
 if(frag.str.substring(1,frag.end.length + 3) == "/" + frag.end + ">" || _strip(frag.str.substring(1,frag.end.length + 3)) == "/" + frag.end)
{

 frag.str = frag.str.substring(frag.end.length + 3,frag.str.length);
 frag.end = "";
 return frag;
}
 else
{
 frag = _tag_element(frag);
}
}
}
}

}
}
 return "";
}




function _tag_element(frag)
{

 var close = frag.str.indexOf(">");
 var empty = (frag.str.substring(close - 1,close) == "/");
 if(empty)
{
 close -= 1;
}

 var starttag = _normalize(frag.str.substring(1,close));
 var nextspace = starttag.indexOf(" ");
 var attribs = new String();
 var name = new String();
 if(nextspace != -1)
{
 name = starttag.substring(0,nextspace);
 attribs = starttag.substring(nextspace + 1,starttag.length);
}
 else
{
 name = starttag;
}

 var thisary = frag.ary.length;
 frag.ary[thisary] = new _element();
 frag.ary[thisary].name = _strip(name);
 if(attribs.length > 0)
{
 frag.ary[thisary].attributes = _attribution(attribs);
}
 if(!empty)
{


 var contents = new _frag();
 contents.str = frag.str.substring(close + 1,frag.str.length);
 contents.end = name;
 contents = _compile(contents);
 frag.ary[thisary].contents = contents.ary;
 frag.str = contents.str;
}
 else
{
 frag.str = frag.str.substring(close + 2,frag.str.length);
}
 return frag;
}

function _tag_pi(frag)
{
 var close = frag.str.indexOf("?>");
 var val = frag.str.substring(2,close);
 var thisary = frag.ary.length;
 frag.ary[thisary] = new _pi();
 frag.ary[thisary].value = val;
 frag.str = frag.str.substring(close + 2,frag.str.length);
 return frag;
}

function _tag_comment(frag)
{
 var close = frag.str.indexOf("-->");
 var val = frag.str.substring(4,close);
 var thisary = frag.ary.length;
 frag.ary[thisary] = new _comment();
 frag.ary[thisary].value = val;
 frag.str = frag.str.substring(close + 3,frag.str.length);
 return frag;
}

function _tag_cdata(frag)
{
 var close = frag.str.indexOf("]]>");
 var val = frag.str.substring(9,close);
 var thisary = frag.ary.length;
 frag.ary[thisary] = new _chardata();
 frag.ary[thisary].value = val;
 frag.str = frag.str.substring(close + 3,frag.str.length);
 return frag;
}




function _attribution(str)
{
 var all = new Array();
 while(1)
{
 var eq = str.indexOf("=");
 if(str.length == 0 || eq == -1)
{
 return all;
}

 var id1 = str.indexOf("\'");
 var id2 = str.indexOf("\"");
 var ids = new Number();
 var id = new String();
 if((id1 < id2 && id1 != -1) || id2 == -1)
{
 ids = id1;
 id = "\'";
}
 if((id2 < id1 || id1 == -1) && id2 != -1)
{
 ids = id2;
 id = "\"";
}
 var nextid = str.indexOf(id,ids + 1);
 var val = str.substring(ids + 1,nextid);

 var name = _strip(str.substring(0,eq));
 all[name] = _entity(val);
 str = str.substring(nextid + 1,str.length);
}
 return "";
}




function _prolog(str)
{
 var A = new Array();

 if (_Xparse_isSplitSupported){
 A = str.split("\r\n");
 str = A.join("\n");
 A = str.split("\r");
 str = A.join("\n");
}else{
 A = splitOld(str, "\r\n");
 str = joinOld(A, "\n");
 A = splitOld(str, "\r");
 str = joinOld(A, "\n");
}

 var start = str.indexOf("<");
 if(str.substring(start,start + 3) == "<?x" || str.substring(start,start + 3) == "<?X" )
{
 var close = str.indexOf("?>");
 str = str.substring(close + 2,str.length);
}
 var start = str.indexOf("<!DOCTYPE");
 if(start != -1)
{
 var close = str.indexOf(">",start) + 1;
 var dp = str.indexOf("[",start);
 if(dp < close && dp != -1)
{
 close = str.indexOf("]>",start) + 2;
}
 str = str.substring(close,str.length);
}
 return str;
}



function _strip(str)
{
 var A = new Array();

 if (_Xparse_isSplitSupported){
 A = str.split("\n");
 str = A.join("");
 A = str.split(" ");
 str = A.join("");
 A = str.split("\t");
 str = A.join("");
}else{
 A = splitOld(str, "\n");
 str = joinOld(A, "");
 A = splitOld(str, " ");
 str = joinOld(A, "");
 A = splitOld(str, "\t");
 str = joinOld(A, "");
}

 return str;
}



function _normalize(str)
{
 var A = new Array();

 if (_Xparse_isSplitSupported){
 A = str.split("\n");
 str = A.join(" ");
 A = str.split("\t");
 str = A.join(" ");
}else{
 A = splitOld(str, "\n");
 str = joinOld(A, " ");
 A = splitOld(str, "\t");
 str = joinOld(A, " ");
}
 
 
 return str;
}



function _entity(str)
{
 var A = new Array();

 
 if (_Xparse_isSplitSupported){
 A = str.split("&lt;");
 str = A.join("<");
 A = str.split("&gt;");
 str = A.join(">");
 A = str.split("&quot;");
 str = A.join("\"");
 A = str.split("&apos;");
 str = A.join("\'");
 A = str.split("&amp;");
 str = A.join("&");

 while (str.indexOf('&#') > -1){
 var pos1 = str.indexOf('&#');
 var pos2 = str.indexOf(';', pos1);
 var ent = str.substring(pos1, pos2+1);
 var charNum = parseInt('0' + ent.substring(2));
 
 if (charNum.valueOf() > 0){
 if (_Xparse_isFromCharCodeSupported) 
 thisChar = String.fromCharCode(charNum);
 else 
 thisChar=chr(charNum-1);
};
 
 A = str.split(ent);
 str = A.join(thisChar);
}

}else{
 A = splitOld(str, "&lt;");
 str = joinOld(A, "<");
 A = splitOld(str, "&gt;");
 str = joinOld(A, ">");
 A = splitOld(str, "&quot;");
 str = joinOld(A, "\"");
 A = splitOld(str, "&apos;");
 str = joinOld(A, "\'");
 A = splitOld(str, "&amp;");
 str = joinOld(A, "&");

 while (str.indexOf('&#') > -1){
 var pos1 = str.indexOf('&#');
 var pos2 = str.indexOf(';', pos1);
 var ent = str.substring(pos1, pos2+1);
 var charNum = parseInt('0' + ent.substring(2));

 if (charNum.valueOf() > 0){
 if (_Xparse_isFromCharCodeSupported) 
 thisChar = String.fromCharCode(charNum);
 else 
 thisChar=chr(charNum-1);
};
 
 A = splitOld(str, ent);
 str = joinOld(str, thisChar);
}
}
 
 return str;
}





function splitOld(String, Sep){
 var NewArray = new Array;
 var Chunk = String;
 Sep = Sep.substring(0, 1);
 
 while (Chunk.indexOf(Sep) > -1){
 NextSep = Chunk.indexOf(Sep);
 NewArray[NewArray.length] = Chunk.substring(0, NextSep);
 Chunk = Chunk.substring(NextSep+1);
}

 NewArray[NewArray.length] = Chunk; 
 return NewArray;
}




function joinOld(theArray, Sep){
 Sep = Sep.substring(0, 1);
 
 if (theArray.length == 0) 
 NewString = '';
 else 
 NewString = theArray[0];
 
 for (var i = 1; i < theArray.length; i++){
 NewString = NewString + Sep + theArray[i];
}
 
 return NewString;
}

function CheckTree(myName)
{
 this.myName = myName;

 this.root = null;


 this.countAllLevels = false;

 this.checkFormat = '(%n%)';

 this.evtProcessed = navigator.userAgent.indexOf('Safari') > -1 ? 'safRtnVal' : 'returnValue';

 CheckTree.list[myName] = this;
};
CheckTree.list = [];

CheckTree.prototype.init = function(){with (this)
{
 if (!document.getElementById) return;
 root = document.getElementById('tree-' + myName);
 if (root)
{
 var lists = root.getElementsByTagName('ul');
 for (var ul = 0; ul < lists.length; ul++)
{

 lists[ul].style.display = 'none';
 lists[ul].treeObj = this;
 lists[ul].setBoxStates = setBoxStates;

 var fn = new Function('e', 'this.setBoxStates(e)');

 if (lists[ul].addEventListener && navigator.vendor != 'Apple Computer, Inc.')
{
 lists[ul].addEventListener('click', fn, false);
}
 else lists[ul].onclick = fn;
}

 root.treeObj = this;
 root.setBoxStates = setBoxStates;
 if (root.addEventListener && navigator.vendor != 'Apple Computer, Inc.')
{

 root.addEventListener('click', new Function('e', myName + '.click(e)'), false);
}
 else{
 root.onclick = new Function('e', myName + '.click(e)'); 
}

 root.setBoxStates({}, true, true);

 var nodes = root.getElementsByTagName('li');
 for (var li = 0; li < nodes.length; li++)
{
 if (nodes[li].id.match(/^show-/))
{
 nodes[li].className = (nodes[li].className=='last' ? 'plus-last' : 'plus');
}
}
}
}};

CheckTree.prototype.click = function(e){with (this)
{
 e = e || window.event;
 var elm = e.srcElement || e.target;



 if (!e[evtProcessed] && elm.id && elm.id.match(/^check-(.*)/))
{
 var tree = document.getElementById('tree-' + RegExp.$1);
 if (tree) tree.setBoxStates(e, true, false);
}

 while (elm)
{

 if (elm.tagName.match(/^(input|ul)/i)) break;

 if (elm.id && elm.id.match(/^show-(.*)/))
{
 var targ = document.getElementById('tree-' + RegExp.$1);
 if (targ.style)
{
 var col = (targ.style.display == 'none');
 targ.style.display = col ? 'block' : 'none';

 elm.className = elm.className.replace(col?'plus':'minus', col?'minus':'plus');
}
 break;
}

 elm = elm.parentNode;
}
}};






function setBoxStates(e, routingDown, countOnly){with (this)
{

 if (!this.childNodes) return;

 e = e || window.event;
 var elm = e.srcElement || e.target;



 if (elm && elm.id && elm.id.match(/^check-(.*)/) && !routingDown && !e[treeObj.evtProcessed])
{
 var refTree = document.getElementById('tree-' + RegExp.$1);
 if (refTree)
{
 refTree.setBoxStates(e, true, countOnly);
 e[treeObj.evtProcessed] = true;
}
}

 var allChecked = true, boxCount = 0, subBoxes = null;

 var thisLevel = this.id.match(/^tree-(.*)/)[1];
 var parBox = document.getElementById('check-' + thisLevel);

 for (var li = 0; li < childNodes.length; li++)
{
 for (var tag = 0; tag < childNodes[li].childNodes.length; tag++)
{
 var child = childNodes[li].childNodes[tag];
 if (!child) continue;
 if (child.tagName && child.type && child.tagName.match(/^input/i) &&
 child.type.match(/^checkbox/i))
{

 if (routingDown && parBox && elm && elm.id && elm.id.match(/^check-/) && !countOnly)
 child.checked = parBox.checked;

 allChecked &= child.checked;
 if (child.checked) boxCount++;
}

 if (child.tagName && child.tagName.match(/^ul/i) && (!e[treeObj.evtProcessed] || routingDown))
 child.setBoxStates(e, true, countOnly);
}
}


 if (!routingDown) e[treeObj.evtProcessed] = true;


 if (parBox && parBox != elm && !countOnly) parBox.checked = allChecked;

 if (treeObj.countAllLevels)
{
 boxCount = 0;
 var subBoxes = this.getElementsByTagName('input');
 for (var i = 0; i < subBoxes.length; i++) if (subBoxes[i].checked) boxCount++;
}

 var countElm = document.getElementById('count-' + thisLevel);
 if (countElm)
{
 while (countElm.firstChild) countElm.removeChild(countElm.firstChild);
 if (boxCount) countElm.appendChild(document.createTextNode(treeObj.checkFormat.replace('%n%',
 boxCount)));
}
}};










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 (http://script.aculo.us, http://mir.aculo.us)




















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') || (key == 'e')){// display previous image
 if(activeImage != 0){
 myLightbox.disableKeyboardNav();
 myLightbox.changeImage(activeImage - 1);
}
}else if((key == 'n') || (key == 'k')){// 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;
}
}







if(typeof deconcept == "undefined") var deconcept = new Object();
if(typeof deconcept.util == "undefined") deconcept.util = new Object();
if(typeof deconcept.SWFObjectUtil == "undefined") deconcept.SWFObjectUtil = new Object();
deconcept.SWFObject = function(swf, id, w, h, ver, c, useExpressInstall, quality, xiRedirectUrl, redirectUrl, detectKey){
 if (!document.getElementById){return;}
 this.DETECT_KEY = detectKey ? detectKey : 'detectflash';
 this.skipDetect = deconcept.util.getRequestParameter(this.DETECT_KEY);
 this.params = new Object();
 this.variables = new Object();
 this.attributes = new Array();
 if(swf){this.setAttribute('swf', swf);}
 if(id){this.setAttribute('id', id);}
 if(w){this.setAttribute('width', w);}
 if(h){this.setAttribute('height', h);}
 if(ver){this.setAttribute('version', new deconcept.PlayerVersion(ver.toString().split(".")));}
 this.installedVer = deconcept.SWFObjectUtil.getPlayerVersion();
 if(c){this.addParam('bgcolor', c);}
 var q = quality ? quality : 'high';
 this.addParam('quality', q);
 this.setAttribute('useExpressInstall', useExpressInstall);
 this.setAttribute('doExpressInstall', false);
 var xir = (xiRedirectUrl) ? xiRedirectUrl : window.location;
 this.setAttribute('xiRedirectUrl', xir);
 this.setAttribute('redirectUrl', '');
 if(redirectUrl){this.setAttribute('redirectUrl', redirectUrl);}
}
deconcept.SWFObject.prototype ={
 setAttribute: function(name, value){
 this.attributes[name] = value;
},
 getAttribute: function(name){
 return this.attributes[name];
},
 addParam: function(name, value){
 this.params[name] = value;
},
 getParams: function(){
 return this.params;
},
 addVariable: function(name, value){
 this.variables[name] = value;
},
 getVariable: function(name){
 return this.variables[name];
},
 getVariables: function(){
 return this.variables;
},
 getVariablePairs: function(){
 var variablePairs = new Array();
 var key;
 var variables = this.getVariables();
 for(key in variables){
 variablePairs.push(key +"="+ variables[key]);
}
 return variablePairs;
},
 getSWFHTML: function(){
 var swfNode = "";
 if (navigator.plugins && navigator.mimeTypes && navigator.mimeTypes.length){// netscape plugin architecture
 if (this.getAttribute("doExpressInstall")){this.addVariable("MMplayerType", "PlugIn");}
 swfNode = '<embed type="application/x-shockwave-flash" src="'+ this.getAttribute('swf') +'" width="'+ this.getAttribute('width') +'" height="'+ this.getAttribute('height') +'"';
 swfNode += ' id="'+ this.getAttribute('id') +'" name="'+ this.getAttribute('id') +'" ';
 var params = this.getParams();
 for(var key in params){swfNode += [key] +'="'+ params[key] +'" ';}
 var pairs = this.getVariablePairs().join("&");
 if (pairs.length > 0){swfNode += 'flashvars="'+ pairs +'"';}
 swfNode += '/>';
}else{// PC IE
 if (this.getAttribute("doExpressInstall")){this.addVariable("MMplayerType", "ActiveX");}
 swfNode = '<object id="'+ this.getAttribute('id') +'" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="'+ this.getAttribute('width') +'" height="'+ this.getAttribute('height') +'">';
 swfNode += '<param name="movie" value="'+ this.getAttribute('swf') +'" />';
 var params = this.getParams();
 for(var key in params){
 swfNode += '<param name="'+ key +'" value="'+ params[key] +'" />';
}
 var pairs = this.getVariablePairs().join("&");
 if(pairs.length > 0){swfNode += '<param name="flashvars" value="'+ pairs +'" />';}
 swfNode += "</object>";
}
 return swfNode;
},
 write: function(elementId){
 if(this.getAttribute('useExpressInstall')){

 var expressInstallReqVer = new deconcept.PlayerVersion([6,0,65]);
 if (this.installedVer.versionIsValid(expressInstallReqVer) && !this.installedVer.versionIsValid(this.getAttribute('version'))){
 this.setAttribute('doExpressInstall', true);
 this.addVariable("MMredirectURL", escape(this.getAttribute('xiRedirectUrl')));
 document.title = document.title.slice(0, 47) + " - Flash Player Installation";
 this.addVariable("MMdoctitle", document.title);
}
}
 if(this.skipDetect || this.getAttribute('doExpressInstall') || this.installedVer.versionIsValid(this.getAttribute('version'))){
 var n = (typeof elementId == 'string') ? document.getElementById(elementId) : elementId;
 n.innerHTML = this.getSWFHTML();
 return true;
}else{
 if(this.getAttribute('redirectUrl') != ""){
 document.location.replace(this.getAttribute('redirectUrl'));
}
}
 return false;
}
}


deconcept.SWFObjectUtil.getPlayerVersion = function(){
 var PlayerVersion = new deconcept.PlayerVersion([0,0,0]);
 if(navigator.plugins && navigator.mimeTypes.length){
 var x = navigator.plugins["Shockwave Flash"];
 if(x && x.description){
 PlayerVersion = new deconcept.PlayerVersion(x.description.replace(/([a-zA-Z]|\s)+/, "").replace(/(\s+r|\s+b[0-9]+)/, ".").split("."));
}
}else{


 try{
 var axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.7");
}catch(e){
 try{
 var axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash.6");
 PlayerVersion = new deconcept.PlayerVersion([6,0,21]);
 axo.AllowScriptAccess = "always"; // throws if player version < 6.0.47 (thanks to Michael Williams @ Adobe for this code)
}catch(e){
 if (PlayerVersion.major == 6){
 return PlayerVersion;
}
}
 try{
 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
}catch(e){}
}
 if (axo != null){
 PlayerVersion = new deconcept.PlayerVersion(axo.GetVariable("$version").split(" ")[1].split(","));
}
}
 return PlayerVersion;
}
deconcept.PlayerVersion = function(arrVersion){
 this.major = arrVersion[0] != null ? parseInt(arrVersion[0]) : 0;
 this.minor = arrVersion[1] != null ? parseInt(arrVersion[1]) : 0;
 this.rev = arrVersion[2] != null ? parseInt(arrVersion[2]) : 0;
}
deconcept.PlayerVersion.prototype.versionIsValid = function(fv){
 if(this.major < fv.major) return false;
 if(this.major > fv.major) return true;
 if(this.minor < fv.minor) return false;
 if(this.minor > fv.minor) return true;
 if(this.rev < fv.rev) return false;
 return true;
}

deconcept.util ={
 getRequestParameter: function(param){
 var q = document.location.search || document.location.hash;
 if(q){
 var pairs = q.substring(1).split("&");
 for (var i=0; i < pairs.length; i++){
 if (pairs[i].substring(0, pairs[i].indexOf("=")) == param){
 return pairs[i].substring((pairs[i].indexOf("=")+1));
}
}
}
 return "";
}
}

deconcept.SWFObjectUtil.cleanupSWFs = function(){
 if (window.opera || !document.all) return;
 var objects = document.getElementsByTagName("OBJECT");
 for (var i=0; i < objects.length; i++){
 objects[i].style.display = 'none';
 for (var x in objects[i]){
 if (typeof objects[i][x] == 'function'){
 objects[i][x] = function(){};
}
}
}
}

deconcept.SWFObjectUtil.prepUnload = function(){
 __flash_unloadHandler = function(){};
 __flash_savedUnloadHandler = function(){};
 if (typeof window.onunload == 'function'){
 var oldUnload = window.onunload;
 window.onunload = function(){
 deconcept.SWFObjectUtil.cleanupSWFs();
 oldUnload();
}
}else{
 window.onunload = deconcept.SWFObjectUtil.cleanupSWFs;
}
}
if (typeof window.onbeforeunload == 'function'){
 var oldBeforeUnload = window.onbeforeunload;
 window.onbeforeunload = function(){
 deconcept.SWFObjectUtil.prepUnload();
 oldBeforeUnload();
}
}else{
 window.onbeforeunload = deconcept.SWFObjectUtil.prepUnload;
}

if (Array.prototype.push == null){Array.prototype.push = function(item){this[this.length] = item; return this.length;}}


var getQueryParamValue = deconcept.util.getRequestParameter;
var FlashObject = deconcept.SWFObject; // for legacy support
var SWFObject = deconcept.SWFObject;

function miracle_init(){
 if (document.getElementById("eolas_fix")){

 document.body.innerHTML = document.getElementById("eolas_fix").innerHTML;

}

 miracleLoadConfig();
 init_MyDTD();
 external_links();


 init_Popups();
 init_wysiwyg();
}



function fix_eolas(){
}

function miracleErrorLogging(){
 window.onerror = function(message, url, line){
 var query="message="+escape(message);
 query+="&url="+escape(url);
 query+="&line="+escape(line);
 query+="&referer="+escape(document.referrer);
 var img=new Image();
 img.src="/javascript_error.png?"+query;
}
}





function removeEvent(obj, evType, fn, useCapture){
 if (obj.removeEventListener){
 obj.removeEventListener(evType, fn, useCapture);
 return true;
}else{
 if (obj.detachEvent){
 var r = obj.detachEvent("on"+evType, fn);
 return r;
}else{
 alert("Handler could not be removed");
}
}
}


function external_links(){
 if (!document.getElementsByTagName) return; 
 var anchors = document.getElementsByTagName("a"); 
 for (var i=0; i<anchors.length; i++){
 var anchor = anchors[i]; 
 if (anchor.getAttribute("href") && anchor.getAttribute("rel") == "external"){
 anchor.target = "_blank"; 
}
}

 var anchors = document.getElementsByTagName("form"); 
 for (var i=0; i<anchors.length; i++){
 var anchor = anchors[i]; 
 if (anchor.getAttribute("rel") == "external"){
 anchor.target = "_blank"; 
}
}
}



function isValidEmail(address){
 var pattern=/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
 tmp=pattern.test(address);
 return tmp;
}


function isModuleLoaded(name){
 var module=document.getElementById("module_"+name);
 return module;
}



function server_action(module, method, parameters, debug){




 MySer = new WddxSerializer;
 MyWDDXPacket = MySer.serialize(parameters);

 Des = new WddxDeserializer();




 var xmlHttp = XmlHttp.create();
 if (xmlHttp){
 xmlHttp.open("POST", "/serveraction/", false);
 xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8');
 xmlHttp.send("module="+module+"&method="+method+"&packet="+escape(MyWDDXPacket));
 packet=xmlHttp.responseText;

 if (debug){
 alert("PACKET: "+packet);
}
 tmp=Des.deserialize(packet);
}else{
 tmp=false;
}



 return tmp;
}

function server_action_async(module, method, parameters, funct, debug){

 MySer = new WddxSerializer;
 MyWDDXPacket = MySer.serialize(parameters);
 Des = new WddxDeserializer();

 var xmlHttp = XmlHttp.create();
 if (xmlHttp){
 xmlHttp.open("POST", "/serveraction/", true);
 xmlHttp.onreadystatechange = function (){
 if (xmlHttp.readyState == 4){
 packet=xmlHttp.responseText;
 tmp=packet;
 if (debug){
 alert(packet);
}
 tmp=Des.deserialize(packet);
 funct(tmp);
}
}
 xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8');
 xmlHttp.send("module="+module+"&method="+method+"&packet="+escape(MyWDDXPacket));
 tmp=true;
}else{
 tmp=false;
}
 return tmp;
}


function server_action_wait(on){
 var div=document.getElementById("serveraction_loading");
 div.style.visibility=on?'visible':'hidden';
}

function debug_watch(s){
 var debug=document.getElementById("debug");
 if (!debug){return;}
 debug.firstChild.nodeValue=s+" / "+debug.firstChild.nodeValue;
}

function isFunction(a){
 return typeof a == 'function';
}



var base64s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

function base64_encode(decStr){
decStr=escape(decStr); 
 var bits, dual, i = 0, encOut = '';
 while(decStr.length >= i + 3){
 bits =
 (decStr.charCodeAt(i++) & 0xff) <<16 |
 (decStr.charCodeAt(i++) & 0xff) <<8 |
 decStr.charCodeAt(i++) & 0xff;
 encOut +=
 base64s.charAt((bits & 0x00fc0000) >>18) +
 base64s.charAt((bits & 0x0003f000) >>12) +
 base64s.charAt((bits & 0x00000fc0) >> 6) +
 base64s.charAt((bits & 0x0000003f));
}
 if(decStr.length -i > 0 && decStr.length -i < 3){
 dual = Boolean(decStr.length -i -1);
 bits =
 ((decStr.charCodeAt(i++) & 0xff) <<16) |
 (dual ? (decStr.charCodeAt(i) & 0xff) <<8 : 0);
 encOut +=
 base64s.charAt((bits & 0x00fc0000) >>18) +
 base64s.charAt((bits & 0x0003f000) >>12) +
 (dual ? base64s.charAt((bits & 0x00000fc0) >>6) : '=') +
 '=';
}
 return encOut
}

function base64_decode(encStr){
 var bits, decOut = '', i = 0;
 for(; i<encStr.length; i += 4){
 bits =
 (base64s.indexOf(encStr.charAt(i)) & 0xff) <<18 |
 (base64s.indexOf(encStr.charAt(i +1)) & 0xff) <<12 | 
 (base64s.indexOf(encStr.charAt(i +2)) & 0xff) << 6 |
 base64s.indexOf(encStr.charAt(i +3)) & 0xff;
 decOut += String.fromCharCode(
 (bits & 0xff0000) >>16, (bits & 0xff00) >>8, bits & 0xff);
}
 if(encStr.charCodeAt(i -2) == 61)
 undecOut=decOut.substring(0, decOut.length -2);
 else if(encStr.charCodeAt(i -1) == 61)
 undecOut=decOut.substring(0, decOut.length -1);
 else undecOut=decOut;
 
 return unescape(undecOut); 
}

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


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 inArray(array,value)
{
 var i=0;
 while (array[i]!=value && i<array.length)
{i++;}
 return (array[i]==value);
};

function delElementWithValue(array,value)
{
 var i;
 var newarray=new Array();
 for (i=0; i<array.length; i++)
{
 if (array[i]!=value)
{newarray[newarray.length]=array[i];}
}
 return newarray;
}

function indexWithValue(array,value)
{
 var i=0;
 while (array[i]!=value && i<array.length)
{
 i++;
}

 return i;
}

function getSelectedOptions(select){
 var tmp=new Array();
 var j=0;
 for (var i=0; i<select.options.length; i++){
 if (select.options[i].selected){
 tmp[j]=i;
 j++;
}
}
 return tmp;
}

function getFirstBiggerOption(select, option_text){
 var i=0;
 while (i<select.length && strcmp(select[i].firstChild.nodeValue, option_text)<=0){
 i++;
}
 return select[i];
}



function strcmp(str1 , str2){
 function stringCode(str){
 str = str.replace('á',"azzz");
 str = str.replace('é',"ezzz");
 str = str.replace('í',"izzz");
 
 str = str.replace('ó',"oxxx");
 str = str.replace('ö',"oyyy");
 str = str.replace('ő',"ozzz");
 
 str = str.replace('ú',"uxxx");
 str = str.replace('ü',"uyyy");
 str = str.replace('ű',"uzzz");
 
 str = str.replace('Á',"AZZZ");
 str = str.replace('é',"EZZZ");
 str = str.replace('í',"IZZZ");
 
 str = str.replace('ó',"OXXX");
 str = str.replace('ö',"OYYY");
 str = str.replace('ő',"OZZZ");
 
 str = str.replace('ú',"UXXX");
 str = str.replace('ü',"UYYY");
 str = str.replace('ű',"UZZZ");
 return str;
}

 var string1=stringCode(str1); 
 var string2=stringCode(str2); 
 
 if (string1<string2) val=-1;
 if (string1==string2) val=0;
 if (string1>string2) val=1;

 return (val);
}

function sleep(millisec){
 var date=new Date();
 var curDate=null;
 do{
 var curDate=new Date(); 
}while (curDate-date<millisec);
}

function loadExternalCSS(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);
}


function loadExternalJS(url){

 var head=document.getElementsByTagName("head")[0];
 var node=document.createElement("script");
 node.setAttribute("type", "text/javascript");
 node.setAttribute("loaded", false);
 node.setAttribute("src", url);
 node.setAttribute("id", url);

 document.getElementsByTagName("head")[0].appendChild(node);
 while (node.readyState!="complete"){
 var i=i+1;
}
}

function miracleLoadConfig(){
 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_"){
 miracleConfig[name]=content;
}
}
}

function hoverEmulation(id){
 if (document.all && document.getElementById && !window.opera){// ie
 if (!document.getElementById(id)){

 return false;
}
 var sfEls = document.getElementById(id).getElementsByTagName("LI");
 for (var i=0; i<sfEls.length; i++){
 sfEls[i].onmouseover=function(){
 this.className+=" hover";

}
 sfEls[i].onmouseout=function(){
 this.className=this.className.replace(new RegExp(" hover\\b"), "");
}
}
}
}

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

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