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

var Prototype ={
 Version: '1.5.0_rc1',
 BrowserFeatures:{
 XPath: !!document.evaluate
},

 ScriptFragment: '(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)',
 emptyFunction: function(){},
 K: function(x){return x}
}

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

var Abstract = new Object();

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

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

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

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

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

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

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

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

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

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

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

 for (var i = 0; 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(){
 this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
},

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

 onTimerEvent: function(){
 if (!this.currentlyExecuting){
 try{
 this.currentlyExecuting = true;
 this.callback(this);
}finally{
 this.currentlyExecuting = false;
}
}
}
}
Object.extend(String.prototype,{
 gsub: function(pattern, replacement){
 var result = '', source = this, match;
 replacement = arguments.callee.prepareReplacement(replacement);

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

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

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

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

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

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

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

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

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

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

 escapeHTML: function(){
 var div = document.createElement('div');
 var text = document.createTextNode(this);
 div.appendChild(text);
 return div.innerHTML;
},

 unescapeHTML: function(){
 var div = document.createElement('div');
 div.innerHTML = this.stripTags();
 return div.childNodes[0] ? div.childNodes[0].nodeValue : '';
},

 toQueryParams: function(){
 var pairs = this.match(/^\??(.*)$/)[1].split('&');
 return pairs.inject({}, function(params, pairString){
 var pair = pairString.split('=');
 var value = pair[1] ? decodeURIComponent(pair[1]) : undefined;
 params[decodeURIComponent(pair[0])] = value;
 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(useDoubleQuotes){
 var escapedString = this.replace(/\\/g, '\\\\');
 if (useDoubleQuotes)
 return '"' + escapedString.replace(/"/g, '\\"') + '"';
 else
 return "'" + escapedString.replace(/'/g, '\\\'') + "'";
}
});

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

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

var Template = Class.create();
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
Template.prototype ={
 initialize: function(template, pattern){
 this.template = template.toString();
 this.pattern = pattern || Template.Pattern;
},

 evaluate: function(object){
 return this.template.gsub(this.pattern, function(match){
 var before = match[1];
 if (before == '\\') return match[2];
 return before + (object[match[3]] || '').toString();
});
}
}

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 = false;
 this.each(function(value, index){
 if (result = !!(iterator || Prototype.K)(value, index))
 throw $break;
});
 return result;
},

 collect: function(iterator){
 var results = [];
 this.each(function(value, index){
 results.push(iterator(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 (result == undefined || value >= result)
 result = value;
});
 return result;
},

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

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

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

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

 sortBy: function(iterator){
 return this.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){
 return iterator(collections.pluck(index));
});
},

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

if (!Array.prototype._reverse)
 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 && 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();
},

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

 uniq: function(){
 return this.inject([], function(array, value){
 return array.include(value) ? array : array.concat([value]);
});
},

 inspect: function(){
 return '[' + this.map(Object.inspect).join(', ') + ']';
}
});
var Hash ={
 _each: function(iterator){
 for (var key in this){
 var value = this[key];
 if (typeof value == 'function') continue;

 var pair = [key, value];
 pair.key = key;
 pair.value = value;
 iterator(pair);
}
},

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

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

 merge: function(hash){
 return $H(hash).inject($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;
 while (this.include(value)){
 iterator(value);
 value = value.succ();
}
},

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

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

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

 activeRequestCount: 0
}

Ajax.Responders ={
 responders: [],

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

 register: function(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,
 contentType: 'application/x-www-form-urlencoded',
 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 += '&_=';

 
 if (this.options.method != 'get' && this.options.method != 'post'){
 parameters += (parameters.length > 0 ? '&' : '') + '_method=' + this.options.method;
 this.options.method = 'post';
}

 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)
 setTimeout(function(){this.respondToReadyState(1)}.bind(this), 10);

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

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

 
 if (!this.options.asynchronous && this.transport.overrideMimeType)
 this.onStateChange();

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

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

 if (this.options.method == 'post'){
 requestHeaders.push('Content-type', this.options.contentType);

 
 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.options.onComplete = undefined;
 clearTimeout(this.timer);
 (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
},

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

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

 onTimerEvent: function(){
 this.updater = new Ajax.Updater(this.container, this.url, this.options);
}
});
function $(){
 var results = [], element;
 for (var i = 0; i < arguments.length; i++){
 element = arguments[i];
 if (typeof element == 'string')
 element = document.getElementById(element);
 results.push(Element.extend(element));
}
 return results.reduce();
}

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

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


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

Element.extend = function(element){
 if (!element) return;
 if (_nativeExtensions || element.nodeType == 3) return element;

 if (!element._extended && element.tagName && element != window){
 var methods = Object.clone(Element.Methods), cache = Element.extend.cache;


 if (element.tagName == 'FORM')
 Object.extend(methods, Form.Methods);
 if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
 Object.extend(methods, Form.Element.Methods);

 for (var property in methods){
 var value = methods[property];
 if (typeof value == 'function')
 element[property] = cache.findOrStore(value);
}
}

 element._extended = true;
 return element;
}

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

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

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

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

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

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

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

 replace: function(element, html){
 element = $(element);
 if (element.outerHTML){
 element.outerHTML = html.stripScripts();
}else{
 var range = element.ownerDocument.createRange();
 range.selectNodeContents(element);
 element.parentNode.replaceChild(
 range.createContextualFragment(html.stripScripts()), element);
}
 setTimeout(function(){html.evalScripts()}, 10);
 return element;
},

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

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

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

 descendants: function(element){
 element = $(element);
 return $A(element.getElementsByTagName('*'));
},

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

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

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

 match: function(element, selector){
 element = $(element);
 if (typeof selector == 'string')
 selector = new Selector(selector);
 return selector.match(element);
},

 up: function(element, expression, index){
 return Selector.findElement($(element).ancestors(), expression, index);
},

 down: function(element, expression, index){
 return Selector.findElement($(element).descendants(), expression, index);
},

 previous: function(element, expression, index){
 return Selector.findElement($(element).previousSiblings(), expression, index);
},

 next: function(element, expression, index){
 return Selector.findElement($(element).nextSiblings(), expression, index);
},

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

 getElementsByClassName: function(element, className){
 element = $(element);
 return document.getElementsByClassName(className, element);
},

 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;
 Element.classNames(element).add(className);
 return element;
},

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

 observe: function(){
 Event.observe.apply(Event, arguments);
 return $A(arguments).first();
},

 stopObserving: function(){
 Event.stopObserving.apply(Event, arguments);
 return $A(arguments).first();
},

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

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

 childOf: function(element, ancestor){
 element = $(element), ancestor = $(ancestor);
 while (element = element.parentNode)
 if (element == ancestor) return true;
 return false;
},

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

 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 (var name in style)
 element.style[name.camelize()] = style[name];
 return element;
},

 getDimensions: function(element){
 element = $(element);
 if (Element.getStyle(element, 'display') != 'none')
 return{width: element.offsetWidth, height: element.offsetHeight};


 var els = element.style;
 var originalVisibility = els.visibility;
 var originalPosition = els.position;
 els.visibility = 'hidden';
 els.position = 'absolute';
 els.display = '';
 var originalWidth = element.clientWidth;
 var originalHeight = element.clientHeight;
 els.display = 'none';
 els.position = originalPosition;
 els.visibility = originalVisibility;
 return{width: originalWidth, height: originalHeight};
},

 makePositioned: function(element){
 element = $(element);
 var pos = Element.getStyle(element, 'position');
 if (pos == 'static' || !pos){
 element._madePositioned = true;
 element.style.position = 'relative';


 if (window.opera){
 element.style.top = 0;
 element.style.left = 0;
}
}
 return element;
},

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

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

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

if(document.all){
 Element.Methods.update = function(element, html){
 element = $(element);
 var tagName = element.tagName.toUpperCase();
 if (['THEAD','TBODY','TR','TD'].indexOf(tagName) > -1){
 var div = document.createElement('div');
 switch (tagName){
 case 'THEAD':
 case 'TBODY':
 div.innerHTML = '<table><tbody>' + html.stripScripts() + '</tbody></table>';
 depth = 2;
 break;
 case 'TR':
 div.innerHTML = '<table><tbody><tr>' + html.stripScripts() + '</tr></tbody></table>';
 depth = 3;
 break;
 case 'TD':
 div.innerHTML = '<table><tbody><tr><td>' + html.stripScripts() + '</td></tr></tbody></table>';
 depth = 4;
}
 $A(element.childNodes).each(function(node){
 element.removeChild(node)
});
 depth.times(function(){div = div.firstChild});

 $A(div.childNodes).each(
 function(node){element.appendChild(node)});
}else{
 element.innerHTML = html.stripScripts();
}
 setTimeout(function(){html.evalScripts()}, 10);
 return element;
}
}

Object.extend(Element, Element.Methods);

var _nativeExtensions = false;

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

Element.addMethods = function(methods){
 Object.extend(Element.Methods, methods ||{});

 function copy(methods, destination){
 var cache = Element.extend.cache;
 for (var property in methods){
 var value = methods[property];
 destination[property] = cache.findOrStore(value);
}
}

 if (typeof HTMLElement != 'undefined'){
 copy(Element.Methods, HTMLElement.prototype);
 copy(Form.Methods, HTMLFormElement.prototype);
 [HTMLInputElement, HTMLTextAreaElement, HTMLSelectElement].each(function(klass){
 copy(Form.Element.Methods, klass.prototype);
});
 _nativeExtensions = true;
}
}

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


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

Abstract.Insertion.prototype ={
 initialize: function(element, content){
 this.element = $(element);
 this.content = content.stripScripts();

 if (this.adjacency && this.element.insertAdjacentHTML){
 try{
 this.element.insertAdjacentHTML(this.adjacency, this.content);
}catch (e){
 var tagName = this.element.tagName.toLowerCase();
 if (tagName == 'tbody' || tagName == 'tr'){
 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 Selector = Class.create();
Selector.prototype ={
 initialize: function(expression){
 this.params ={classNames: []};
 this.expression = expression.toString().strip();
 this.parseExpression();
 this.compileMatcher();
},

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

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

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

 if (expr == '*') return this.params.wildcard = true;

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

 if (expr.length > 0) abort(expr.inspect());
},

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

 if (params.wildcard)
 conditions.push('true');
 if (clause = params.id)
 conditions.push('element.id == ' + clause.inspect());
 if (clause = params.tagName)
 conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
 if ((clause = params.classNames).length > 0)
 for (var i = 0; i < clause.length; i++)
 conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
 if (clause = params.attributes){
 clause.each(function(attribute){
 var value = 'element.getAttribute(' + attribute.name.inspect() + ')';
 var splitValueBy = function(delimiter){
 return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
}

 switch (attribute.operator){
 case '=': conditions.push(value + ' == ' + attribute.value.inspect()); break;
 case '~=': conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
 case '|=': conditions.push(
 splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()
 ); break;
 case '!=': conditions.push(value + ' != ' + attribute.value.inspect()); break;
 case '':
 case undefined: conditions.push(value + ' != null'); break;
 default: throw 'Unknown operator ' + attribute.operator + ' in selector';
}
});
}

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

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

 findElements: function(scope){
 var element;

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

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

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

 return results;
},

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

Object.extend(Selector,{
 matchElements: function(elements, expression){
 var selector = new Selector(expression);
 return elements.select(selector.match.bind(selector));
},

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

 findChildElements: function(element, expressions){
 return expressions.map(function(expression){
 return expression.strip().split(/\s+/).inject([null], function(results, expr){
 var selector = new Selector(expr);
 return results.inject([], function(elements, result){
 return elements.concat(selector.findElements(result || element));
});
});
}).flatten();
}
});

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

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

 serializeElements: function(elements){
 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){
 return $A($(form).getElementsByTagName('*')).inject([], function(elements, child){
 if (Form.Element.Serializers[child.tagName.toLowerCase()])
 elements.push(Element.extend(child));
 return elements;
});
},

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

 if (!typeName && !name)
 return 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){
 form = $(form);
 var elements = Form.getElements(form);
 for (var i = 0; i < elements.length; i++){
 var element = elements[i];
 element.blur();
 element.disabled = 'true';
}
 return form;
},

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

 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){
 form = $(form);
 Field.activate(Form.findFirstElement(form));
 return form;
}
}

Object.extend(Form, Form.Methods);


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

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

Form.Element.Methods ={
 serialize: function(element){
 element = $(element);
 var method = element.tagName.toLowerCase();
 var parameter = Form.Element.Serializers[method](element);

 if (parameter){
 var key = encodeURIComponent(parameter[0]);
 if (key.length == 0) return;

 if (parameter[1].constructor != Array)
 parameter[1] = [parameter[1]];

 return parameter[1].map(function(value){
 return key + '=' + encodeURIComponent(value);
}).join('&');
}
},

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

 if (parameter)
 return parameter[1];
},

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

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

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

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

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

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


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

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

 textarea: function(element){
 return [element.name, element.value];
},

 select: function(element){
 return Form.Element.Serializers[element.type == 'select-one' ?
 'selectOne' : 'selectMany'](element);
},

 selectOne: function(element){
 var value = '', opt, index = element.selectedIndex;
 if (index >= 0){
 opt = element.options[index];
 value = opt.value || opt.text;
}
 return [element.name, value];
},

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


var $F = Form.Element.getValue;


Abstract.TimedObserver = function(){}
Abstract.TimedObserver.prototype ={
 initialize: function(element, frequency, callback){
 this.frequency = frequency;
 this.element = $(element);
 this.callback = callback;

 this.lastValue = this.getValue();
 this.registerCallback();
},

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

 onTimerEvent: function(){
 var value = this.getValue();
 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;
 default:
 Event.observe(element, 'change', this.onElementEvent.bind(this));
 break;
}
}
}
}

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

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

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

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

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

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

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

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


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

 observers: false,

 _observeAndCache: function(element, name, observer, useCapture){
 if (!this.observers) this.observers = [];
 if (element.addEventListener){
 this.observers.push([element, name, observer, useCapture]);
 element.addEventListener(name, observer, useCapture);
}else if (element.attachEvent){
 this.observers.push([element, name, observer, useCapture]);
 element.attachEvent('on' + name, observer);
}
},

 unloadCache: function(){
 if (!Event.observers) return;
 for (var i = 0; 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){
 element = $(element);
 useCapture = useCapture || false;

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

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

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

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

 if (element.removeEventListener){
 element.removeEventListener(name, observer, useCapture);
}else if (element.detachEvent){
 try{
 element.detachEvent('on' + name, observer);
}catch (e){}
}
}
});

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



 includeScrollOffsets: false,


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

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

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

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

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

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

 return document.body;
},

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

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

 withinIncludingScrolloffsets: function(element, x, y){
 var offsetcache = this.realOffset(element);

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

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

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

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

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

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

}while (element = element.offsetParent);

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

 return [valueL, valueT];
},

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

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

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


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

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

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

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

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

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

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

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

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

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



if (/Konqueror|Safari|KHTML/.test(navigator.userAgent)){
 Position.cumulativeOffset = function(element){
 var valueT = 0, valueL = 0;
 do{
 valueT += element.offsetTop || 0;
 valueL += element.offsetLeft || 0;
 if (element.offsetParent == document.body)
 if (Element.getStyle(element, 'position') == 'absolute') break;

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

 return [valueL, valueT];
}
}

Element.addMethods();// EventSelectors 































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

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


























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

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

Scriptaculous.load();// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)








String.prototype.parseColor = function(){
 var color = '#'; 
 if(this.slice(0,4) == 'rgb('){
 var cols = this.slice(4,this.length-1).split(','); 
 var i=0; do{color += parseInt(cols[i]).toColorPart()}while (++i<3); 
}else{
 if(this.slice(0,1) == '#'){
 if(this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase(); 
 if(this.length==7) color = this.toLowerCase(); 
}
}
 return(color.length==7 ? color : (arguments[0] || this)); 
}


Element.collectTextNodes = function(element){
 return $A($(element).childNodes).collect( function(node){
 return (node.nodeType==3 ? node.nodeValue : 
 (node.hasChildNodes() ? Element.collectTextNodes(node) : ''));
}).flatten().join('');
}

Element.collectTextNodesIgnoreClass = function(element, className){
 return $A($(element).childNodes).collect( function(node){
 return (node.nodeType==3 ? node.nodeValue : 
 ((node.hasChildNodes() && !Element.hasClassName(node,className)) ? 
 Element.collectTextNodesIgnoreClass(node, className) : ''));
}).flatten().join('');
}

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

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

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

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

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

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


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


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

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

var Effect2 = Effect; // deprecated


Effect.Transitions ={}

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


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

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

 timestamp = this.effects.pluck('finishOn').max() || timestamp;
 break;
}
 
 effect.startOn += timestamp;
 effect.finishOn += timestamp;

 if(!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
 this.effects.push(effect);
 
 if(!this.interval) 
 this.interval = setInterval(this.loop.bind(this), 40);
},
 remove: function(effect){
 this.effects = this.effects.reject(function(e){return e==effect});
 if(this.effects.length == 0){
 clearInterval(this.interval);
 this.interval = null;
}
},
 loop: function(){
 var timePos = new Date().getTime();
 this.effects.invoke('loop', timePos);
}
});

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

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

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

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

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

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

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




 this.element.makePositioned();
 this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
 this.originalTop = parseFloat(this.element.getStyle('top') || '0');
 if(this.options.mode == 'absolute'){

 this.options.x = this.options.x - this.originalLeft;
 this.options.y = this.options.y - this.originalTop;
}
},
 update: function(position){
 this.element.setStyle({
 left: this.options.x * position + this.originalLeft + 'px',
 top: this.options.y * position + this.originalTop + 'px'
});
}
});

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

Effect.Scale = Class.create();
Object.extend(Object.extend(Effect.Scale.prototype, Effect.Base.prototype),{
 initialize: function(element, percent){
 this.element = $(element)
 var options = Object.extend({
 scaleX: true,
 scaleY: true,
 scaleContent: true,
 scaleFromCenter: false,
 scaleMode: 'box', // 'box' or 'contents' or{}with provided values
 scaleFrom: 100.0,
 scaleTo: percent
}, arguments[2] ||{});
 this.start(options);
},
 setup: function(){
 this.restoreAfterFinish = this.options.restoreAfterFinish || false;
 this.elementPositioning = this.element.getStyle('position');
 
 this.originalStyle ={};
 ['top','left','width','height','fontSize'].each( function(k){
 this.originalStyle[k] = this.element.style[k];
}.bind(this));
 
 this.originalTop = this.element.offsetTop;
 this.originalLeft = this.element.offsetLeft;
 
 var fontSize = this.element.getStyle('font-size') || '100%';
 ['em','px','%'].each( function(fontSizeType){
 if(fontSize.indexOf(fontSizeType)>0){
 this.fontSize = parseFloat(fontSize);
 this.fontSizeType = fontSizeType;
}
}.bind(this));
 
 this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;
 
 this.dims = null;
 if(this.options.scaleMode=='box')
 this.dims = [this.element.offsetHeight, this.element.offsetWidth];
 if(/^content/.test(this.options.scaleMode))
 this.dims = [this.element.scrollHeight, this.element.scrollWidth];
 if(!this.dims)
 this.dims = [this.options.scaleMode.originalHeight,
 this.options.scaleMode.originalWidth];
},
 update: function(position){
 var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
 if(this.options.scaleContent && this.fontSize)
 this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType});
 this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
},
 finish: function(position){
 if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
},
 setDimensions: function(height, width){
 var d ={};
 if(this.options.scaleX) d.width = width + 'px';
 if(this.options.scaleY) d.height = height + 'px';
 if(this.options.scaleFromCenter){
 var topd = (height - this.dims[0])/2;
 var leftd = (width - this.dims[1])/2;
 if(this.elementPositioning == 'absolute'){
 if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
 if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
}else{
 if(this.options.scaleY) d.top = -topd + 'px';
 if(this.options.scaleX) d.left = -leftd + 'px';
}
}
 this.element.setStyle(d);
}
});

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

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

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

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

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


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

Effect.Appear = function(element){
 element = $(element);
 var options = Object.extend({
 from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
 to: 1.0,

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

Effect.Puff = function(element){
 element = $(element);
 var oldStyle ={opacity: element.getInlineOpacity(), position: element.getStyle('position')};
 return new Effect.Parallel(
 [ new Effect.Scale(element, 200, 
{sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true}), 
 new Effect.Opacity(element,{sync: true, to: 0.0}) ], 
 Object.extend({duration: 1.0, 
 beforeSetupInternal: function(effect){
 effect.effects[0].element.setStyle({position: 'absolute'});},
 afterFinishInternal: function(effect){
 effect.effects[0].element.hide();
 effect.effects[0].element.setStyle(oldStyle);}
}, arguments[1] ||{})
 );
}

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

Effect.BlindDown = function(element){
 element = $(element);
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, 100, 
 Object.extend({scaleContent: false, 
 scaleX: false,
 scaleFrom: 0,
 scaleMode:{originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
 restoreAfterFinish: true,
 afterSetup: function(effect){
 effect.element.makeClipping();
 effect.element.setStyle({height: '0px'});
 effect.element.show(); 
}, 
 afterFinishInternal: function(effect){
 effect.element.undoClipping();
}
}, arguments[1] ||{})
 );
}

Effect.SwitchOff = function(element){
 element = $(element);
 var oldOpacity = element.getInlineOpacity();
 return new Effect.Appear(element,{
 duration: 0.4,
 from: 0,
 transition: Effect.Transitions.flicker,
 afterFinishInternal: function(effect){
 new Effect.Scale(effect.element, 1,{
 duration: 0.3, scaleFromCenter: true,
 scaleX: false, scaleContent: false, restoreAfterFinish: true,
 beforeSetup: function(effect){
 effect.element.makePositioned();
 effect.element.makeClipping();
},
 afterFinishInternal: function(effect){
 effect.element.hide();
 effect.element.undoClipping();
 effect.element.undoPositioned();
 effect.element.setStyle({opacity: oldOpacity});
}
})
}
});
}

Effect.DropOut = function(element){
 element = $(element);
 var oldStyle ={
 top: element.getStyle('top'),
 left: element.getStyle('left'),
 opacity: element.getInlineOpacity()};
 return new Effect.Parallel(
 [ new Effect.Move(element,{x: 0, y: 100, sync: true}), 
 new Effect.Opacity(element,{sync: true, to: 0.0}) ],
 Object.extend(
{duration: 0.5,
 beforeSetup: function(effect){
 effect.effects[0].element.makePositioned(); 
},
 afterFinishInternal: function(effect){
 effect.effects[0].element.hide();
 effect.effects[0].element.undoPositioned();
 effect.effects[0].element.setStyle(oldStyle);
}
}, arguments[1] ||{}));
}

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

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

 var oldInnerBottom = $(element.firstChild).getStyle('bottom');
 var elementDimensions = element.getDimensions();
 return new Effect.Scale(element, 100, Object.extend({
 scaleContent: false, 
 scaleX: false, 
 scaleFrom: 0,
 scaleMode:{originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
 restoreAfterFinish: true,
 afterSetup: function(effect){
 effect.element.makePositioned();
 effect.element.firstChild.makePositioned();
 if(window.opera) effect.element.setStyle({top: ''});
 effect.element.makeClipping();
 effect.element.setStyle({height: '0px'});
 effect.element.show();},
 afterUpdateInternal: function(effect){
 effect.element.firstChild.setStyle({bottom:
 (effect.dims[0] - effect.element.clientHeight) + 'px'}); 
},
 afterFinishInternal: function(effect){
 effect.element.undoClipping(); 

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

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

Effect.Grow = function(element){
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransition: Effect.Transitions.sinoidal,
 scaleTransition: Effect.Transitions.sinoidal,
 opacityTransition: Effect.Transitions.full
}, arguments[1] ||{});
 var oldStyle ={
 top: element.style.top,
 left: element.style.left,
 height: element.style.height,
 width: element.style.width,
 opacity: element.getInlineOpacity()};

 var dims = element.getDimensions(); 
 var initialMoveX, initialMoveY;
 var moveX, moveY;
 
 switch (options.direction){
 case 'top-left':
 initialMoveX = initialMoveY = moveX = moveY = 0; 
 break;
 case 'top-right':
 initialMoveX = dims.width;
 initialMoveY = moveY = 0;
 moveX = -dims.width;
 break;
 case 'bottom-left':
 initialMoveX = moveX = 0;
 initialMoveY = dims.height;
 moveY = -dims.height;
 break;
 case 'bottom-right':
 initialMoveX = dims.width;
 initialMoveY = dims.height;
 moveX = -dims.width;
 moveY = -dims.height;
 break;
 case 'center':
 initialMoveX = dims.width / 2;
 initialMoveY = dims.height / 2;
 moveX = -dims.width / 2;
 moveY = -dims.height / 2;
 break;
}
 
 return new Effect.Move(element,{
 x: initialMoveX,
 y: initialMoveY,
 duration: 0.01, 
 beforeSetup: function(effect){
 effect.element.hide();
 effect.element.makeClipping();
 effect.element.makePositioned();
},
 afterFinishInternal: function(effect){
 new Effect.Parallel(
 [ new Effect.Opacity(effect.element,{sync: true, to: 1.0, from: 0.0, transition: options.opacityTransition}),
 new Effect.Move(effect.element,{x: moveX, y: moveY, sync: true, transition: options.moveTransition}),
 new Effect.Scale(effect.element, 100,{
 scaleMode:{originalHeight: dims.height, originalWidth: dims.width}, 
 sync: true, scaleFrom: window.opera ? 1 : 0, transition: options.scaleTransition, restoreAfterFinish: true})
 ], Object.extend({
 beforeSetup: function(effect){
 effect.effects[0].element.setStyle({height: '0px'});
 effect.effects[0].element.show(); 
},
 afterFinishInternal: function(effect){
 effect.effects[0].element.undoClipping();
 effect.effects[0].element.undoPositioned();
 effect.effects[0].element.setStyle(oldStyle); 
}
}, options)
 )
}
});
}

Effect.Shrink = function(element){
 element = $(element);
 var options = Object.extend({
 direction: 'center',
 moveTransition: Effect.Transitions.sinoidal,
 scaleTransition: Effect.Transitions.sinoidal,
 opacityTransition: Effect.Transitions.none
}, arguments[1] ||{});
 var oldStyle ={
 top: element.style.top,
 left: element.style.left,
 height: element.style.height,
 width: element.style.width,
 opacity: element.getInlineOpacity()};

 var dims = element.getDimensions();
 var moveX, moveY;
 
 switch (options.direction){
 case 'top-left':
 moveX = moveY = 0;
 break;
 case 'top-right':
 moveX = dims.width;
 moveY = 0;
 break;
 case 'bottom-left':
 moveX = 0;
 moveY = dims.height;
 break;
 case 'bottom-right':
 moveX = dims.width;
 moveY = dims.height;
 break;
 case 'center': 
 moveX = dims.width / 2;
 moveY = dims.height / 2;
 break;
}
 
 return new Effect.Parallel(
 [ new Effect.Opacity(element,{sync: true, to: 0.0, from: 1.0, transition: options.opacityTransition}),
 new Effect.Scale(element, window.opera ? 1 : 0,{sync: true, transition: options.scaleTransition, restoreAfterFinish: true}),
 new Effect.Move(element,{x: moveX, y: moveY, sync: true, transition: options.moveTransition})
 ], Object.extend({
 beforeStartInternal: function(effect){
 effect.effects[0].element.makePositioned();
 effect.effects[0].element.makeClipping();},
 afterFinishInternal: function(effect){
 effect.effects[0].element.hide();
 effect.effects[0].element.undoClipping();
 effect.effects[0].element.undoPositioned();
 effect.effects[0].element.setStyle(oldStyle);}
}, options)
 );
}

Effect.Pulsate = function(element){
 element = $(element);
 var options = arguments[1] ||{};
 var oldOpacity = element.getInlineOpacity();
 var transition = options.transition || Effect.Transitions.sinoidal;
 var reverser = function(pos){return transition(1-Effect.Transitions.pulse(pos))};
 reverser.bind(transition);
 return new Effect.Opacity(element, 
 Object.extend(Object.extend({duration: 3.0, from: 0,
 afterFinishInternal: function(effect){effect.element.setStyle({opacity: oldOpacity});}
}, options),{transition: reverser}));
}

Effect.Fold = function(element){
 element = $(element);
 var oldStyle ={
 top: element.style.top,
 left: element.style.left,
 width: element.style.width,
 height: element.style.height};
 Element.makeClipping(element);
 return new Effect.Scale(element, 5, Object.extend({
 scaleContent: false,
 scaleX: false,
 afterFinishInternal: function(effect){
 new Effect.Scale(element, 1,{
 scaleContent: false, 
 scaleY: false,
 afterFinishInternal: function(effect){
 effect.element.hide();
 effect.element.undoClipping(); 
 effect.element.setStyle(oldStyle);
}});
}}, arguments[1] ||{}));
}

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

































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

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

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

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

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

 Element.hide(this.update);

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

 show: function(){
 if(Element.getStyle(this.update, 'display')=='none') this.options.onShow(this.element, this.update);
 if(!this.iefix && 
 (navigator.appVersion.indexOf('MSIE')>0) &&
 (navigator.userAgent.indexOf('Opera')<0) &&
 (Element.getStyle(this.update, 'position')=='absolute')){
 new Insertion.After(this.update, 
 '<iframe id="' + this.update.id + '_iefix" '+
 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' +
 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
 this.iefix = $(this.update.id+'_iefix');
}
 if(this.iefix) setTimeout(this.fixIEOverlapping.bind(this), 50);
},
 
 fixIEOverlapping: function(){
 Position.clone(this.update, this.iefix);
 this.iefix.style.zIndex = 1;
 this.update.style.zIndex = 2;
 Element.show(this.iefix);
},

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

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

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

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

 this.changed = true;
 this.hasFocus = true;

 if(this.observer) clearTimeout(this.observer);
 this.observer = 
 setTimeout(this.onObserverEvent.bind(this), this.options.frequency*1000);
},

 activate: function(){
 this.changed = false;
 this.hasFocus = true;
 this.getUpdatedChoices();
},

 onHover: function(event){
 var element = Event.findElement(event, 'LI');
 if(this.index != element.autocompleteIndex) 
{
 this.index = element.autocompleteIndex;
 this.render();
}
 Event.stop(event);
},
 
 onClick: function(event){
 var element = Event.findElement(event, 'LI');
 this.index = element.autocompleteIndex;
 this.selectEntry();
 this.hide();
},
 
 onBlur: function(event){

 setTimeout(this.hide.bind(this), 250);
 this.hasFocus = false;
 this.active = false; 
}, 
 
 render: function(){
 if(this.entryCount > 0){
 for (var i = 0; i < this.entryCount; i++)
 this.index==i ? 
 Element.addClassName(this.getEntry(i),"selected") : 
 Element.removeClassName(this.getEntry(i),"selected");
 
 if(this.hasFocus){
 this.show();
 this.active = true;
}
}else{
 this.active = false;
 this.hide();
}
},
 
 markPrevious: function(){
 if(this.index > 0) this.index--
 else this.index = this.entryCount-1;
},
 
 markNext: function(){
 if(this.index < this.entryCount-1) this.index++
 else this.index = 0;
},
 
 getEntry: function(index){
 return this.update.firstChild.childNodes[index];
},
 
 getCurrentEntry: function(){
 return this.getEntry(this.index);
},
 
 selectEntry: function(){
 this.active = false;
 this.updateElement(this.getCurrentEntry());
},

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

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

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

 this.stopIndicator();

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

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

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

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

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

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

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

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

 getUpdatedChoices: function(){
 entry = encodeURIComponent(this.options.paramName) + '=' + 
 encodeURIComponent(this.getToken());

 this.options.parameters = this.options.callback ?
 this.options.callback(this.element, entry) : entry;

 if(this.options.defaultParams) 
 this.options.parameters += '&' + this.options.defaultParams;

 new Ajax.Request(this.url, this.options);
},

 onComplete: function(request){
 this.updateChoices(request.responseText);
}

});



































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

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

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

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

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

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

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

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






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

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

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

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

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

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

 this.createEditField();

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

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

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

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

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



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

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

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

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

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




Form.Element.DelayedObserver = Class.create();
Form.Element.DelayedObserver.prototype ={
 initialize: function(element, delay, callback){
 this.delay = delay || 0.5;
 this.element = $(element);
 this.callback = callback;
 this.timer = null;
 this.lastValue = $F(this.element); 
 Event.observe(this.element,'keyup',this.delayedListener.bindAsEventListener(this));
},
 delayedListener: function(event){
 if(this.lastValue == $F(this.element)) return;
 if(this.timer) clearTimeout(this.timer);
 this.timer = setTimeout(this.onTimerEvent.bind(this), this.delay * 1000);
 this.lastValue = $F(this.element);
},
 onTimerEvent: function(){
 this.timer = null;
 this.callback(this.element, $F(this.element));
}
};// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)



var Builder ={
 NODEMAP:{
 AREA: 'map',
 CAPTION: 'table',
 COL: 'table',
 COLGROUP: 'table',
 LEGEND: 'fieldset',
 OPTGROUP: 'select',
 OPTION: 'select',
 PARAM: 'object',
 TBODY: 'table',
 TD: 'table',
 TFOOT: 'table',
 TH: 'table',
 THEAD: 'table',
 TR: 'table'
},


 node: function(elementName){
 elementName = elementName.toUpperCase();

 var parentTag = this.NODEMAP[elementName] || 'div';
 var parentElement = document.createElement(parentTag);
 try{// prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
}catch(e){}
 var element = parentElement.firstChild || null;

 if(element && (element.tagName != elementName))
 element = element.getElementsByTagName(elementName)[0];

 if(!element) element = document.createElement(elementName);

 if(!element) return;

 if(arguments[1])
 if(this._isStringOrNumber(arguments[1]) ||
 (arguments[1] instanceof Array)){
 this._children(element, arguments[1]);
}else{
 var attrs = this._attributes(arguments[1]);
 if(attrs.length){
 try{// prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
 parentElement.innerHTML = "<" +elementName + " " +
 attrs + "></" + elementName + ">";
}catch(e){}
 element = parentElement.firstChild || null;

 if(!element){
 element = document.createElement(elementName);
 for(attr in arguments[1]) 
 element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
}
 if(element.tagName != elementName)
 element = parentElement.getElementsByTagName(elementName)[0];
}
}

 if(arguments[2])
 this._children(element, arguments[2]);

 return element;
},
 _text: function(text){
 return document.createTextNode(text);
},
 _attributes: function(attributes){
 var attrs = [];
 for(attribute in attributes)
 attrs.push((attribute=='className' ? 'class' : attribute) +
 '="' + attributes[attribute].toString().escapeHTML() + '"');
 return attrs.join(" ");
},
 _children: function(element, children){
 if(typeof children=='object'){// array can hold nodes and text
 children.flatten().each( function(e){
 if(typeof e=='object')
 element.appendChild(e)
 else
 if(Builder._isStringOrNumber(e))
 element.appendChild(Builder._text(e));
});
}else
 if(Builder._isStringOrNumber(children)) 
 element.appendChild(Builder._text(children));
},
 _isStringOrNumber: function(param){
 return(typeof param=='string' || typeof param=='number');
}
}// Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)




var Droppables ={
 drops: [],

 remove: function(element){
 this.drops = this.drops.reject(function(d){return d.element==$(element)});
},

 add: function(element){
 element = $(element);
 var options = Object.extend({
 greedy: true,
 hoverclass: null 
}, arguments[1] ||{});

 if(options.containment){
 options._containers = [];
 var containment = options.containment;
 if((typeof containment == 'object') && 
 (containment.constructor == Array)){
 containment.each( function(c){options._containers.push($(c))});
}else{
 options._containers.push($(containment));
}
}
 
 if(options.accept) options.accept = [options.accept].flatten();

 Element.makePositioned(element); // fix IE
 options.element = element;

 this.drops.push(options);
},

 isContained: function(element, drop){
 var parentNode = element.parentNode;
 return drop._containers.detect(function(c){return parentNode == c});
},

 isAffected: function(point, element, drop){
 return (
 (drop.element!=element) &&
 ((!drop._containers) ||
 this.isContained(element, drop)) &&
 ((!drop.accept) ||
 (Element.classNames(element).detect( 
 function(v){return drop.accept.include(v)}) )) &&
 Position.within(drop.element, point[0], point[1]) );
},

 deactivate: function(drop){
 if(drop.hoverclass)
 Element.removeClassName(drop.element, drop.hoverclass);
 this.last_active = null;
},

 activate: function(drop){
 if(drop.hoverclass)
 Element.addClassName(drop.element, drop.hoverclass);
 this.last_active = drop;
},

 show: function(point, element){
 if(!this.drops.length) return;
 
 if(this.last_active) this.deactivate(this.last_active);
 this.drops.each( function(drop){
 if(Droppables.isAffected(point, element, drop)){
 if(drop.onHover)
 drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
 if(drop.greedy){
 Droppables.activate(drop);
 throw $break;
}
}
});
},

 fire: function(event, element){
 if(!this.last_active) return;
 Position.prepare();

 if (this.isAffected([Event.pointerX(event), Event.pointerY(event)], element, this.last_active))
 if (this.last_active.onDrop) 
 this.last_active.onDrop(element, this.last_active.element, event);
},

 reset: function(){
 if(this.last_active)
 this.deactivate(this.last_active);
}
}

var Draggables ={
 drags: [],
 observers: [],
 
 register: function(draggable){
 if(this.drags.length == 0){
 this.eventMouseUp = this.endDrag.bindAsEventListener(this);
 this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
 this.eventKeypress = this.keyPress.bindAsEventListener(this);
 
 Event.observe(document, "mouseup", this.eventMouseUp);
 Event.observe(document, "mousemove", this.eventMouseMove);
 Event.observe(document, "keypress", this.eventKeypress);
}
 this.drags.push(draggable);
},
 
 unregister: function(draggable){
 this.drags = this.drags.reject(function(d){return d==draggable});
 if(this.drags.length == 0){
 Event.stopObserving(document, "mouseup", this.eventMouseUp);
 Event.stopObserving(document, "mousemove", this.eventMouseMove);
 Event.stopObserving(document, "keypress", this.eventKeypress);
}
},
 
 activate: function(draggable){
 window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
 this.activeDraggable = draggable;
},
 
 deactivate: function(){
 this.activeDraggable = null;
},
 
 updateDrag: function(event){
 if(!this.activeDraggable) return;
 var pointer = [Event.pointerX(event), Event.pointerY(event)];


 if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
 this._lastPointer = pointer;
 this.activeDraggable.updateDrag(event, pointer);
},
 
 endDrag: function(event){
 if(!this.activeDraggable) return;
 this._lastPointer = null;
 this.activeDraggable.endDrag(event);
 this.activeDraggable = null;
},
 
 keyPress: function(event){
 if(this.activeDraggable)
 this.activeDraggable.keyPress(event);
},
 
 addObserver: function(observer){
 this.observers.push(observer);
 this._cacheObserverCallbacks();
},
 
 removeObserver: function(element){// element instead of observer fixes mem leaks
 this.observers = this.observers.reject( function(o){return o.element==element});
 this._cacheObserverCallbacks();
},
 
 notify: function(eventName, draggable, event){// 'onStart', 'onEnd', 'onDrag'
 if(this[eventName+'Count'] > 0)
 this.observers.each( function(o){
 if(o[eventName]) o[eventName](eventName, draggable, event);
});
},
 
 _cacheObserverCallbacks: function(){
 ['onStart','onEnd','onDrag'].each( function(eventName){
 Draggables[eventName+'Count'] = Draggables.observers.select(
 function(o){return o[eventName];}
 ).length;
});
}
}


var Draggable = Class.create();
Draggable.prototype ={
 initialize: function(element){
 var options = Object.extend({
 handle: false,
 starteffect: function(element){
 new Effect.Opacity(element,{duration:0.2, from:1.0, to:0.7}); 
},
 reverteffect: function(element, top_offset, left_offset){
 var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
 element._revert = new Effect.Move(element,{x: -left_offset, y: -top_offset, duration: dur});
},
 endeffect: function(element){
 new Effect.Opacity(element,{duration:0.2, from:0.7, to:1.0}); 
},
 zindex: 1000,
 revert: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 snap: false // false, or xy or [x,y] or function(x,y){return [x,y]}
}, arguments[1] ||{});

 this.element = $(element);
 
 if(options.handle && (typeof options.handle == 'string'))
 this.handle = Element.childrenWithClassName(this.element, options.handle, true)[0]; 
 if(!this.handle) this.handle = $(options.handle);
 if(!this.handle) this.handle = this.element;
 
 if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML)
 options.scroll = $(options.scroll);

 Element.makePositioned(this.element); // fix IE 

 this.delta = this.currentDelta();
 this.options = options;
 this.dragging = false; 

 this.eventMouseDown = this.initDrag.bindAsEventListener(this);
 Event.observe(this.handle, "mousedown", this.eventMouseDown);
 
 Draggables.register(this);
},
 
 destroy: function(){
 Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
 Draggables.unregister(this);
},
 
 currentDelta: function(){
 return([
 parseInt(Element.getStyle(this.element,'left') || '0'),
 parseInt(Element.getStyle(this.element,'top') || '0')]);
},
 
 initDrag: function(event){
 if(Event.isLeftClick(event)){

 var src = Event.element(event);
 if(src.tagName && (
 src.tagName=='INPUT' ||
 src.tagName=='SELECT' ||
 src.tagName=='OPTION' ||
 src.tagName=='BUTTON' ||
 src.tagName=='TEXTAREA')) return;
 
 if(this.element._revert){
 this.element._revert.cancel();
 this.element._revert = null;
}
 
 var pointer = [Event.pointerX(event), Event.pointerY(event)];
 var pos = Position.cumulativeOffset(this.element);
 this.offset = [0,1].map( function(i){return (pointer[i] - pos[i])});
 
 Draggables.activate(this);
 Event.stop(event);
}
},
 
 startDrag: function(event){
 this.dragging = true;
 
 if(this.options.zindex){
 this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
 this.element.style.zIndex = this.options.zindex;
}
 
 if(this.options.ghosting){
 this._clone = this.element.cloneNode(true);
 Position.absolutize(this.element);
 this.element.parentNode.insertBefore(this._clone, this.element);
}
 
 if(this.options.scroll){
 if (this.options.scroll == window){
 var where = this._getWindowScroll(this.options.scroll);
 this.originalScrollLeft = where.left;
 this.originalScrollTop = where.top;
}else{
 this.originalScrollLeft = this.options.scroll.scrollLeft;
 this.originalScrollTop = this.options.scroll.scrollTop;
}
}
 
 Draggables.notify('onStart', this, event);
 if(this.options.starteffect) this.options.starteffect(this.element);
},
 
 updateDrag: function(event, pointer){
 if(!this.dragging) this.startDrag(event);
 Position.prepare();
 Droppables.show(pointer, this.element);
 Draggables.notify('onDrag', this, event);
 this.draw(pointer);
 if(this.options.change) this.options.change(this);
 
 if(this.options.scroll){
 this.stopScrolling();
 
 var p;
 if (this.options.scroll == window){
 with(this._getWindowScroll(this.options.scroll)){p = [ left, top, left+width, top+height ];}
}else{
 p = Position.page(this.options.scroll);
 p[0] += this.options.scroll.scrollLeft;
 p[1] += this.options.scroll.scrollTop;
 p.push(p[0]+this.options.scroll.offsetWidth);
 p.push(p[1]+this.options.scroll.offsetHeight);
}
 var speed = [0,0];
 if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
 if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
 if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
 if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
 this.startScrolling(speed);
}

 if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
 
 Event.stop(event);
},
 
 finishDrag: function(event, success){
 this.dragging = false;

 if(this.options.ghosting){
 Position.relativize(this.element);
 Element.remove(this._clone);
 this._clone = null;
}

 if(success) Droppables.fire(event, this.element);
 Draggables.notify('onEnd', this, event);

 var revert = this.options.revert;
 if(revert && typeof revert == 'function') revert = revert(this.element);
 
 var d = this.currentDelta();
 if(revert && this.options.reverteffect){
 this.options.reverteffect(this.element, 
 d[1]-this.delta[1], d[0]-this.delta[0]);
}else{
 this.delta = d;
}

 if(this.options.zindex)
 this.element.style.zIndex = this.originalZ;

 if(this.options.endeffect) 
 this.options.endeffect(this.element);

 Draggables.deactivate(this);
 Droppables.reset();
},
 
 keyPress: function(event){
 if(event.keyCode!=Event.KEY_ESC) return;
 this.finishDrag(event, false);
 Event.stop(event);
},
 
 endDrag: function(event){
 if(!this.dragging) return;
 this.stopScrolling();
 this.finishDrag(event, true);
 Event.stop(event);
},
 
 draw: function(point){
 var pos = Position.cumulativeOffset(this.element);
 var d = this.currentDelta();
 pos[0] -= d[0]; pos[1] -= d[1];
 
 if(this.options.scroll && (this.options.scroll != window)){
 pos[0] -= this.options.scroll.scrollLeft-this.originalScrollLeft;
 pos[1] -= this.options.scroll.scrollTop-this.originalScrollTop;
}
 
 var p = [0,1].map(function(i){
 return (point[i]-pos[i]-this.offset[i]) 
}.bind(this));
 
 if(this.options.snap){
 if(typeof this.options.snap == 'function'){
 p = this.options.snap(p[0],p[1]);
}else{
 if(this.options.snap instanceof Array){
 p = p.map( function(v, i){
 return Math.round(v/this.options.snap[i])*this.options.snap[i]}.bind(this))
}else{
 p = p.map( function(v){
 return Math.round(v/this.options.snap)*this.options.snap}.bind(this))
}
}}
 
 var style = this.element.style;
 if((!this.options.constraint) || (this.options.constraint=='horizontal'))
 style.left = p[0] + "px";
 if((!this.options.constraint) || (this.options.constraint=='vertical'))
 style.top = p[1] + "px";
 if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
},
 
 stopScrolling: function(){
 if(this.scrollInterval){
 clearInterval(this.scrollInterval);
 this.scrollInterval = null;
}
},
 
 startScrolling: function(speed){
 this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
 this.lastScrolled = new Date();
 this.scrollInterval = setInterval(this.scroll.bind(this), 10);
},
 
 scroll: function(){
 var current = new Date();
 var delta = current - this.lastScrolled;
 this.lastScrolled = current;
 if(this.options.scroll == window){
 with (this._getWindowScroll(this.options.scroll)){
 if (this.scrollSpeed[0] || this.scrollSpeed[1]){
 var d = delta / 1000;
 this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
}
}
}else{
 this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
 this.options.scroll.scrollTop += this.scrollSpeed[1] * delta / 1000;
}
 
 Position.prepare();
 Droppables.show(Draggables._lastPointer, this.element);
 Draggables.notify('onDrag', this);
 this.draw(Draggables._lastPointer); 
 
 if(this.options.change) this.options.change(this);
},
 
 _getWindowScroll: function(w){
 var T, L, W, H;
 with (w.document){
 if (w.document.documentElement && documentElement.scrollTop){
 T = documentElement.scrollTop;
 L = documentElement.scrollLeft;
}else if (w.document.body){
 T = body.scrollTop;
 L = body.scrollLeft;
}
 if (w.innerWidth){
 W = w.innerWidth;
 H = w.innerHeight;
}else if (w.document.documentElement && documentElement.clientWidth){
 W = documentElement.clientWidth;
 H = documentElement.clientHeight;
}else{
 W = body.offsetWidth;
 H = body.offsetHeight
}
}
 return{top: T, left: L, width: W, height: H};
}
}


var SortableObserver = Class.create();
SortableObserver.prototype ={
 initialize: function(element, observer){
 this.element = $(element);
 this.observer = observer;
 this.lastValue = Sortable.serialize(this.element);
},
 
 onStart: function(){
 this.lastValue = Sortable.serialize(this.element);
},
 
 onEnd: function(){
 Sortable.unmark();
 if(this.lastValue != Sortable.serialize(this.element))
 this.observer(this.element)
}
}

var Sortable ={
 sortables: new Array(),
 
 options: function(element){
 element = $(element);
 return this.sortables.detect(function(s){return s.element == element});
},
 
 destroy: function(element){
 element = $(element);
 this.sortables.findAll(function(s){return s.element == element}).each(function(s){
 Draggables.removeObserver(s.element);
 s.droppables.each(function(d){Droppables.remove(d)});
 s.draggables.invoke('destroy');
});
 this.sortables = this.sortables.reject(function(s){return s.element == element});
},
 
 create: function(element){
 element = $(element);
 var options = Object.extend({
 element: element,
 tag: 'li', // assumes li children, override with tag: 'tagname'
 dropOnEmpty: false,
 tree: false, // fixme: unimplemented
 overlap: 'vertical', // one of 'vertical', 'horizontal'
 constraint: 'vertical', // one of 'vertical', 'horizontal', false
 containment: element, // also takes array of elements (or id's); or false
 handle: false, // or a CSS class
 only: false,
 hoverclass: null,
 ghosting: false,
 scroll: false,
 scrollSensitivity: 20,
 scrollSpeed: 15,
 format: /^[^_]*_(.*)$/,
 onChange: Prototype.emptyFunction,
 onUpdate: Prototype.emptyFunction
}, arguments[1] ||{});

 this.destroy(element);

 var options_for_draggable ={
 revert: true,
 scroll: options.scroll,
 scrollSpeed: options.scrollSpeed,
 scrollSensitivity: options.scrollSensitivity,
 ghosting: options.ghosting,
 constraint: options.constraint,
 handle: options.handle};

 if(options.starteffect)
 options_for_draggable.starteffect = options.starteffect;

 if(options.reverteffect)
 options_for_draggable.reverteffect = options.reverteffect;
 else
 if(options.ghosting) options_for_draggable.reverteffect = function(element){
 element.style.top = 0;
 element.style.left = 0;
};

 if(options.endeffect)
 options_for_draggable.endeffect = options.endeffect;

 if(options.zindex)
 options_for_draggable.zindex = options.zindex;

 var options_for_droppable ={
 overlap: options.overlap,
 containment: options.containment,
 hoverclass: options.hoverclass,
 onHover: Sortable.onHover,
 greedy: !options.dropOnEmpty
}

 Element.cleanWhitespace(element); 

 options.draggables = [];
 options.droppables = [];


 if(options.dropOnEmpty){
 Droppables.add(element,
{containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false});
 options.droppables.push(element);
}

 (this.findElements(element, options) || []).each( function(e){

 var handle = options.handle ? 
 Element.childrenWithClassName(e, options.handle)[0] : e; 
 options.draggables.push(
 new Draggable(e, Object.extend(options_for_draggable,{handle: handle})));
 Droppables.add(e, options_for_droppable);
 options.droppables.push(e); 
});

 this.sortables.push(options);

 Draggables.addObserver(new SortableObserver(element, options.onUpdate));

},

 findElements: function(element, options){
 if(!element.hasChildNodes()) return null;
 var elements = [];
 var only = options.only ? [options.only].flatten() : null;
 $A(element.childNodes).each( function(e){
 if(e.tagName && e.tagName.toUpperCase()==options.tag.toUpperCase() &&
 (!only || (Element.classNames(e).detect(function(v){return only.include(v)}))))
 elements.push(e);
 if(options.tree){
 var grandchildren = this.findElements(e, options);
 if(grandchildren) elements.push(grandchildren);
}
});

 return (elements.length>0 ? elements.flatten() : null);
},

 onHover: function(element, dropon, overlap){
 if(overlap>0.5){
 Sortable.mark(dropon, 'before');
 if(dropon.previousSibling != element){
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, dropon);
 if(dropon.parentNode!=oldParentNode) 
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
}
}else{
 Sortable.mark(dropon, 'after');
 var nextElement = dropon.nextSibling || null;
 if(nextElement != element){
 var oldParentNode = element.parentNode;
 element.style.visibility = "hidden"; // fix gecko rendering
 dropon.parentNode.insertBefore(element, nextElement);
 if(dropon.parentNode!=oldParentNode) 
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon.parentNode).onChange(element);
}
}
},

 onEmptyHover: function(element, dropon){
 if(element.parentNode!=dropon){
 var oldParentNode = element.parentNode;
 dropon.appendChild(element);
 Sortable.options(oldParentNode).onChange(element);
 Sortable.options(dropon).onChange(element);
}
},

 unmark: function(){
 if(Sortable._marker) Element.hide(Sortable._marker);
},

 mark: function(dropon, position){

 var sortable = Sortable.options(dropon.parentNode);
 if(sortable && !sortable.ghosting) return; 

 if(!Sortable._marker){
 Sortable._marker = $('dropmarker') || document.createElement('DIV');
 Element.hide(Sortable._marker);
 Element.addClassName(Sortable._marker, 'dropmarker');
 Sortable._marker.style.position = 'absolute';
 document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
}
 var offsets = Position.cumulativeOffset(dropon);
 Sortable._marker.style.left = offsets[0] + 'px';
 Sortable._marker.style.top = offsets[1] + 'px';
 
 if(position=='after')
 if(sortable.overlap == 'horizontal') 
 Sortable._marker.style.left = (offsets[0]+dropon.clientWidth) + 'px';
 else
 Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
 
 Element.show(Sortable._marker);
},

 sequence: function(element){
 element = $(element);
 var options = Object.extend(this.options(element), arguments[1] ||{});
 
 return $(this.findElements(element, options) || []).map( function(item){
 return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
});
},

 setSequence: function(element, new_sequence){
 element = $(element);
 var options = Object.extend(this.options(element), arguments[2] ||{});
 
 var nodeMap ={};
 this.findElements(element, options).each( function(n){
 if (n.id.match(options.format))
 nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
 n.parentNode.removeChild(n);
});
 
 new_sequence.each(function(ident){
 var n = nodeMap[ident];
 if (n){
 n[1].appendChild(n[0]);
 delete nodeMap[ident];
}
});
},

 serialize: function(element){
 element = $(element);
 var name = encodeURIComponent(
 (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
 return Sortable.sequence(element, arguments[1]).map( function(item){
 return name + "[]=" + encodeURIComponent(item);
}).join('&');
}
}









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

 var count = 0;

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


 count++;
 anchor.onclick = function (){

 document.getElementsByClassName("_banner").each(function(element){
 if (element.down('div',0)) element.down('div',0).style.display="none";
});
 myLightbox.start(this); return false;
}
}
}

 if (count == 0) return;


































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

 document.getElementsByClassName("_banner").each(function(element){
 if (element.down('div',0)) element.down('div',0).style.display="block";
});
 myLightbox.end(); return false;
}
 objBottomNav.appendChild(objBottomNavCloseLink);
 
 var objBottomNavCloseImage = document.createElement("img");
 objBottomNavCloseImage.setAttribute('src', fileBottomNavCloseImage);
 objBottomNavCloseLink.appendChild(objBottomNavCloseImage);
},




 start: function(imageLink){

 hideSelectBoxes();

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

 imageArray = [];
 imageNum = 0; 

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

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

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


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

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

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




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

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

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



 resizeImageContainer: function( imgWidth, imgHeight){

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

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

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

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


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

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

 this.showImage();
},




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




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

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

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




 updateNav: function(){

 Element.show('hoverNav'); 

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

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



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



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



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

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


},




 preloadNeighborImages: function(){

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



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






function getPageScroll(){

 var yScroll;

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

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







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

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

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


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





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




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


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


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






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







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

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


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


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

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

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



if (typeof unFocus == "undefined") var unFocus ={};
if (!unFocus.Utilities) unFocus.Utilities ={};


unFocus.Utilities.EventManager = function(arg){
 this._listeners ={};
 for (var i = arguments.length; -1 < --i;){
 this._listeners[arguments[i]] = [];
}
};


unFocus.Utilities.EventManager.prototype.addEventListener = function($type, $listener){

 for (var i = this._listeners[$type].length; -1 < --i;)
 if (this._listeners[$type][i] == $listener) return;

 this._listeners[$type].push($listener);
};


unFocus.Utilities.EventManager.prototype.removeEventListener = function($type, $listener){

 for (var i = this._listeners[$type].length; -1 < --i;){
 if (this._listeners[$type][i] == $listener){
 this._listeners.splice(i,1);
 break;
}
}
};


unFocus.Utilities.EventManager.prototype.notifyListeners = function($type, $data){
 for (var i = this._listeners[$type].length; -1 < --i;)
 this._listeners[$type][i]($data);
};
if (typeof unFocus == "undefined") var unFocus ={};


unFocus.History = (function(){

function Keeper(){

 var _this = this,

 _pollInterval = 200, _intervalID,

 _currentHash = _getHash();


 function _getHash(){
 return location.hash.substring(1);
}
 

 function _setHash($newHash){
 window.location.hash = $newHash;
}
 

 function _watchHash(){
 var $newHash = _getHash();
 if (_currentHash != $newHash){
 _currentHash = $newHash;
 _this.notifyListeners("historyChange", $newHash);
}
}

 if (setInterval) _intervalID = setInterval(_watchHash, _pollInterval);
 

 _this.getCurrent = function(){
 return _currentHash;
};
 

 function _createAnchor($newHash){
 if (!_checkAnchorExists($newHash)){
 var $anchor = document.createElement("a");
 $anchor.setAttribute("name", $newHash);
 if (/MSIE/.test(navigator.userAgent) && !window.opera)
 $anchor = document.createElement('<a name="'+$newHash+'">'+$newHash+"</a>");
 $anchor.style.position = "absolute";
 $anchor.style.top = getScrollY()+"px";
 $anchor.style.left = getScrollX()+"px";


 document.body.insertBefore($anchor,document.body.firstChild);
}
}
 function _checkAnchorExists($name){
 var $anchors = document.anchors;
 for (var i = 0; i < $anchors.length; i++)
 if ($anchors[i].name == $name)
 return true;
 return false;
}


 if (typeof self.pageYOffset == "number"){
 function getScrollY(){
 return self.pageYOffset;
}
}else if (document.documentElement && document.documentElement.scrollTop){
 function getScrollY(){
 return document.documentElement.scrollTop;
}
}else if (document.body){
 function getScrollY(){
 return document.body.scrollTop;
}
}

 eval(String(getScrollY).toString().replace(/Top/g,"Left").replace(/Y/g,"X"));

 _this.addHistory = function(){};

 if (navigator.appVersion.indexOf("Safari") != -1){
 var _windowHistoryLength = history.length,
 _historyArray = [],
 _recentlyAdded = false;

 _historyArray[_windowHistoryLength] = location.hash;
 
 _this.addHistory = function($newHash){// adds history and bookmark hash
 if (_currentHash != $newHash){
 _createAnchor($newHash);
 _currentHash = $newHash;
 _setHash($newHash); // :NOTE: this doesn't update history.length right away
 _windowHistoryLength = history.length+1;
 _historyArray[_windowHistoryLength] = $newHash;
 _recentlyAdded = true;
 _this.notifyListeners("historyChange",$newHash);
}
};
 
 var _watchHistoryLength = function(){
 if (!_recentlyAdded){// :NOTE: for some reason the first time this is called, it can't tell that anything has changed.
 var _historyLength = history.length;
 if (_historyLength != _windowHistoryLength){// && _historyArray[_historyLength]
 _windowHistoryLength = _historyLength;
 
 var $newHash = _historyArray[_windowHistoryLength];
 if (_currentHash != $newHash){
 _currentHash = $newHash;
 _this.notifyListeners("historyChange", $newHash);
}
}
}else _recentlyAdded = false;
};

 clearInterval(_intervalID);

 _intervalID = setInterval(_watchHistoryLength, _pollInterval);

}else if (typeof ActiveXObject != "undefined" && window.print && 
 !window.opera && navigator.userAgent.match(/MSIE (\d\.\d)/)[1] >= 5.5){
 
 var _historyFrameObj, _historyFrameRef;
 
 
 function _createHistoryFrame(){
 var $historyFrameName = "unFocusHistoryFrame";
 _historyFrameObj = document.createElement("iframe");
 _historyFrameObj.setAttribute("name", $historyFrameName);
 _historyFrameObj.setAttribute("id", $historyFrameName);
 _historyFrameObj.style.position = "absolute";
 _historyFrameObj.style.top = "-900px";
 document.body.insertBefore(_historyFrameObj,document.body.firstChild);



 _historyFrameRef = frames[$historyFrameName];

 _createHistoryHTML(_currentHash, true);
}
 
 
 function _createHistoryHTML($newHash){
 _historyFrameRef.document.open("text/html");
 _historyFrameRef.document.write("<html><head></head><body onl",
 'oad="parent.unFocus.History._updateFromHistory(\''+$newHash+'\');">',
 $newHash+"</body></html>");
 _historyFrameRef.document.close();
}
 
 
 _this._updateFromHistory = function(){

 _this._updateFromHistory = function($hash){
 _currentHash = $hash;
 _this.notifyListeners("historyChange", $hash);
};
};

 _this.addHistory = function($newHash){

 _createHistoryFrame();

 _this.addHistory = function($newHash){// adds history and bookmark hash
 if (_currentHash != $newHash){


 _currentHash = $newHash;

 _createHistoryHTML($newHash);
}
};

 _this.addHistory($newHash);
};

 _this.addEventListener("historyChange", function($hash){_setHash($hash)});

 
}else{
 _this.addHistory = function($newHash){// adds history and bookmark hash

 _createAnchor(_currentHash);

 _this.addHistory = function($newHash){
 if (_currentHash != $newHash){
 _createAnchor($newHash);
 _currentHash = $newHash;
 _setHash($newHash);
 _this.notifyListeners("historyChange",$newHash);
}
};

 _this.addHistory($newHash);
};
}
}
Keeper.prototype = new unFocus.Utilities.EventManager("historyChange");

return new Keeper();

})()

var flashVersion = getFlashVersion(); //Lekérem a Flash lejátszó verziószámát



if( parseInt(flashVersion) > 8 ){

 




var SWFUpload;

if (SWFUpload == undefined){
 SWFUpload = function (settings){
 this.initSWFUpload(settings);
};
}

SWFUpload.prototype.initSWFUpload = function (settings){
 try{
 this.customSettings ={}; // A container where developers can place their own settings associated with this instance.
 this.settings = settings;
 this.eventQueue = [];
 this.movieName = "SWFUpload_" + SWFUpload.movieCount++;
 this.movieElement = null;

 SWFUpload.instances[this.movieName] = this;

 this.initSettings();
 this.loadFlash();
 this.displayDebugInfo();
}catch (ex){
 delete SWFUpload.instances[this.movieName];
 throw ex;
}
};




SWFUpload.instances ={};
SWFUpload.movieCount = 0;
SWFUpload.version = "2.2.0 Beta 3";
SWFUpload.QUEUE_ERROR ={
 QUEUE_LIMIT_EXCEEDED : -100,
 FILE_EXCEEDS_SIZE_LIMIT : -110,
 ZERO_BYTE_FILE : -120,
 INVALID_FILETYPE : -130
};
SWFUpload.UPLOAD_ERROR ={
 HTTP_ERROR : -200,
 MISSING_UPLOAD_URL : -210,
 IO_ERROR : -220,
 SECURITY_ERROR : -230,
 UPLOAD_LIMIT_EXCEEDED : -240,
 UPLOAD_FAILED : -250,
 SPECIFIED_FILE_ID_NOT_FOUND : -260,
 FILE_VALIDATION_FAILED : -270,
 FILE_CANCELLED : -280,
 UPLOAD_STOPPED : -290
};
SWFUpload.FILE_STATUS ={
 QUEUED : -1,
 IN_PROGRESS : -2,
 ERROR : -3,
 COMPLETE : -4,
 CANCELLED : -5
};
SWFUpload.BUTTON_ACTION ={
 SELECT_FILE : -100,
 SELECT_FILES : -110,
 START_UPLOAD : -120
};
SWFUpload.CURSOR ={
 ARROW : -1,
 HAND : -2
};
SWFUpload.WINDOW_MODE ={
 WINDOW : "window",
 TRANSPARENT : "transparent",
 OPAQUE : "opaque"
};


SWFUpload.prototype.initSettings = function (){
 this.ensureDefault = function (settingName, defaultValue){
 this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
};

 this.ensureDefault("upload_url", "");
 this.ensureDefault("file_post_name", "Filedata");
 this.ensureDefault("post_params",{});
 this.ensureDefault("use_query_string", false);
 this.ensureDefault("requeue_on_error", false);
 this.ensureDefault("http_success", []);

 this.ensureDefault("file_types", "*.*");
 this.ensureDefault("file_types_description", "All Files");
 this.ensureDefault("file_size_limit", 0); // Default zero means "unlimited"
 this.ensureDefault("file_upload_limit", 0);
 this.ensureDefault("file_queue_limit", 0);

 this.ensureDefault("flash_url", "/flash/swfupload2.swf");
 this.ensureDefault("prevent_swf_caching", true);

 this.ensureDefault("button_image_url", "");
 this.ensureDefault("button_width", 1);
 this.ensureDefault("button_height", 1);
 this.ensureDefault("button_text", "");
 this.ensureDefault("button_text_style", "color: #000000; font-size: 16pt;");
 this.ensureDefault("button_text_top_padding", 0);
 this.ensureDefault("button_text_left_padding", 0);
 this.ensureDefault("button_action", SWFUpload.BUTTON_ACTION.SELECT_FILES);
 this.ensureDefault("button_disabled", false);

 this.ensureDefault("button_placeholder_id", "swfbutton"); 
 this.ensureDefault("button_cursor", SWFUpload.CURSOR.ARROW);
 this.ensureDefault("button_window_mode", SWFUpload.WINDOW_MODE.WINDOW);

 this.ensureDefault("debug", false);
 this.settings.debug_enabled = this.settings.debug; // Here to maintain v2 API

 this.settings.return_upload_start_handler = this.returnUploadStart;
 this.ensureDefault("swfupload_loaded_handler", null);
 this.ensureDefault("file_dialog_start_handler", null);
 this.ensureDefault("file_queued_handler", null);
 this.ensureDefault("file_queue_error_handler", null);
 this.ensureDefault("file_dialog_complete_handler", null);

 this.ensureDefault("upload_start_handler", null);
 this.ensureDefault("upload_progress_handler", null);
 this.ensureDefault("upload_error_handler", null);
 this.ensureDefault("upload_success_handler", null);
 this.ensureDefault("upload_complete_handler", null);
 
 this.ensureDefault("debug_handler", this.debugMessage);

 this.ensureDefault("custom_settings",{});

 this.customSettings = this.settings.custom_settings;

 if (this.settings.prevent_swf_caching){
 this.settings.flash_url = this.settings.flash_url + "?swfuploadrnd=" + Math.floor(Math.random() * 999999999);
}
 
 delete this.ensureDefault;
};

SWFUpload.prototype.loadFlash = function (){
 if (this.settings.button_placeholder_id !== ""){
 this.replaceWithFlash();
}else{
 this.appendFlash();
}
};


SWFUpload.prototype.appendFlash = function (){
 var targetElement, container;

 if (document.getElementById(this.movieName) !== null){
 throw "ID " + this.movieName + " is already in use. The Flash Object could not be added";
}

 targetElement = document.getElementsByTagName("body")[0];

 if (targetElement == undefined){
 throw "Could not find the 'body' element.";
}

 container = document.createElement("div");
 container.style.width = "1px";
 container.style.height = "1px";
 container.style.overflow = "hidden";

 targetElement.appendChild(container);
 container.innerHTML = this.getFlashHTML(); // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)

 if (window[this.movieName] == undefined){
 window[this.movieName] = this.getMovieElement();
}
 
 
};

SWFUpload.prototype.replaceWithFlash = function (){
 var targetElement, tempParent;

 if (document.getElementById(this.movieName) !== null){
 throw "ID " + this.movieName + " is already in use. The Flash Object could not be added";
}

 targetElement = document.getElementById(this.settings.button_placeholder_id);

 if (targetElement == undefined){
 throw "Could not find the placeholder element.";
}

 tempParent = document.createElement("div");
 tempParent.innerHTML = this.getFlashHTML(); // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)
 targetElement.parentNode.replaceChild(tempParent.firstChild, targetElement);

 if (window[this.movieName] == undefined){
 window[this.movieName] = this.getMovieElement();
}
 
};

SWFUpload.prototype.getFlashHTML = function (){

 return ['<object id="', this.movieName, '" type="application/x-shockwave-flash" data="', this.settings.flash_url, '" width="', this.settings.button_width, '" height="', this.settings.button_height, '" class="swfupload">',
 '<param name="wmode" value="', this.settings.button_window_mode , '" />',
 '<param name="movie" value="', this.settings.flash_url, '" />',
 '<param name="quality" value="high" />',
 '<param name="menu" value="false" />',
 '<param name="allowScriptAccess" value="always" />',
 '<param name="flashvars" value="' + this.getFlashVars() + '" />',
 '</object>'].join("");
};


SWFUpload.prototype.getFlashVars = function (){

 var paramString = this.buildParamString();
 var httpSuccessString = this.settings.http_success.join(",");

 return ["movieName=", encodeURIComponent(this.movieName),
 "&amp;uploadURL=", encodeURIComponent(this.settings.upload_url),
 "&amp;useQueryString=", encodeURIComponent(this.settings.use_query_string),
 "&amp;requeueOnError=", encodeURIComponent(this.settings.requeue_on_error),
 "&amp;httpSuccess=", encodeURIComponent(httpSuccessString),
 "&amp;params=", encodeURIComponent(paramString),
 "&amp;filePostName=", encodeURIComponent(this.settings.file_post_name),
 "&amp;fileTypes=", encodeURIComponent(this.settings.file_types),
 "&amp;fileTypesDescription=", encodeURIComponent(this.settings.file_types_description),
 "&amp;fileSizeLimit=", encodeURIComponent(this.settings.file_size_limit),
 "&amp;fileUploadLimit=", encodeURIComponent(this.settings.file_upload_limit),
 "&amp;fileQueueLimit=", encodeURIComponent(this.settings.file_queue_limit),
 "&amp;debugEnabled=", encodeURIComponent(this.settings.debug_enabled),
 "&amp;buttonImageURL=", encodeURIComponent(this.settings.button_image_url),
 "&amp;buttonWidth=", encodeURIComponent(this.settings.button_width),
 "&amp;buttonHeight=", encodeURIComponent(this.settings.button_height),
 "&amp;buttonText=", encodeURIComponent(this.settings.button_text),
 "&amp;buttonTextTopPadding=", encodeURIComponent(this.settings.button_text_top_padding),
 "&amp;buttonTextLeftPadding=", encodeURIComponent(this.settings.button_text_left_padding),
 "&amp;buttonTextStyle=", encodeURIComponent(this.settings.button_text_style),
 "&amp;buttonAction=", encodeURIComponent(this.settings.button_action),
 "&amp;buttonDisabled=", encodeURIComponent(this.settings.button_disabled),
 "&amp;buttonCursor=", encodeURIComponent(this.settings.button_cursor)
 ].join("");
};


SWFUpload.prototype.getMovieElement = function (){
 if (this.movieElement == undefined){
 this.movieElement = document.getElementById(this.movieName);
}

 if (this.movieElement === null){
 throw "Could not find Flash element";
}
 
 return this.movieElement;
};


SWFUpload.prototype.buildParamString = function (){
 var postParams = this.settings.post_params; 
 var paramStringPairs = [];

 if (typeof(postParams) === "object"){
 for (var name in postParams){
 if (postParams.hasOwnProperty(name)){
 paramStringPairs.push(encodeURIComponent(name.toString()) + "=" + encodeURIComponent(postParams[name].toString()));
}
}
}

 return paramStringPairs.join("&amp;");
};




SWFUpload.prototype.destroy = function (){
 try{

 this.cancelUpload(null, false);

 var movieElement = null;
 movieElement = this.getMovieElement();
 
 if (movieElement){

 for (var i in movieElement){
 try{
 if (typeof(movieElement[i]) === "function"){
 movieElement[i] = null;
}
}catch (ex1){}
}

 try{
 movieElement.parentNode.removeChild(movieElement);
}catch (ex){}
}

 window[this.movieName] = null;

 SWFUpload.instances[this.movieName] = null;
 delete SWFUpload.instances[this.movieName];

 this.movieElement = null;
 this.settings = null;
 this.customSettings = null;
 this.eventQueue = null;
 this.movieName = null;
 
 
 return true;
}catch (ex1){
 return false;
}
};




SWFUpload.prototype.displayDebugInfo = function (){
 this.debug(
 [
 "---SWFUpload Instance Info---\n",
 "Version: ", SWFUpload.version, "\n",
 "Movie Name: ", this.movieName, "\n",
 "Settings:\n",
 "\t", "upload_url: ", this.settings.upload_url, "\n",
 "\t", "flash_url: ", this.settings.flash_url, "\n",
 "\t", "use_query_string: ", this.settings.use_query_string.toString(), "\n",
 "\t", "requeue_on_error: ", this.settings.requeue_on_error.toString(), "\n",
 "\t", "http_success: ", this.settings.http_success.join(", "), "\n",
 "\t", "file_post_name: ", this.settings.file_post_name, "\n",
 "\t", "post_params: ", this.settings.post_params.toString(), "\n",
 "\t", "file_types: ", this.settings.file_types, "\n",
 "\t", "file_types_description: ", this.settings.file_types_description, "\n",
 "\t", "file_size_limit: ", this.settings.file_size_limit, "\n",
 "\t", "file_upload_limit: ", this.settings.file_upload_limit, "\n",
 "\t", "file_queue_limit: ", this.settings.file_queue_limit, "\n",
 "\t", "debug: ", this.settings.debug.toString(), "\n",

 "\t", "prevent_swf_caching: ", this.settings.prevent_swf_caching.toString(), "\n",

 "\t", "button_placeholder_id: ", this.settings.button_placeholder_id.toString(), "\n",
 "\t", "button_image_url: ", this.settings.button_image_url.toString(), "\n",
 "\t", "button_width: ", this.settings.button_width.toString(), "\n",
 "\t", "button_height: ", this.settings.button_height.toString(), "\n",
 "\t", "button_text: ", this.settings.button_text.toString(), "\n",
 "\t", "button_text_style: ", this.settings.button_text_style.toString(), "\n",
 "\t", "button_text_top_padding: ", this.settings.button_text_top_padding.toString(), "\n",
 "\t", "button_text_left_padding: ", this.settings.button_text_left_padding.toString(), "\n",
 "\t", "button_action: ", this.settings.button_action.toString(), "\n",
 "\t", "button_disabled: ", this.settings.button_disabled.toString(), "\n",

 "\t", "custom_settings: ", this.settings.custom_settings.toString(), "\n",
 "Event Handlers:\n",
 "\t", "swfupload_loaded_handler assigned: ", (typeof this.settings.swfupload_loaded_handler === "function").toString(), "\n",
 "\t", "file_dialog_start_handler assigned: ", (typeof this.settings.file_dialog_start_handler === "function").toString(), "\n",
 "\t", "file_queued_handler assigned: ", (typeof this.settings.file_queued_handler === "function").toString(), "\n",
 "\t", "file_queue_error_handler assigned: ", (typeof this.settings.file_queue_error_handler === "function").toString(), "\n",
 "\t", "upload_start_handler assigned: ", (typeof this.settings.upload_start_handler === "function").toString(), "\n",
 "\t", "upload_progress_handler assigned: ", (typeof this.settings.upload_progress_handler === "function").toString(), "\n",
 "\t", "upload_error_handler assigned: ", (typeof this.settings.upload_error_handler === "function").toString(), "\n",
 "\t", "upload_success_handler assigned: ", (typeof this.settings.upload_success_handler === "function").toString(), "\n",
 "\t", "upload_complete_handler assigned: ", (typeof this.settings.upload_complete_handler === "function").toString(), "\n",
 "\t", "debug_handler assigned: ", (typeof this.settings.debug_handler === "function").toString(), "\n"
 ].join("")
 );
};

SWFUpload.prototype.addSetting = function (name, value, default_value){
 if (value == undefined){
 return (this.settings[name] = default_value);
}else{
 return (this.settings[name] = value);
}
};

SWFUpload.prototype.getSetting = function (name){
 if (this.settings[name] != undefined){
 return this.settings[name];
}

 return "";
};



SWFUpload.prototype.callFlash = function (functionName, argumentArray){
 argumentArray = argumentArray || [];
 
 var movieElement = this.getMovieElement();
 var returnValue, returnString;

 try{
 returnString = movieElement.CallFunction('<invoke name="' + functionName + '" returntype="javascript">' + __flash__argumentsToXML(argumentArray, 0) + '</invoke>');
 returnValue = eval(returnString);
}catch (ex){
 throw "Call to " + functionName + " failed";
}

 if (returnValue != undefined && typeof returnValue.post === "object"){
 returnValue = this.unescapeFilePostParams(returnValue);
}

 return returnValue;
};



SWFUpload.prototype.selectFile = function (){
 this.callFlash("SelectFile");
};






SWFUpload.prototype.selectFiles = function (){
 this.callFlash("SelectFiles");
};


SWFUpload.prototype.startUpload = function (fileID){
 this.callFlash("StartUpload", [fileID]);
};



SWFUpload.prototype.cancelUpload = function (fileID, triggerErrorEvent){
 if (triggerErrorEvent !== false){
 triggerErrorEvent = true;
}
 this.callFlash("CancelUpload", [fileID, triggerErrorEvent]);
};


SWFUpload.prototype.stopUpload = function (){
 this.callFlash("StopUpload");
};


 SWFUpload.prototype.cancelQueue = function (){
 this.customSettings.queue_cancelled_flag = true;
 this.stopUpload();
 
 var stats = this.getStats();
 while (stats.files_queued > 0){
 this.cancelUpload();
 stats = this.getStats();
}
};

SWFUpload.prototype.getStats = function (){
 return this.callFlash("GetStats");
};




SWFUpload.prototype.setStats = function (statsObject){
 this.callFlash("SetStats", [statsObject]);
};


SWFUpload.prototype.getFile = function (fileID){
 if (typeof(fileID) === "number"){
 return this.callFlash("GetFileByIndex", [fileID]);
}else{
 return this.callFlash("GetFile", [fileID]);
}
};



SWFUpload.prototype.addFileParam = function (fileID, name, value){
 return this.callFlash("AddFileParam", [fileID, name, value]);
};


SWFUpload.prototype.removeFileParam = function (fileID, name){
 this.callFlash("RemoveFileParam", [fileID, name]);
};

SWFUpload.prototype.setUploadURL = function (url){
 this.settings.upload_url = url.toString();
 this.callFlash("SetUploadURL", [url]);
};

SWFUpload.prototype.setPostParams = function (paramsObject){
 this.settings.post_params = paramsObject;
 this.callFlash("SetPostParams", [paramsObject]);
};

SWFUpload.prototype.addPostParam = function (name, value){
 this.settings.post_params[name] = value;
 this.callFlash("SetPostParams", [this.settings.post_params]);
};

SWFUpload.prototype.removePostParam = function (name){
 delete this.settings.post_params[name];
 this.callFlash("SetPostParams", [this.settings.post_params]);
};

SWFUpload.prototype.setFileTypes = function (types, description){
 this.settings.file_types = types;
 this.settings.file_types_description = description;
 this.callFlash("SetFileTypes", [types, description]);
};

SWFUpload.prototype.setFileSizeLimit = function (fileSizeLimit){
 this.settings.file_size_limit = fileSizeLimit;
 this.callFlash("SetFileSizeLimit", [fileSizeLimit]);
};

SWFUpload.prototype.setFileUploadLimit = function (fileUploadLimit){
 this.settings.file_upload_limit = fileUploadLimit;
 this.callFlash("SetFileUploadLimit", [fileUploadLimit]);
};

SWFUpload.prototype.setFileQueueLimit = function (fileQueueLimit){
 this.settings.file_queue_limit = fileQueueLimit;
 this.callFlash("SetFileQueueLimit", [fileQueueLimit]);
};

SWFUpload.prototype.setFilePostName = function (filePostName){
 this.settings.file_post_name = filePostName;
 this.callFlash("SetFilePostName", [filePostName]);
};

SWFUpload.prototype.setUseQueryString = function (useQueryString){
 this.settings.use_query_string = useQueryString;
 this.callFlash("SetUseQueryString", [useQueryString]);
};

SWFUpload.prototype.setRequeueOnError = function (requeueOnError){
 this.settings.requeue_on_error = requeueOnError;
 this.callFlash("SetRequeueOnError", [requeueOnError]);
};

SWFUpload.prototype.setHTTPSuccess = function (http_status_codes){
 if (typeof http_status_codes === "string"){
 http_status_codes = http_status_codes.replace(" ", "").split(",");
}
 
 this.settings.http_success = http_status_codes;
 this.callFlash("SetHTTPSuccess", [http_status_codes]);
};

SWFUpload.prototype.setDebugEnabled = function (debugEnabled){
 this.settings.debug_enabled = debugEnabled;
 this.callFlash("SetDebugEnabled", [debugEnabled]);
};

SWFUpload.prototype.setButtonImageURL = function (buttonImageURL){
 if (buttonImageURL == undefined){
 buttonImageURL = "";
}
 
 this.settings.button_image_url = buttonImageURL;
 this.callFlash("SetButtonImageURL", [buttonImageURL]);
};

SWFUpload.prototype.setButtonDimensions = function (width, height){
 this.settings.button_width = width;
 this.settings.button_height = height;
 
 var movie = this.getMovieElement();
 if (movie != undefined){
 movie.style.width = width + "px";
 movie.style.height = height + "px";
}
 
 this.callFlash("SetButtonDimensions", [width, height]);
};

SWFUpload.prototype.setButtonText = function (html){
 this.settings.button_text = html;
 this.callFlash("SetButtonText", [html]);
};

SWFUpload.prototype.setButtonTextPadding = function (left, top){
 this.settings.button_text_top_padding = top;
 this.settings.button_text_left_padding = left;
 this.callFlash("SetButtonTextPadding", [left, top]);
};

SWFUpload.prototype.setButtonTextStyle = function (css){
 this.settings.button_text_style = css;
 this.callFlash("SetButtonTextStyle", [css]);
};

SWFUpload.prototype.setButtonDisabled = function (isDisabled){
 this.settings.button_disabled = isDisabled;
 this.callFlash("SetButtonDisabled", [isDisabled]);
};

SWFUpload.prototype.setButtonAction = function (buttonAction){
 this.settings.button_action = buttonAction;
 this.callFlash("SetButtonAction", [buttonAction]);
};

SWFUpload.prototype.setButtonCursor = function (cursor){
 this.settings.button_cursor = cursor;
 this.callFlash("SetButtonCursor", [cursor]);
};



SWFUpload.prototype.queueEvent = function (handlerName, argumentArray){

 
 if (argumentArray == undefined){
 argumentArray = [];
}else if (!(argumentArray instanceof Array)){
 argumentArray = [argumentArray];
}
 
 var self = this;
 if (typeof this.settings[handlerName] === "function"){

 this.eventQueue.push(function (){
 this.settings[handlerName].apply(this, argumentArray);
});

 setTimeout(function (){
 self.executeNextEvent();
}, 0);
 
}else if (this.settings[handlerName] !== null){
 throw "Event handler " + handlerName + " is unknown or is not a function";
}
};


SWFUpload.prototype.executeNextEvent = function (){


 var f = this.eventQueue ? this.eventQueue.shift() : null;
 if (typeof(f) === "function"){
 f.apply(this);
}
};



SWFUpload.prototype.unescapeFilePostParams = function (file){
 var reg = /[$]([0-9a-f]{4})/i;
 var unescapedPost ={};
 var uk;

 if (file != undefined){
 for (var k in file.post){
 if (file.post.hasOwnProperty(k)){
 uk = k;
 var match;
 while ((match = reg.exec(uk)) !== null){
 uk = uk.replace(match[0], String.fromCharCode(parseInt("0x" + match[1], 16)));
}
 unescapedPost[uk] = file.post[k];
}
}

 file.post = unescapedPost;
}

 return file;
};

SWFUpload.prototype.flashReady = function (){

 var movieElement = this.getMovieElement();

 if (typeof(movieElement.CallFunction) === "unknown"){// We only want to do this in IE
 this.debug("Removing Flash functions hooks (this should only run in IE and should prevent memory leaks)");
 for (var key in movieElement){
 try{
 if (typeof(movieElement[key]) === "function"){
 movieElement[key] = null;
}
}catch (ex){
}
}
}
 
 this.queueEvent("swfupload_loaded_handler");
};



SWFUpload.prototype.fileDialogStart = function (){
 this.queueEvent("file_dialog_start_handler");
};



SWFUpload.prototype.fileQueued = function (file){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("file_queued_handler", file);
};



SWFUpload.prototype.fileQueueError = function (file, errorCode, message){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("file_queue_error_handler", [file, errorCode, message]);
};


SWFUpload.prototype.fileDialogComplete = function (numFilesSelected, numFilesQueued){
 this.queueEvent("file_dialog_complete_handler", [numFilesSelected, numFilesQueued]);
};

SWFUpload.prototype.uploadStart = function (file){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("return_upload_start_handler", file);
};

SWFUpload.prototype.returnUploadStart = function (file){
 var returnValue;
 if (typeof this.settings.upload_start_handler === "function"){
 file = this.unescapeFilePostParams(file);
 returnValue = this.settings.upload_start_handler.call(this, file);
}else if (this.settings.upload_start_handler != undefined){
 throw "upload_start_handler must be a function";
}


 if (returnValue === undefined){
 returnValue = true;
}
 
 returnValue = !!returnValue;
 
 this.callFlash("ReturnUploadStart", [returnValue]);
};



SWFUpload.prototype.uploadProgress = function (file, bytesComplete, bytesTotal){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("upload_progress_handler", [file, bytesComplete, bytesTotal]);
};

SWFUpload.prototype.uploadError = function (file, errorCode, message){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("upload_error_handler", [file, errorCode, message]);
};

SWFUpload.prototype.uploadSuccess = function (file, serverData){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("upload_success_handler", [file, serverData]);
};

SWFUpload.prototype.uploadComplete = function (file){
 file = this.unescapeFilePostParams(file);
 this.queueEvent("upload_complete_handler", file);
};


SWFUpload.prototype.debug = function (message){
 this.queueEvent("debug_handler", message);
};



SWFUpload.prototype.debugMessage = function (message){
 if (this.settings.debug){
 var exceptionMessage, exceptionValues = [];

 if (typeof message === "object" && typeof message.name === "string" && typeof message.message === "string"){
 for (var key in message){
 if (message.hasOwnProperty(key)){
 exceptionValues.push(key + ": " + message[key]);
}
}
 exceptionMessage = exceptionValues.join("\n") || "";
 exceptionValues = exceptionMessage.split("\n");
 exceptionMessage = "EXCEPTION: " + exceptionValues.join("\nEXCEPTION: ");
 SWFUpload.Console.writeLine(exceptionMessage);
}else{
 SWFUpload.Console.writeLine(message);
}
}
};

SWFUpload.Console ={};
SWFUpload.Console.writeLine = function (message){
 var console, documentForm;

 try{
 console = document.getElementById("SWFUpload_Console");

 if (!console){
 documentForm = document.createElement("form");
 document.getElementsByTagName("body")[0].appendChild(documentForm);

 console = document.createElement("textarea");
 console.id = "SWFUpload_Console";
 console.style.fontFamily = "monospace";
 console.setAttribute("wrap", "off");
 console.wrap = "off";
 console.style.overflow = "auto";
 console.style.width = "700px";
 console.style.height = "350px";
 console.style.margin = "5px";
 documentForm.appendChild(console);
}

 console.value += message + "\n";

 console.scrollTop = console.scrollHeight - console.clientHeight;
}catch (ex){
 alert("Exception: " + ex.name + " Message: " + ex.message);
}
};

}// endif SWFUploader 2.2

else{//Ez pedig a régi
 

var SWFUpload = function (init_settings){


 try{
 document.execCommand('BackgroundImageCache', false, true);
}catch (ex1){
}


 try{
 this.customSettings ={}; // A container where developers can place their own settings associated with this instance.
 this.settings ={};
 this.eventQueue = [];
 this.movieName = "SWFUpload_" + SWFUpload.movieCount++;
 this.movieElement = null;

 SWFUpload.instances[this.movieName] = this;

 this.initSettings(init_settings);
 this.loadFlash();

 this.displayDebugInfo();

}catch (ex2){
 this.debug(ex2);
}
};




SWFUpload.instances ={};
SWFUpload.movieCount = 0;
SWFUpload.QUEUE_ERROR ={
 QUEUE_LIMIT_EXCEEDED : -100,
 FILE_EXCEEDS_SIZE_LIMIT : -110,
 ZERO_BYTE_FILE : -120,
 INVALID_FILETYPE : -130
};
SWFUpload.UPLOAD_ERROR ={
 HTTP_ERROR : -200,
 MISSING_UPLOAD_URL : -210,
 IO_ERROR : -220,
 SECURITY_ERROR : -230,
 UPLOAD_LIMIT_EXCEEDED : -240,
 UPLOAD_FAILED : -250,
 SPECIFIED_FILE_ID_NOT_FOUND : -260,
 FILE_VALIDATION_FAILED : -270,
 FILE_CANCELLED : -280,
 UPLOAD_STOPPED : -290
};
SWFUpload.FILE_STATUS ={
 QUEUED : -1,
 IN_PROGRESS : -2,
 ERROR : -3,
 COMPLETE : -4,
 CANCELLED : -5
};


SWFUpload.prototype.initSettings = function (init_settings){

 this.addSetting("upload_url", init_settings.upload_url, "");
 this.addSetting("hidden_id", init_settings.hidden_id, "");
 this.addSetting("file_post_name", init_settings.file_post_name, "Filedata");
 this.addSetting("post_params", init_settings.post_params,{});

 this.addSetting("file_types", init_settings.file_types, "*.gif;*.jpg;*.png;*.zip");
 this.addSetting("file_types_description", init_settings.file_types_description, "Common Web Image Formats (gif, jpg, png)");
 this.addSetting("file_size_limit", init_settings.file_size_limit, "0");
 this.addSetting("file_upload_limit", init_settings.file_upload_limit, "0");
 this.addSetting("file_queue_limit", init_settings.file_queue_limit, "0");

 this.addSetting("flash_url", init_settings.flash_url, "/flash/swfupload.swf");
 this.addSetting("flash_width", init_settings.flash_width, "1px");
 this.addSetting("flash_height", init_settings.flash_height, "1px");
 this.addSetting("flash_color", init_settings.flash_color, "#FFFFFF");

 this.addSetting("debug_enabled", init_settings.debug, false);
 this.debug_enabled = this.getSetting("debug_enabled");

 this.flashReady_handler = SWFUpload.flashReady; // This is a non-overrideable event handler
 this.swfUploadLoaded_handler = this.retrieveSetting(init_settings.swfupload_loaded_handler, SWFUpload.swfUploadLoaded);
 
 this.fileDialogStart_handler = this.retrieveSetting(init_settings.file_dialog_start_handler, SWFUpload.fileDialogStart);
 this.fileQueued_handler = this.retrieveSetting(init_settings.file_queued_handler, SWFUpload.fileQueued);
 this.fileQueueError_handler = this.retrieveSetting(init_settings.file_queue_error_handler, SWFUpload.fileQueueError);
 this.fileDialogComplete_handler = this.retrieveSetting(init_settings.file_dialog_complete_handler, SWFUpload.fileDialogComplete);
 
 this.uploadStart_handler = this.retrieveSetting(init_settings.upload_start_handler, SWFUpload.uploadStart);
 this.uploadProgress_handler = this.retrieveSetting(init_settings.upload_progress_handler, SWFUpload.uploadProgress);
 this.uploadError_handler = this.retrieveSetting(init_settings.upload_error_handler, SWFUpload.uploadError);
 this.uploadComplete_handler = this.retrieveSetting(init_settings.upload_complete_handler, SWFUpload.uploadComplete);
 this.fileComplete_handler = this.retrieveSetting(init_settings.file_complete_handler, SWFUpload.fileComplete);

 this.debug_handler = this.retrieveSetting(init_settings.debug_handler, SWFUpload.debug);


 this.addSetting("ui_container_id", init_settings.ui_container_id, "");
 this.addSetting("degraded_container_id", init_settings.degraded_container_id, "");

 
};



SWFUpload.prototype.loadFlash = function (){
 var html, target_element, container;

 if (document.getElementById(this.movieName) !== null){
 return false;
}

 try{
 target_element = document.getElementsByTagName("body")[0];
 if (typeof(target_element) === "undefined" || target_element === null){
 this.debug('Could not find an element to add the Flash too. Failed to find element for "flash_container_id" or the BODY element.');
 return false;
}
}catch (ex){
 return false;
}

 container = document.createElement("div");
 container.style.width = this.getSetting("flash_width");
 container.style.height = this.getSetting("flash_height");

 target_element.appendChild(container);
 container.innerHTML = this.getFlashHTML(); // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)
};

SWFUpload.prototype.getFlashHTML = function (){
 var html = "";

 if (navigator.plugins && navigator.mimeTypes && navigator.mimeTypes.length){

 html = '<embed type="application/x-shockwave-flash" src="' + this.getSetting("flash_url") + '" width="' + this.getSetting("flash_width") + '" height="' + this.getSetting("flash_height") + '"';
 html += ' id="' + this.movieName + '" name="' + this.movieName + '" ';
 html += 'bgcolor="' + this.getSetting("flash_color") + '" quality="high" menu="false" flashvars="';

 html += this.getFlashVars();

 html += '" />';

}else{

 html = '<object id="' + this.movieName + '" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="' + this.getSetting("flash_width") + '" height="' + this.getSetting("flash_height") + '">';
 html += '<param name="movie" value="' + this.getSetting("flash_url") + '">';

 html += '<param name="bgcolor" value="' + this.getSetting("flash_color") + '" />';
 html += '<param name="quality" value="high" />';
 html += '<param name="menu" value="false" />';

 html += '<param name="flashvars" value="' + this.getFlashVars() + '" />';
 html += 'A tartalom megtekintéséhez flashplayer szükséges / Nem elérhető a tartalom';
 html += '</object>';

}
 
 if ((navigator.appName == "Microsoft Internet Explorer" &&
 navigator.appVersion.indexOf("Mac") == -1 && navigator.appVersion.indexOf("3.1") == -1) ||
 (navigator.plugins && navigator.plugins["Shockwave Flash"])
 || navigator.plugins["Shockwave Flash 2.0"]){

 return html;
}else{

 return 'Kérjük telepitsen flash playert';
}

};


SWFUpload.prototype.getFlashVars = function (){

 var param_string = this.buildParamString();

 var html = "";
 html += "movieName=" + encodeURIComponent(this.movieName);
 html += "&uploadURL=" + encodeURIComponent(this.getSetting("upload_url"));
 html += "&params=" + encodeURIComponent(param_string);
 html += "&filePostName=" + encodeURIComponent(this.getSetting("file_post_name"));
 html += "&fileTypes=" + encodeURIComponent(this.getSetting("file_types"));
 html += "&fileTypesDescription=" + encodeURIComponent(this.getSetting("file_types_description"));
 html += "&fileSizeLimit=" + encodeURIComponent(this.getSetting("file_size_limit"));
 html += "&fileUploadLimit=" + encodeURIComponent(this.getSetting("file_upload_limit"));
 html += "&fileQueueLimit=" + encodeURIComponent(this.getSetting("file_queue_limit"));
 html += "&debugEnabled=" + encodeURIComponent(this.getSetting("debug_enabled"));

 return html;
};

SWFUpload.prototype.getMovieElement = function (){
 if (typeof(this.movieElement) === "undefined" || this.movieElement === null){
 this.movieElement = document.getElementById(this.movieName);







}

 return this.movieElement;
};

SWFUpload.prototype.buildParamString = function (){
 var post_params = this.getSetting("post_params");
 var param_string_pairs = [];
 var i, value, name;

 if (typeof(post_params) === "object"){
 for (name in post_params){
 if (post_params.hasOwnProperty(name)){
 if (typeof(post_params[name]) === "string"){
 param_string_pairs.push(encodeURIComponent(name) + "=" + encodeURIComponent(post_params[name]));
}
}
}
}

 return param_string_pairs.join("&");
};

SWFUpload.prototype.addSetting = function (name, value, default_value){
 if (typeof(value) === "undefined" || value === null){
 this.settings[name] = default_value;
}else{
 this.settings[name] = value;
}

 return this.settings[name];
};

SWFUpload.prototype.getSetting = function (name){
 if (typeof(this.settings[name]) === "undefined"){
 return "";
}else{
 return this.settings[name];
}
};


SWFUpload.prototype.retrieveSetting = function (value, default_value){
 if (typeof(value) === "undefined" || value === null){
 return default_value;
}else{
 return value;
}
};


SWFUpload.prototype.displayDebugInfo = function (){
 var key, debug_message = "";

 debug_message += "----- SWFUPLOAD SETTINGS ----\nID: " + this.getMovieElement().id + "\n";

 debug_message += this.outputObject(this.settings);

 debug_message += "----- SWFUPLOAD SETTINGS END ----\n";
 debug_message += "\n";

 this.debug(debug_message);
};
SWFUpload.prototype.outputObject = function (object, prefix){
 var output = "", key;

 if (typeof(prefix) !== "string"){
 prefix = "";
}
 if (typeof(object) !== "object"){
 return "";
}

 for (key in object){
 if (object.hasOwnProperty(key)){
 if (typeof(object[key]) === "object"){
 output += (prefix + key + ":{\n" + this.outputObject(object[key], "\t" + prefix) + prefix + "}" + "\n");
}else{
 output += (prefix + key + ": " + object[key] + "\n");
}
}
}

 return output;
};



SWFUpload.prototype.selectFile = function (){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SelectFile) === "function"){
 try{
 movie_element.SelectFile();
}
 catch (ex){
 this.debug("Could not call SelectFile: " + ex);
}
}else{
 this.debug("Could not find Flash element");
}

};

SWFUpload.prototype.selectFiles = function (){
 var p={};
 miracle.ajax("miracle", "initialize_upload", p, function(dummy){}.bind(this));
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SelectFiles) === "function"){
 try{
 movie_element.SelectFiles();
}
 catch (ex){
 this.debug("Could not call SelectFiles: " + ex);
}
}else{
 this.debug("Could not find Flash element");
}

};



SWFUpload.prototype.startUpload = function (file_id){
 var self = this;
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.StartUpload) === "function"){
 setTimeout(
 function (){
 try{
 movie_element.StartUpload(file_id);
}
 catch (ex){
 self.debug("Could not call StartUpload: " + ex);
}
}, 0
 );
}else{
 this.debug("Could not find Flash element");
}

};


SWFUpload.prototype.cancelUpload = function (file_id){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.CancelUpload) === "function"){
 try{
 movie_element.CancelUpload(file_id);
}
 catch (ex){
 this.debug("Could not call CancelUpload: " + ex);
}
}else{
 this.debug("Could not find Flash element");
}

};

SWFUpload.prototype.stopUpload = function (){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.StopUpload) === "function"){
 try{
 movie_element.StopUpload();
}
 catch (ex){
 this.debug("Could not call StopUpload: " + ex);
}
}else{
 this.debug("Could not find Flash element");
}

};




SWFUpload.prototype.getStats = function (){
 var self = this;
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.GetStats) === "function"){
 try{
 return movie_element.GetStats();
}
 catch (ex){
 self.debug("Could not call GetStats");
}
}else{
 this.debug("Could not find Flash element");
}
};

SWFUpload.prototype.addFileParam = function (file_id, name, value){
 var self = this;
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.AddFileParam) === "function"){
 try{
 return movie_element.AddFileParam(file_id, name, value);
}
 catch (ex){
 self.debug("Could not call AddFileParam");
}
}else{
 this.debug("Could not find Flash element");
}
};

SWFUpload.prototype.removeFileParam = function (file_id, name){
 var self = this;
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.RemoveFileParam) === "function"){
 try{
 return movie_element.RemoveFileParam(file_id, name);
}
 catch (ex){
 self.debug("Could not call AddFileParam");
}
}else{
 this.debug("Could not find Flash element");
}

};

SWFUpload.prototype.setUploadURL = function (url){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetUploadURL) === "function"){
 try{
 this.addSetting("upload_url", url);
 movie_element.SetUploadURL(this.getSetting("upload_url"));
}
 catch (ex){
 this.debug("Could not call SetUploadURL");
}
}else{
 this.debug("Could not find Flash element in setUploadURL");
}
};

SWFUpload.prototype.setPostParams = function (param_object){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetPostParams) === "function"){
 try{
 this.addSetting("post_params", param_object);
 movie_element.SetPostParams(this.getSetting("post_params"));
}
 catch (ex){
 this.debug("Could not call SetPostParams");
}
}else{
 this.debug("Could not find Flash element in SetPostParams");
}
};

SWFUpload.prototype.setFileTypes = function (types, description){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetFileTypes) === "function"){
 try{
 this.addSetting("file_types", types);
 this.addSetting("file_types_description", description);
 movie_element.SetFileTypes(this.getSetting("file_types"), this.getSetting("file_types_description"));
}
 catch (ex){
 this.debug("Could not call SetFileTypes");
}
}else{
 this.debug("Could not find Flash element in SetFileTypes");
}
};

SWFUpload.prototype.setFileSizeLimit = function (file_size_limit){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetFileSizeLimit) === "function"){
 try{
 this.addSetting("file_size_limit", file_size_limit);
 movie_element.SetFileSizeLimit(this.getSetting("file_size_limit"));
}
 catch (ex){
 this.debug("Could not call SetFileSizeLimit");
}
}else{
 this.debug("Could not find Flash element in SetFileSizeLimit");
}
};

SWFUpload.prototype.setFileUploadLimit = function (file_upload_limit){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetFileUploadLimit) === "function"){
 try{
 this.addSetting("file_upload_limit", file_upload_limit);
 movie_element.SetFileUploadLimit(this.getSetting("file_upload_limit"));
}
 catch (ex){
 this.debug("Could not call SetFileUploadLimit");
}
}else{
 this.debug("Could not find Flash element in SetFileUploadLimit");
}
};

SWFUpload.prototype.setFileQueueLimit = function (file_queue_limit){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetFileQueueLimit) === "function"){
 try{
 this.addSetting("file_queue_limit", file_queue_limit);
 movie_element.SetFileQueueLimit(this.getSetting("file_queue_limit"));
}
 catch (ex){
 this.debug("Could not call SetFileQueueLimit");
}
}else{
 this.debug("Could not find Flash element in SetFileQueueLimit");
}
};

SWFUpload.prototype.setFilePostName = function (file_post_name){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetFilePostName) === "function"){
 try{
 this.addSetting("file_post_name", file_post_name);
 movie_element.SetFilePostName(this.getSetting("file_post_name"));
}
 catch (ex){
 this.debug("Could not call SetFilePostName");
}
}else{
 this.debug("Could not find Flash element in SetFilePostName");
}
};

SWFUpload.prototype.setDebugEnabled = function (debug_enabled){
 var movie_element = this.getMovieElement();
 if (movie_element !== null && typeof(movie_element.SetDebugEnabled) === "function"){
 try{
 this.addSetting("debug_enabled", debug_enabled);
 this.debug_enabled = this.getSetting("debug_enabled");
 movie_element.SetDebugEnabled(this.getSetting("debug_enabled"));
}
 catch (ex){
 this.debug("Could not call SetDebugEnabled");
}
}else{
 this.debug("Could not find Flash element in SetDebugEnabled");
}
};






SWFUpload.prototype.flashReady = function (){
 var self = this;
 if (typeof(self.fileDialogStart_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.flashReady_handler();};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("fileDialogStart event not defined");
}
};


SWFUpload.prototype.executeNextEvent = function (){
 var f = this.eventQueue.shift();
 if (typeof(f) === "function"){
 f();
}
}


SWFUpload.prototype.fileDialogStart = function (){
 var self = this;
 if (typeof(self.fileDialogStart_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.fileDialogStart_handler();};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("fileDialogStart event not defined");
}
};



SWFUpload.prototype.fileQueued = function (file){
 var self = this;
 if (typeof(self.fileQueued_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.fileQueued_handler(file);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("fileQueued event not defined");
}
};



SWFUpload.prototype.fileQueueError = function (file, error_code, message){
 var self = this;
 if (typeof(self.fileQueueError_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.fileQueueError_handler(file, error_code, message);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("fileQueueError event not defined");
}
};


SWFUpload.prototype.fileDialogComplete = function (num_files_selected){
 var self = this;
 if (typeof(self.fileDialogComplete_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.fileDialogComplete_handler(num_files_selected);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("fileDialogComplete event not defined");
}
};


SWFUpload.prototype.uploadStart = function (file){
 if (typeof(this.uploadStart_handler) === "function"){
 return this.uploadStart_handler(file);
}else{
 this.debug("uploadStart event not defined");
 return true;
}
};


SWFUpload.prototype.uploadProgress = function (file, bytes_complete, bytes_total){
 var self = this;
 if (typeof(self.uploadProgress_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.uploadProgress_handler(file, bytes_complete, bytes_total);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("uploadProgress event not defined");
}
};


SWFUpload.prototype.uploadError = function (file, error_code, message){
 var self = this;
 if (typeof(this.uploadError_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.uploadError_handler(file, error_code, message);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("uploadError event not defined");
}
};


SWFUpload.prototype.uploadComplete = function (file, server_data){
 var self = this;
 if (typeof(self.uploadComplete_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.uploadComplete_handler(file, server_data);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("uploadComplete event not defined");
}
};


SWFUpload.prototype.fileComplete = function (file){
 var self = this;
 if (typeof(self.fileComplete_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.fileComplete_handler(file);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.debug("fileComplete event not defined");
}
};


SWFUpload.prototype.debug = function (message){
 var self = this;
 if (typeof(self.debug_handler) === "function"){
 this.eventQueue[this.eventQueue.length] = function(){self.debug_handler(message);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}else{
 this.eventQueue[this.eventQueue.length] = function(){self.debugMessage(message);};
 setTimeout(function (){self.executeNextEvent();}, 0);
}
};





SWFUpload.flashReady = function (){
 try{
 this.debug("Flash called back and is ready.");

 if (typeof(this.swfUploadLoaded_handler) === "function"){
 this.swfUploadLoaded_handler();
}
}catch (ex){
 this.debug(ex);
}
}

SWFUpload.swfUploadLoaded = function (){
 var ui_container_id, ui_target, degraded_container_id, degraded_target;
 try{
 ui_container_id = this.getSetting("ui_container_id");

 if (typeof(ui_container_id) === "string" && ui_container_id !== ""){
 ui_target = document.getElementById(ui_container_id);
 if (ui_target !== null){
 ui_target.style.display = "block";

 degraded_container_id = this.getSetting("degraded_container_id");
 if (typeof(degraded_container_id) && degraded_container_id !== ""){
 degraded_target = document.getElementById(degraded_container_id);
 if (degraded_target !== null){
 degraded_target.style.display = "none";
}
}
}

}

}catch (ex){
 this.debug(ex);
}
}


SWFUpload.fileDialogStart = function (){
};



SWFUpload.fileQueued = function (file){
};



SWFUpload.fileQueueError = function (file, error_code, message){
 try{
 switch (error_code){
 case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
 this.debug("Error Code: File too big, File name: " + file.name + ", File size: " + file.size + ", Message: " + message);
 break;
 case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE:
 this.debug("Error Code: Zero Byte File, File name: " + file.name + ", File size: " + file.size + ", Message: " + message);
 break;
 case SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED:
 this.debug("Error Code: Upload limit reached, File name: " + file.name + ", File size: " + file.size + ", Message: " + message);
 break;
 case SWFUpload.QUEUE_ERROR.INVALID_FILETYPE:
 this.debug("Error Code: File extension is not allowed, Message: " + message);
 break;
 default:
 this.debug("Error Code: Unhandled error occured. Errorcode: " + error_code);
}
}catch (ex){
 this.debug(ex);
}
};


SWFUpload.fileDialogComplete = function (num_files_selected){
};


SWFUpload.uploadStart = function (file){
 return true;
};

SWFUpload.uploadProgress = function (file, bytes_complete, bytes_total){
 this.debug("File Progress: " + file.id + ", Bytes: " + bytes_complete + ". Total: " + bytes_total);
};


SWFUpload.uploadComplete = function (file, server_data){
};


SWFUpload.fileComplete = function (file){
};


SWFUpload.debug = function (message){
 if (this.debug_enabled){
 this.debugMessage(message);
}
};


SWFUpload.uploadError = function (file, error_code, message){
 try{
 switch (errcode){
 case SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND:
 this.debug("Error Code: File ID specified for upload was not found, Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.HTTP_ERROR:
 this.debug("Error Code: HTTP Error, File name: " + file.name + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.MISSING_UPLOAD_URL:
 this.debug("Error Code: No backend file, File name: " + file.name + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.IO_ERROR:
 this.debug("Error Code: IO Error, File name: " + file.name + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR:
 this.debug("Error Code: Security Error, File name: " + file.name + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.UPLOAD_LIMIT_EXCEEDED:
 this.debug("Error Code: Upload limit reached, File name: " + file.name + ", File size: " + file.size + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.UPLOAD_FAILED:
 this.debug("Error Code: Upload Initialization exception, File name: " + file.name + ", File size: " + file.size + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED:
 this.debug("Error Code: uploadStart callback returned false, File name: " + file.name + ", File size: " + file.size + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
 this.debug("Error Code: The file upload was cancelled, File name: " + file.name + ", File size: " + file.size + ", Message: " + msg);
 break;
 case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED:
 this.debug("Error Code: The file upload was stopped, File name: " + file.name + ", File size: " + file.size + ", Message: " + msg);
 break;
 default:
 this.debug("Error Code: Unhandled error occured. Errorcode: " + errcode);
}
}catch (ex){
 this.debug(ex);
}
};




SWFUpload.prototype.debugMessage = function (message){
 var exception_message, exception_values;

 if (typeof(message) === "object" && typeof(message.name) === "string" && typeof(message.message) === "string"){
 exception_message = "";
 exception_values = [];
 for (var key in message){
 exception_values.push(key + ": " + message[key]);
}
 exception_message = exception_values.join("\n");
 exception_values = exception_message.split("\n");
 exception_message = "EXCEPTION: " + exception_values.join("\nEXCEPTION: ");
 SWFUpload.Console.writeLine(exception_message);
}else{
 SWFUpload.Console.writeLine(message);
}
};

SWFUpload.Console ={};
SWFUpload.Console.writeLine = function (message){
 var console, documentForm;

 try{
 console = document.getElementById("SWFUpload_Console");

 if (!console){
 documentForm = document.createElement("form");
 document.getElementsByTagName("body")[0].appendChild(documentForm);

 console = document.createElement("textarea");
 console.id = "SWFUpload_Console";
 console.style.fontFamily = "monospace";
 console.setAttribute("wrap", "off");
 console.wrap = "off";
 console.style.overflow = "auto";
 console.style.width = "700px";
 console.style.height = "350px";
 console.style.margin = "5px";
 documentForm.appendChild(console);
}

 console.value += message + "\n";

 console.scrollTop = console.scrollHeight - console.clientHeight;
}catch (ex){
 alert("Exception: " + ex.name + " Message: " + ex.message);
}
};

}//endif SWFuploader Régi

















function cancelQueue(instance){
 document.getElementById(instance.customSettings.cancelButtonId).disabled = true;
 instance.stopUpload();
 var stats;
 
 do{
 stats = instance.getStats();
 instance.cancelUpload();
}while (stats.files_queued !== 0);
 
}

function fileDialogStart(){

}
function fileQueued(fileObj){
 try{


 var progress = new FileProgress(fileObj, this.customSettings.progressTarget);
 progress.SetStatus("Pending...");
 progress.ToggleCancel(true, this);

}catch (ex){this.debug(ex);}

}

function fileQueueError(fileObj, error_code, message){
 try{
 if (error_code === SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED){
 alert("Sajnos több file feltöltése nem engedélyezett!");
 return;
}

 var progress = new FileProgress(fileObj, this.customSettings.progressTarget);
 progress.SetError();
 progress.ToggleCancel(false);

 switch(error_code){
 case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT:
 progress.SetStatus("A file túl nagy!");
 this.debug("Error Code: File too big, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE:
 progress.SetStatus("Cannot upload Zero Byte files.");
 this.debug("Error Code: Zero byte file, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.QUEUE_ERROR.INVALID_FILETYPE:
 progress.SetStatus("Invalid File Type.");
 this.debug("Error Code: Invalid File Type, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED:
 alert("You have selected too many files. " + (message > 1 ? "You may only add " + message + " more files" : "You cannot add any more files."));
 break;
 default:
 if (fileObj !== null){
 progress.SetStatus("Unhandled Error");
}
 this.debug("Error Code: " + error_code + ", File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
}
}catch (ex){
 this.debug(ex);
}
}

function fileDialogComplete(num_files_queued){
 try{
 if (this.getStats().files_queued > 0){
 document.getElementById(this.customSettings.cancelButtonId).disabled = false;
}
 

 this.startUpload();
}catch (ex){
 this.debug(ex);
}
}

function uploadStart(fileObj){
 try{
 
 var progress = new FileProgress(fileObj, this.customSettings.progressTarget);
 progress.SetStatus("Feltöltés...");
 progress.ToggleCancel(true, this);
}
 catch (ex){}
 
 return true;
}

function uploadProgress(fileObj, bytesLoaded, bytesTotal){

 try{
 var percent = Math.ceil((bytesLoaded / bytesTotal) * 100);

 var progress = new FileProgress(fileObj, this.customSettings.progressTarget);
 progress.SetProgress(percent);
 progress.SetStatus("Feltöltés...");
}catch (ex){this.debug(ex);}
}

function uploadComplete(fileObj, server_data){
 try{
 var progress = new FileProgress(fileObj, this.customSettings.progressTarget);
 progress.SetComplete();
 progress.SetStatus("Feltöltés sikeres.");

 if(this.getSetting("hidden_id").length > 0)
{



 document.getElementById(this.getSetting("hidden_id")).value=document.getElementById(this.getSetting("hidden_id")).value + fileObj.name + ";";
 
}
 
 progress.ToggleCancel(false);

}catch (ex){this.debug(ex);}
}

function fileComplete(fileObj){
 try{
 
 if (this.getStats().files_queued === 0){
 document.getElementById(this.customSettings.cancelButtonId).disabled = true;
}else{
 this.startUpload();
}
}catch (ex){this.debug(ex);}

}

function uploadError(fileObj, error_code, message){
 try{
 var progress = new FileProgress(fileObj, this.customSettings.progressTarget);
 progress.SetError();
 progress.ToggleCancel(false);

 switch(error_code){
 case SWFUpload.UPLOAD_ERROR.HTTP_ERROR:
 progress.SetStatus("Upload Error: " + message);
 this.debug("Error Code: HTTP Error, File name: " + fileObj.name + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.MISSING_UPLOAD_URL:
 progress.SetStatus("Configuration Error");
 this.debug("Error Code: No backend file, File name: " + fileObj.name + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.UPLOAD_FAILED:
 progress.SetStatus("Upload Failed.");
 this.debug("Error Code: Upload Failed, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.IO_ERROR:
 progress.SetStatus("Server (IO) Error");
 this.debug("Error Code: IO Error, File name: " + fileObj.name + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR:
 progress.SetStatus("Security Error");
 this.debug("Error Code: Security Error, File name: " + fileObj.name + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.UPLOAD_LIMIT_EXCEEDED:
 progress.SetStatus("Upload limit exceeded.");
 this.debug("Error Code: Upload Limit Exceeded, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.SPECIFIED_FILE_ID_NOT_FOUND:
 progress.SetStatus("File not found.");
 this.debug("Error Code: The file was not found, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED:
 progress.SetStatus("Failed Validation. Upload skipped.");
 this.debug("Error Code: File Validation Failed, File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
 case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED:
 if (this.getStats().files_queued === 0){
 document.getElementById(this.customSettings.cancelButtonId).disabled = true;
}
 progress.SetStatus("Megszakítva");
 progress.SetCancelled();
 break;
 case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED:
 progress.SetStatus("Leállítva");
 break;
 default:
 progress.SetStatus("Unhandled Error: " + error_code);
 this.debug("Error Code: " + error_code + ", File name: " + fileObj.name + ", File size: " + fileObj.size + ", Message: " + message);
 break;
}
}catch (ex){
 this.debug(ex);
}
}



function FileProgress(fileObj, target_id){
 this.file_progress_id = fileObj.id;

 this.opacity = 100;
 this.height = 0;

 this.fileProgressWrapper = document.getElementById(this.file_progress_id);
 if (!this.fileProgressWrapper){
 this.fileProgressWrapper = document.createElement("div");
 this.fileProgressWrapper.className = "progressWrapper";
 this.fileProgressWrapper.id = this.file_progress_id;

 this.fileProgressElement = document.createElement("div");
 this.fileProgressElement.className = "progressContainer";

 var progressCancel = document.createElement("a");
 progressCancel.className = "progressCancel";
 progressCancel.href = "#";
 progressCancel.style.visibility = "hidden";
 progressCancel.appendChild(document.createTextNode(" "));

 var progressText = document.createElement("div");
 progressText.className = "progressName";
 progressText.appendChild(document.createTextNode(fileObj.name));

 var progressBar = document.createElement("div");
 progressBar.className = "progressBarInProgress";

 var progressStatus = document.createElement("div");
 progressStatus.className = "progressBarStatus";
 progressStatus.innerHTML = "&nbsp;";

 this.fileProgressElement.appendChild(progressCancel);
 this.fileProgressElement.appendChild(progressText);
 this.fileProgressElement.appendChild(progressStatus);
 this.fileProgressElement.appendChild(progressBar);

 this.fileProgressWrapper.appendChild(this.fileProgressElement);

 document.getElementById(target_id).appendChild(this.fileProgressWrapper);
}else{
 this.fileProgressElement = this.fileProgressWrapper.firstChild;
}

 this.height = this.fileProgressWrapper.offsetHeight;

}
FileProgress.prototype.SetProgress = function(percentage){
 this.fileProgressElement.className = "progressContainer green";
 this.fileProgressElement.childNodes[3].className = "progressBarInProgress";
 this.fileProgressElement.childNodes[3].style.width = percentage + "%";
};
FileProgress.prototype.SetComplete = function(){
 this.fileProgressElement.className = "progressContainer blue";
 this.fileProgressElement.childNodes[3].className = "progressBarComplete";
 this.fileProgressElement.childNodes[3].style.width = "";

 var oSelf = this;


};
FileProgress.prototype.SetError = function(){
 this.fileProgressElement.className = "progressContainer red";
 this.fileProgressElement.childNodes[3].className = "progressBarError";
 this.fileProgressElement.childNodes[3].style.width = "";

 var oSelf = this;
 setTimeout(function(){oSelf.Disappear();}, 5000);
};
FileProgress.prototype.SetCancelled = function(){
 this.fileProgressElement.className = "progressContainer";
 this.fileProgressElement.childNodes[3].className = "progressBarError";
 this.fileProgressElement.childNodes[3].style.width = "";

 var oSelf = this;
 setTimeout(function(){oSelf.Disappear();}, 2000);
};
FileProgress.prototype.SetStatus = function(status){
 this.fileProgressElement.childNodes[2].innerHTML = status;
};

FileProgress.prototype.ToggleCancel = function(show, upload_obj){
 this.fileProgressElement.childNodes[0].style.visibility = show ? "visible" : "hidden";
 if (upload_obj){
 var file_id = this.file_progress_id;
 this.fileProgressElement.childNodes[0].onclick = function(){upload_obj.cancelUpload(file_id); return false;};
}
};

FileProgress.prototype.Disappear = function(){

 var reduce_opacity_by = 15;
 var reduce_height_by = 4;
 var rate = 30; // 15 fps

 if (this.opacity > 0){
 this.opacity -= reduce_opacity_by;
 if (this.opacity < 0){
 this.opacity = 0;
}

 if (this.fileProgressWrapper.filters){
 try{
 this.fileProgressWrapper.filters.item("DXImageTransform.Microsoft.Alpha").opacity = this.opacity;
}catch (e){

 this.fileProgressWrapper.style.filter = "progid:DXImageTransform.Microsoft.Alpha(opacity=" + this.opacity + ")";
}
}else{
 this.fileProgressWrapper.style.opacity = this.opacity / 100;
}
}

 if (this.height > 0){
 this.height -= reduce_height_by;
 if (this.height < 0){
 this.height = 0;
}

 this.fileProgressWrapper.style.height = this.height + "px";
}

 if (this.height > 0 || this.opacity > 0){
 var oSelf = this;
 setTimeout(function(){oSelf.Disappear();}, rate);
}else{
 this.fileProgressWrapper.style.display = "none";
}
};









function getFlashVersion(){

 function getVersionNumber(desc){
 var matches = desc.match(/[\d]+/g);
 matches.length = 3; // To standardize IE vs FF
 return matches[0]; //Csak major verziót adjuk vissza

 return matches.join('.'); //Ez visszaadja a teljes verziószámot, csak éppen emiatt String lesz belőle
}

 var version;
 var axo;
 
 if(navigator.plugins && navigator.mimeTypes.length){
 axo = navigator.plugins["Shockwave Flash"];
 if( axo ) version = axo.description;
}
 else{
 try{
 axo = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
 if( axo ) version = axo.GetVariable("$version");
}
 catch (e){
 fResult = "Nincs flasplayer"; //IE
}
}
 
 if( axo ) fResult = getVersionNumber(version);
 else fResult = "Nincs flasplayer"; //FF
 
 return fResult;
}
























var Window = Class.create();
Window.prototype ={



 initialize: function(id){
 if ($(id))
 alert("Window " + id + " is already register is the DOM!!, be sure to use setDestroyOnClose()")
 
 this.hasEffectLib = String.prototype.parseColor != null;
 this.options = Object.extend({
 className: "dialog",
 minWidth: 100,
 minHeight: 20,
 resizable: true,
 closable: true,
 minimizable: true,
 maximizable: true,
 draggable: true,
 userData: null,
 showEffect: (this.hasEffectLib ? Effect.Appear : Element.show),
 hideEffect: (this.hasEffectLib ? Effect.Fade : Element.hide),
 showEffectOptions:{},
 hideEffectOptions:{},
 effectOptions: null,
 parent: document.getElementsByTagName("body").item(0),
 title: "&nbsp;",
 url: null,
 onload: Prototype.emptyFunction,
 width: 200,
 height: 300,
 opacity: 1
}, arguments[1] ||{});
 
 if (this.options.effectOptions){
 Object.extend(this.options.hideEffectOptions, this.options.effectOptions);
 Object.extend(this.options.showEffectOptions, this.options.effectOptions);
}
 if (this.options.hideEffect == Element.hide)
 this.options.hideEffect = function(){Element.hide(this.element); if (this.destroyOnClose) this.destroy();}.bind(this)
 
 this.element = this._createWindow(id);

 this.eventMouseDown = this._initDrag.bindAsEventListener(this);
 this.eventMouseUp = this._endDrag.bindAsEventListener(this);
 this.eventMouseMove = this._updateDrag.bindAsEventListener(this);
 this.eventKeyPress = this._keyPress.bindAsEventListener(this);
 this.eventOnLoad = this._getWindowBorderSize.bindAsEventListener(this);
 this.eventMouseDownContent = this.toFront.bindAsEventListener(this);
 this.eventResize = this._recenter.bindAsEventListener(this);
 
 this.topbar = $(this.element.id + "_top");
 this.bottombar = $(this.element.id + "_bottom");
 this.content = $(this.element.id + "_content");
 
 Event.observe(this.topbar, "mousedown", this.eventMouseDown);
 Event.observe(this.bottombar, "mousedown", this.eventMouseDown);
 Event.observe(this.content, "mousedown", this.eventMouseDownContent);
 Event.observe(window, "load", this.eventOnLoad);
 Event.observe(window, "resize", this.eventResize);
 Event.observe(window, "scroll", this.eventResize);
 
 if (this.options.draggable){
 this.bottombar.addClassName("bottom_draggable");
 this.topbar.addClassName("top_draggable");
}
 
 if (this.options.resizable){
 this.sizer = $(this.element.id + "_sizer");
 Event.observe(this.sizer, "mousedown", this.eventMouseDown);
}
 
 this.useLeft = null;
 this.useTop = null;
 if (arguments[1].left != null){
 this.element.setStyle({left: parseFloat(arguments[1].left) + 'px'});
 this.useLeft = true;
}
 if (arguments[1].right != null){
 this.element.setStyle({right: parseFloat(arguments[1].right) + 'px'});
 this.useLeft = false;
}
 if (this.useLeft == null){
 this.element.setStyle({left: "0px"});
 this.useLeft = true;
}
 
 if (arguments[1].top != null){
 this.element.setStyle({top: parseFloat(arguments[1].top) + 'px'});
 this.useTop = true;
}
 if (arguments[1].bottom != null){
 this.element.setStyle({bottom: parseFloat(arguments[1].bottom) + 'px'}); 
 this.useTop = false;
}
 if (this.useTop == null){
 this.element.setStyle({top: "0px"});
 this.useTop = true;
}

 this.storedLocation = null;
 
 this.setOpacity(this.options.opacity);
 if (this.options.zIndex)
 this.setZIndex(this.options.zIndex)

 this.destroyOnClose = false;

 this._getWindowBorderSize();
 this.width = this.options.width;
 this.height = this.options.height;
 
 if (this.width && this.height)
 this.setSize(this.options.width, this.options.height);
 this.setTitle(this.options.title)
 Windows.register(this); 
},

 destroy: function(){
 Windows.notify("onDestroy", this);
 
 Event.stopObserving(this.topbar, "mousedown", this.eventMouseDown);
 Event.stopObserving(this.bottombar, "mousedown", this.eventMouseDown);
 Event.stopObserving(this.content, "mousedown", this.eventMouseDownContent);
 
 Event.stopObserving(window, "load", this.eventOnLoad);
 Event.stopObserving(window, "resize", this.eventResize);
 Event.stopObserving(window, "scroll", this.eventResize);
 
 Event.stopObserving(this.content, "load", this.options.onload);

 if (this.sizer)
 Event.stopObserving(this.sizer, "mousedown", this.eventMouseDown);

 if (this.options.url)
 this.content.src = null

 if(this.iefix) 
 Element.remove(this.iefix);

 Element.remove(this.element);
 Windows.unregister(this);
 if ($("photogallery2_darken")){
 $("photogallery2_darken").style.display="none";
 var bodys = document.getElementsByTagName("body"); 
 bodys[0].removeClassName("no-scroll");
}
},

 setDelegate: function(delegate){
 this.delegate = delegate
},

 getDelegate: function(){
 return this.delegate;
},

 getContent: function (){
 return this.content;
},

 setContent: function(id, autoresize, autoposition){
 var d = null;
 var p = null;

 if (autoresize) 
 d = Element.getDimensions(id);
 if (autoposition) 
 p = Position.cumulativeOffset($(id));

 var content = this.getContent()
 content.appendChild($(id));
 $(id).show();
 if (autoresize) 
 this.setSize(d.width, d.height);
 if (autoposition) 
 this.setLocation(p[1] - this.heightN, p[0] - this.widthW); 
},
 
 setAjaxContent: function(url, options, showCentered, showModal){
 this.showFunction = showCentered ? "showCenter" : "show";
 this.showModal = showModal || false;
 
 if (options == null)
 options ={}
 this.onComplete = options.onComplete;
 options.onComplete = this._setAjaxContent.bind(this);
 
 new Ajax.Request(url, options);
},
 
 _setAjaxContent: function(originalRequest){
 this.getContent().innerHTML = originalRequest.responseText;
 if (this.onComplete)
 this.onComplete(originalRequest);
 this[this.showFunction](this.showModal)
},

 setCookie: function(name, expires, path, domain, secure){
 name = name || this.element.id;
 this.cookie = [name, expires, path, domain, secure];

 var value = WindowUtilities.getCookie(name)

 if (value){
 var values = value.split(',');
 var x = values[0].split(':');
 var y = values[1].split(':');

 var w = parseFloat(values[2]), h = parseFloat(values[3]);
 var mini = values[4];
 var maxi = values[5];

 this.setSize(w, h);
 if (mini == "true")
 this.doMinimize = true; // Minimize will be done at onload window event
 else if (maxi == "true")
 this.doMaximize = true; // Maximize will be done at onload window event

 this.useLeft = x[0] == "l";
 this.useTop = y[0] == "t";

 this.element.setStyle(this.useLeft ?{left: x[1]}:{right: x[1]});
 this.element.setStyle(this.useTop ?{top: y[1]}:{bottom: y[1]});
}
},

 getId: function(){
 return this.element.id;
},

 setDestroyOnClose: function(){
 Object.extend(this.options.hideEffectOptions,{afterFinish: this.destroy.bind(this)});
 this.destroyOnClose = true;
},

 _initDrag: function(event){

 this.pointer = [Event.pointerX(event), Event.pointerY(event)];

 if (Event.element(event) == this.sizer){
 this.doResize = true;
 this.widthOrg = this.width;
 this.heightOrg = this.height;
 this.bottomOrg = parseFloat(this.element.getStyle('bottom'));
 this.rightOrg = parseFloat(this.element.getStyle('right'));
 Windows.notify("onStartResize", this);
}
 else{
 this.doResize = false;

 var closeButton = $(this.getId() + '_close');
 if (closeButton && Position.within(closeButton, this.pointer[0], this.pointer[1])) 
 return;

 this.toFront();

 if (! this.options.draggable) 
 return;
 Windows.notify("onStartMove", this);
}

 Event.observe(document, "mouseup", this.eventMouseUp, false);
 Event.observe(document, "mousemove", this.eventMouseMove, false);

 WindowUtilities.disableScreen('__invisible__', '__invisible__');

 document.body.ondrag = function (){return false;};
 document.body.onselectstart = function (){return false;};
 
 Event.stop(event);
},

 _updateDrag: function(event){
 var pointer = [Event.pointerX(event), Event.pointerY(event)]; 
 var dx = pointer[0] - this.pointer[0];
 var dy = pointer[1] - this.pointer[1];

 if (this.doResize){
 this.setSize(this.widthOrg + dx , this.heightOrg + dy);
 
 dx = this.width - this.widthOrg
 dy = this.height - this.heightOrg

 if (! this.useLeft) 
 this.element.setStyle({right: (this.rightOrg -dx) + 'px'});

 if (! this.useTop) 
 this.element.setStyle({bottom: (this.bottomOrg -dy) + 'px'});
}

 else{
 this.pointer = pointer;
 
 if (this.useLeft) 
 this.element.setStyle({left: parseFloat(this.element.getStyle('left')) + dx + 'px'});
 else 
 this.element.setStyle({right: parseFloat(this.element.getStyle('right')) - dx + 'px'});
 
 if (this.useTop) 
 this.element.setStyle({top: parseFloat(this.element.getStyle('top')) + dy + 'px'});
 else 
 this.element.setStyle({bottom: parseFloat(this.element.getStyle('bottom')) - dy + 'px'});
}
 if (this.iefix) 
 this._fixIEOverlapping(); 
 
 this._removeStoreLocation();
 Event.stop(event);
},

 _endDrag: function(event){

 WindowUtilities.enableScreen('__invisible__');
 
 if (this.doResize)
 Windows.notify("onEndResize", this);
 else
 Windows.notify("onEndMove", this);

 Event.stopObserving(document, "mouseup", this.eventMouseUp,false);
 Event.stopObserving(document, "mousemove", this.eventMouseMove, false);

 this._saveCookie()

 Event.stop(event);

 document.body.ondrag = null;
 document.body.onselectstart = null;
},

 _keyPress: function(event){

},

 _createWindow: function(id){
 var className = this.options.className;
 var win = document.createElement("div");
 win.setAttribute('id', id);
 win.className = "dialog";

 var content;
 if (this.options.url)
 content= "<iframe name=\"" + id + "_content\" id=\"" + id + "_content\" src=\"" + this.options.url + "\"> </iframe>";
 else
 content ="<div id=\"" + id + "_content\" class=\"" +className + "_content\"> </div>";
 
 var closeDiv = this.options.closable ? "<div class='"+ className +"_close' id='"+ id +"_close' onmouseup='Windows.close(\""+ id +"\")'> </div>" : "";
 var minDiv = this.options.minimizable ? "<div class='"+ className + "_minimize' id='"+ id +"_minimize' onmouseup='Windows.minimize(\""+ id +"\")'> </div>" : "";
 var maxDiv = this.options.maximizable ? "<div class='"+ className + "_maximize' id='"+ id +"_maximize' onmouseup='Windows.maximize(\""+ id +"\")'> </div>" : "";
 var seAttributes = this.options.resizable ? "class='" + className + "_sizer' id='" + id + "_sizer'" : "class='" + className + "_se'";
 
 if (id=="photogallery2_window"){
 win.innerHTML = closeDiv + minDiv + maxDiv + "\
 <div id='"+ id +"_row1' class=\"top table_window\"><div id='"+ id +"_top'></div></div>\
 </table>\
 <table id='"+ id +"_row2' class=\"mid table_window\">\
 <tr>\
 <td class='"+ className +"_w'></td>\
 <td id='"+ id +"_table_content' class='"+ className +"_content' valign='top'>"+ content +"</td>\
 <td class='"+ className +"_e'></td>\
 </tr>\
 </table>\
 <div id='"+ id +"_row3' class=\"top table_window\"><div id='"+ id +"_bottom'></div></div>\
 ";
}
 else{
 win.innerHTML = closeDiv + minDiv + maxDiv + "\
 <table id='"+ id +"_row1' class=\"top table_window\">\
 <tr>\
 <td class='"+ className +"_nw'>&nbsp;</td>\
 <td class='"+ className +"_n'><div id='"+ id +"_top' class='"+ className +"_title title_window'>"+ this.options.title +"</div></td>\
 <td class='"+ className +"_ne'>&nbsp;</td>\
 </tr>\
 </table>\
 <table id='"+ id +"_row2' class=\"mid table_window\">\
 <tr>\
 <td class='"+ className +"_w'></td>\
 <td id='"+ id +"_table_content' class='"+ className +"_content' valign='top'>"+ content +"</td>\
 <td class='"+ className +"_e'></td>\
 </tr>\
 </table>\
 <table id='"+ id +"_row3' class=\"bot table_window\">\
 <tr>\
 <td class='"+ className +"_sw'>&nbsp;</td>\
 <td class='"+ className +"_s'><div id='"+ id +"_bottom' class='status_bar'>&nbsp;</div></td>\
 <td " + seAttributes + ">&nbsp;</td>\
 </tr>\
 </table>\
 ";
}
 Element.hide(win);
 this.options.parent.insertBefore(win, this.options.parent.firstChild);
 Event.observe($(id + "_content"), "load", this.options.onload);
 return win;
},

 setLocation: function(top, left){
 if (top < 0)
 top = 0;
 if (left < 0)
 left= 0
 this.element.setStyle({top: top + 'px'});
 this.element.setStyle({left: left + 'px'});
 this.useLeft = true;
 this.useTop = true;
},

 getSize: function(){
 return{width: this.width, height: this.height};
},

 setSize: function(width, height){
 width = parseFloat(width);
 height = parseFloat(height);

 if (width < this.options.minWidth)
 width = this.options.minWidth;

 if (height < this.options.minHeight)
 height = this.options.minHeight;
 
 if (this.options. maxHeight && height > this.options. maxHeight)
 height = this.options. maxHeight;

 if (this.options. maxWidth && width > this.options. maxWidth)
 width = this.options. maxWidth;

 this.width = width;
 this.height = height;
 this.element.setStyle({width: width + this.widthW + this.widthE + "px"})
 this.element.setStyle({height: height + this.heightN + this.heightS + "px"})

 var content = $(this.element.id + '_content')
 content.setStyle({height: height + 'px'});
 content.setStyle({width: width + 'px'});
},
 
 updateHeight: function(){
 this.setSize(this.width, this.content.scrollHeight)
},
 
 updateWidth: function(){
 this.setSize(this.content.scrollWidth, this.height)
},

 toFront: function(){
 this.setZIndex(Windows.maxZIndex + 20);
 Windows.notify("onFocus", this);
},

 show: function(modal){
 if (modal){
 WindowUtilities.disableScreen(this.options.className, 'overlay_modal', this.getId());
 this.modal = true; 
 this.setZIndex(Windows.maxZIndex + 20);
 Windows.unsetOverflow(this);
 Event.observe(document, "keypress", this.eventKeyPress); 
}

 if (this.oldStyle)
 this.getContent().setStyle({overflow: this.oldStyle});
 
 if (! this.width || !this.height){
 var size = WindowUtilities._computeSize(this.content.innerHTML, this.content.id, this.width, this.height, 0)
 if (this.height)
 this.width = size + 5
 else
 this.height = size + 5
}

 this.setSize(this.width, this.height);
 if (this.centered)
 this._center(this.centerTop, this.centerLeft); 
 
 if (this.options.showEffect != Element.show && this.options.showEffectOptions )
 this.options.showEffect(this.element, this.options.showEffectOptions); 
 else
 this.options.showEffect(this.element); 

 this._checkIEOverlapping();
 Windows.notify("onShow", this); 
},

 showCenter: function(modal, top, left){
 this.centered = true;
 this.centerTop = top;
 this.centerLeft = left;

 this.show(modal);
},
 
 isVisible: function(){
 return this.element.visible();
},
 
 _center: function(top, left){
 var windowScroll = WindowUtilities.getWindowScroll(); 
 var pageSize = WindowUtilities.getPageSize(); 

 if (!top)
 top = (pageSize.windowHeight - (this.height + this.heightN + this.heightS))/2;
 top += windowScroll.top
 
 if (!left)
 left = (pageSize.windowWidth - (this.width + this.widthW + this.widthE))/2;
 left += windowScroll.left 
 
 this.setLocation(top, left);
 this.toFront();
},
 
 _recenter: function(event){
 if (this.modal){
 var pageSize = WindowUtilities.getPageSize();

 if ($('overlay_modal')){
 $('overlay_modal').style.height = (pageSize.pageHeight + 'px');
 $('overlay_modal').style.width = (pageSize.pageWidth + 'px');
}
 if (this.centered)
 this._center(this.centerTop, this.centerLeft); 
}
},

 hide: function(){
 if (this.modal){
 WindowUtilities.enableScreen();
 Windows.resetOverflow();
 Event.stopObserving(document, "keypress", this.eventKeyPress); 
}

 this.oldStyle = this.getContent().getStyle('overflow') || "auto"
 this.getContent().setStyle({overflow: "hidden"});

 this.options.hideEffect(this.element, this.options.hideEffectOptions); 

 if(this.iefix) 
 this.iefix.hide();
 Windows.notify("onHide", this);
},

 minimize: function(){
 var r2 = $(this.getId() + "_row2");
 var dh = r2.getDimensions().height;
 
 if (r2.visible()){
 var h = this.element.getHeight() - dh
 r2.hide()
 this.element.setStyle({height: h + "px"})
 if (! this.useTop){
 var bottom = parseFloat(this.element.getStyle('bottom'));
 this.element.setStyle({bottom: (bottom + dh) + 'px'});
}
}
 else{
 var h = this.element.getHeight() + dh;
 this.element.setStyle({height: h + "px"})
 if (! this.useTop){
 var bottom = parseFloat(this.element.getStyle('bottom'));
 this.element.setStyle({bottom: (bottom - dh) + 'px'});
}
 r2.show();
 
 this.toFront();
}
 Windows.notify("onMinimize", this);

 this._saveCookie()
},
 
 maximize: function(){
 if (this.storedLocation != null){
 this._restoreLocation();
 if(this.iefix) 
 this.iefix.hide();
}
 else{
 this._storeLocation();
 Windows.unsetOverflow(this);
 
 var windowScroll = WindowUtilities.getWindowScroll();
 var pageSize = WindowUtilities.getPageSize(); 

 this.element.setStyle(this.useLeft ?{left: windowScroll.left}:{right: windowScroll.left});
 this.element.setStyle(this.useTop ?{top: windowScroll.top}:{bottom: windowScroll.top});

 this.setSize(pageSize.windowWidth - this.widthW - this.widthE, pageSize.windowHeight - this.heightN - this.heightS)
 this.toFront();
 if (this.iefix) 
 this._fixIEOverlapping(); 
}
 Windows.notify("onMaximize", this);

 this._saveCookie()
},
 
 isMinimized: function(){
 var r2 = $(this.getId() + "_row2");
 return !r2.visible();
},
 
 isMaximized: function(){
 return (this.storedLocation != null);
},
 
 setOpacity: function(opacity){
 if (Element.setOpacity)
 Element.setOpacity(this.element, opacity);
},
 
 setZIndex: function(zindex){
 this.element.setStyle({zIndex: zindex});
 Windows.updateZindex(zindex, this);
},

 setTitle: function(newTitle){
 if (!newTitle || newTitle == "") 
 newTitle = "&nbsp;";
 
 Element.update(this.element.id + '_top', newTitle);
},

 setStatusBar: function(element){
 var statusBar = $(this.getId() + "_bottom");

 if (typeof(element) == "object"){
 if (this.bottombar.firstChild)
 this.bottombar.replaceChild(element, this.bottombar.firstChild);
 else
 this.bottombar.appendChild(element);
}
 else
 this.bottombar.innerHTML = element;
},

 _checkIEOverlapping: function(){
 if(!this.iefix && (navigator.appVersion.indexOf('MSIE')>0) && (navigator.userAgent.indexOf('Opera')<0) && (this.element.getStyle('position')=='absolute')){
 new Insertion.After(this.element.id, '<iframe id="' + this.element.id + '_iefix" '+ 'style="display:none;position:absolute;filter:progid:DXImageTransform.Microsoft.Alpha(opacity=0);" ' + 'src="javascript:false;" frameborder="0" scrolling="no"></iframe>');
 this.iefix = $(this.element.id+'_iefix');
}
 if(this.iefix) 
 setTimeout(this._fixIEOverlapping.bind(this), 50);
},

 _fixIEOverlapping: function(){
 Position.clone(this.element, this.iefix);
 this.iefix.style.zIndex = this.element.style.zIndex - 1;
 this.iefix.show();
},
 
 _getWindowBorderSize: function(event){

 var div = this._createHiddenDiv(this.options.className + "_n")
 this.heightN = Element.getDimensions(div).height; 
 div.parentNode.removeChild(div)

 var div = this._createHiddenDiv(this.options.className + "_s")
 this.heightS = Element.getDimensions(div).height; 
 div.parentNode.removeChild(div)

 var div = this._createHiddenDiv(this.options.className + "_e")
 this.widthE = Element.getDimensions(div).width; 
 div.parentNode.removeChild(div)

 var div = this._createHiddenDiv(this.options.className + "_w")
 this.widthW = Element.getDimensions(div).width;
 div.parentNode.removeChild(div);

 if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
 this.setSize(this.width, this.height);
 if (this.doMaximize)
 this.maximize();
 if (this.doMinimize)
 this.minimize();
},
 
 _createHiddenDiv: function(className){
 var objBody = document.getElementsByTagName("body").item(0);
 var win = document.createElement("div");
 win.setAttribute('id', this.element.id+ "_tmp");
 win.className = className;
 win.style.display = 'none'
 win.innerHTML = ''
 objBody.insertBefore(win, objBody.firstChild) 
 return win
},
 
 _storeLocation: function(){
 if (this.storedLocation == null){
 this.storedLocation ={useTop: this.useTop, useLeft: this.useLeft, 
 top: this.element.getStyle('top'), bottom: this.element.getStyle('bottom'),
 left: this.element.getStyle('left'), right: this.element.getStyle('right'),
 width: this.width, height: this.height};
}
},
 
 _restoreLocation: function(){
 if (this.storedLocation != null){
 this.useLeft = this.storedLocation.useLeft;
 this.useTop = this.storedLocation.useTop;
 
 this.element.setStyle(this.useLeft ?{left: this.storedLocation.left}:{right: this.storedLocation.right});
 this.element.setStyle(this.useTop ?{top: this.storedLocation.top}:{bottom: this.storedLocation.bottom});
 this.setSize(this.storedLocation.width, this.storedLocation.height);
 
 Windows.resetOverflow();
 this._removeStoreLocation();
}
},
 
 _removeStoreLocation: function(){
 this.storedLocation = null;
},
 
 _saveCookie: function(){
 if (this.cookie){
 var value = "";
 if (this.useLeft)
 value += "l:" + (this.storedLocation ? this.storedLocation.left : this.element.getStyle('left'))
 else
 value += "r:" + (this.storedLocation ? this.storedLocation.right : this.element.getStyle('right'))
 if (this.useTop)
 value += ",t:" + (this.storedLocation ? this.storedLocation.top : this.element.getStyle('top'))
 else
 value += ",b:" + (this.storedLocation ? this.storedLocation.bottom :this.element.getStyle('bottom'))
 
 value += "," + (this.storedLocation ? this.storedLocation.width : this.width);
 value += "," + (this.storedLocation ? this.storedLocation.height : this.height);
 value += "," + this.isMinimized();
 value += "," + this.isMaximized();
 WindowUtilities.setCookie(value, this.cookie)
}
}
};

var Windows ={
 windows: [],
 observers: [],
 focusedWindow: null,
 maxZIndex: 0,

 addObserver: function(observer){
 this.removeObserver(observer);
 this.observers.push(observer);
},
 
 removeObserver: function(observer){
 this.observers = this.observers.reject( function(o){return o==observer});
},
 
 notify: function(eventName, win){// onStartResize(), onEndResize(), onStartMove(), onEndMove(), onClose(), onDestroy(), onMinimize(), onMaximize(), onHide(), onShow(), onFocus()
 this.observers.each( function(o){if(o[eventName]) o[eventName](eventName, win);});
},

 getWindow: function(id){
 return this.windows.detect(function(d){return d.getId() ==id});
},

 getFocusedWindow: function(){
 return this.focusedWindow;
},

 register: function(win){
 this.windows.push(win);
},

 unregister: function(win){
 this.windows = this.windows.reject(function(d){return d==win});
}, 

 close: function(id){
 var win = this.getWindow(id);

 if (win){
 if (win.getDelegate() && ! win.getDelegate().canClose(win)) 
 return;
 if ($(id + "_close"))
 $(id + "_close").onclick = null;
 if ($(id + "_minimize"))
 $(id + "_minimize").onclick = null; 
 if ($(id + "_maximize"))
 $(id + "_maximize").onclick = null; 
 
 this.notify("onClose", win);
 win.hide();
}
},

 closeAll: function(){
 this.windows.each( function(w){Windows.close(w.getId())});
},

 minimize: function(id){
 var win = this.getWindow(id)
 if (win)
 win.minimize();
},

 maximize: function(id){
 var win = this.getWindow(id)
 if (win)
 win.maximize();
},
 
 unsetOverflow: function(except){
 this.windows.each(function(d){d.oldOverflow = d.getContent().getStyle("overflow") || "auto" ; d.getContent().setStyle({overflow: "hidden"})});
 if (except && except.oldOverflow)
 except.getContent().setStyle({overflow: except.oldOverflow});
},

 resetOverflow: function(){
 this.windows.each(function(d){if (d.oldOverflow) d.getContent().setStyle({overflow: d.oldOverflow})});
},

 updateZindex: function(zindex, win){
 if (zindex > this.maxZIndex)
 this.maxZIndex = zindex;
 this.focusedWindow = win;
}
};

var Dialog ={
 dialogId: null,
 win: null,
 onCompleteFunc: null,
 callFunc: null, 
 parameters: null, 
 
 confirm: function(content, parameters){

 if (typeof content != "string"){
 Dialog._runAjaxRequest(content, parameters, Dialog.confirm);
 return 
}
 
 parameters = parameters ||{};
 var okLabel = parameters.okLabel ? parameters.okLabel : "Ok";
 var cancelLabel = parameters.cancelLabel ? parameters.cancelLabel : "Cancel";

 var windowParam = parameters.windowParameters ||{};
 windowParam.className = windowParam.className || "alert";

 okButtonClass = "class ='" + (parameters.buttonClass ? parameters.buttonClass + " " : "") + " ok_button'" 
 cancelButtonClass = "class ='" + (parameters.buttonClass ? parameters.buttonClass + " " : "") + " cancel_button'" 
 var content = "\
 <div class='" + windowParam.className + "_message'>" + content + "</div>\
 <div class='" + windowParam.className + "_buttons'>\
 <input type='button' value='" + okLabel + "' onclick='Dialog.okCallback()'" + okButtonClass + "/>\
 <input type='button' value='" + cancelLabel + "' onclick='Dialog.cancelCallback()' " + cancelButtonClass + "/>\
 </div>\
 ";
 this._openDialog(content, parameters)
 return this.win
},
 
 alert: function(content, parameters){

 if (typeof content != "string"){
 Dialog._runAjaxRequest(content, parameters, Dialog.alert);
 return 
}
 
 parameters = parameters ||{};
 var okLabel = parameters.okLabel ? parameters.okLabel : "Ok";

 var windowParam = parameters.windowParameters ||{};
 windowParam.className = windowParam.className || "alert";

 okButtonClass = "class ='" + (parameters.buttonClass ? parameters.buttonClass + " " : "") + " ok_button'" 
 var content = "\
 <div class='" + windowParam.className + "_message'>" + content + "</div>\
 <div class='" + windowParam.className + "_buttons'>\
 <input type='button' value='" + okLabel + "' onclick='Dialog.okCallback()'" + okButtonClass + "/>\
 </div>";
 return this._openDialog(content, parameters)
},
 
 info: function(content, parameters){

 if (typeof content != "string"){
 Dialog._runAjaxRequest(content, parameters, Dialog.info);
 return 
}
 
 parameters = parameters ||{};
 parameters.windowParameters = parameters.windowParameters ||{};
 
 var className = parameters.windowParameters.className || "alert";

 var content = "<div id='modal_dialog_message' class='" + className + "_message'>" + content + "</div>";
 if (parameters.showProgress)
 content += "<div id='modal_dialog_progress' class='" + className + "_progress'> </div>";

 parameters.windowParameters.ok = null;
 parameters.windowParameters.cancel = null;
 parameters.windowParameters.className = className;
 
 return this._openDialog(content, parameters)
},
 
 setInfoMessage: function(message){
 $('modal_dialog_message').update(message);
},
 
 closeInfo: function(){
 Windows.close(this.dialogId);
},
 
 _openDialog: function(content, parameters){

 if (this.win) 
 this.win.destroy();

 if (! parameters.windowParameters.height && ! parameters.windowParameters.width){
 parameters.windowParameters.width = WindowUtilities.getPageSize().pageWidth / 2;
}
 this.dialogId = parameters.id ? parameters.id : 'modal_dialog'

 if (! parameters.windowParameters.height || ! parameters.windowParameters.width){
 var size = WindowUtilities._computeSize(content, this.dialogId, parameters.windowParameters.width, parameters.windowParameters.height)
 if (parameters.windowParameters.height)
 parameters.windowParameters.width = size + 5
 else
 parameters.windowParameters.height = size + 5
}
 var windowParam = parameters && parameters.windowParameters ? parameters.windowParameters :{};
 windowParam.resizable = windowParam.resizable || false;
 
 windowParam.effectOptions = windowParam.effectOptions ||{duration: 1};
 windowParam.minimizable = false;
 windowParam.maximizable = false;
 windowParam.closable = false;
 this.win = new Window(this.dialogId, windowParam);
 this.win.getContent().innerHTML = content;
 this.win.showCenter(true, parameters.top, parameters.left); 
 
 this.win.cancelCallback = parameters.cancel;
 this.win.okCallback = parameters.ok;
 
 return this.win; 
},
 
 _getAjaxContent: function(originalRequest){
 Dialog.callFunc(originalRequest.responseText, Dialog.parameters)
},
 
 _runAjaxRequest: function(message, parameters, callFunc){
 if (message.options == null)
 message.options ={}
 Dialog.onCompleteFunc = message.options.onComplete;
 Dialog.parameters = parameters;
 Dialog.callFunc = callFunc;
 
 message.options.onComplete = Dialog._getAjaxContent;
 new Ajax.Request(message.url, message.options);
},
 
 okCallback: function(){
 if (!this.win.okCallback || this.win.okCallback(this.win))
 this.win.hide();
},

 cancelCallback: function(){
 this.win.hide();
 if (this.win.cancelCallback)
 this.win.cancelCallback(this.win);
}
}

var isIE = navigator.appVersion.match(/MSIE/) == "MSIE";

var WindowUtilities ={

 getWindowScroll: function(){
 var w = window;
 var T, L, W, H;
 with (w.document){
 if (w.document.documentElement && documentElement.scrollTop){
 T = documentElement.scrollTop;
 L = documentElement.scrollLeft;
}else if (w.document.body){
 T = body.scrollTop;
 L = body.scrollLeft;
}
 if (w.innerWidth){
 W = w.innerWidth;
 H = w.innerHeight;
}else if (w.document.documentElement && documentElement.clientWidth){
 W = documentElement.clientWidth;
 H = documentElement.clientHeight;
}else{
 W = body.offsetWidth;
 H = body.offsetHeight
}
}
 return{top: T, left: L, width: W, height: H};
 
}, 






 getPageSize: function(){
 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;
}
 var pageHeight, pageWidth;

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

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

 return{pageWidth: pageWidth ,pageHeight: pageHeight , windowWidth: windowWidth, windowHeight: windowHeight};
},

 disableScreen: function(className, overlayId, contentId){
 WindowUtilities.initLightbox(overlayId, className);
 var objBody = document.getElementsByTagName("body").item(0);

 var objOverlay = $(overlayId);

 var pageSize = WindowUtilities.getPageSize();

 if (contentId && isIE){
 $$('select').each(function(element){element.style.visibility = "hidden"});
 $$('#'+contentId+' select').each(function(element){element.style.visibility = "visible"});
}

 objOverlay.style.height = (pageSize.pageHeight + 'px');
 objOverlay.style.width = (pageSize.windowWidth + 'px');
 objOverlay.style.display = 'block'; 
},

 enableScreen: function(id){
 id = id || 'overlay_modal'
 var objOverlay = $(id);
 if (objOverlay){

 objOverlay.style.display = 'none';

 if (isIE){
 $$('select').each(function(element){element.style.visibility = "visible"});
}
 objOverlay.parentNode.removeChild(objOverlay);
}
},





 initLightbox: function(id, className){

 if ($(id)){
 Element.setStyle(id,{zIndex: Windows.maxZIndex + 10});
}

 else{
 var objBody = document.getElementsByTagName("body").item(0);
 var objOverlay = document.createElement("div");
 objOverlay.setAttribute('id', id);
 objOverlay.className = "overlay_" + className
 objOverlay.style.display = 'none';
 objOverlay.style.position = 'absolute';
 objOverlay.style.top = '0';
 objOverlay.style.left = '0';
 objOverlay.style.zIndex = Windows.maxZIndex + 10;
 objOverlay.style.width = '100%';
 objBody.insertBefore(objOverlay, objBody.firstChild);
}
},
 
 setCookie: function(value, parameters){
 document.cookie= parameters[0] + "=" + escape(value) +
 ((parameters[1]) ? "; expires=" + parameters[1].toGMTString() : "") +
 ((parameters[2]) ? "; path=" + parameters[2] : "") +
 ((parameters[3]) ? "; domain=" + parameters[3] : "") +
 ((parameters[4]) ? "; secure" : "");
},

 getCookie: function(name){
 var dc = document.cookie;
 var prefix = name + "=";
 var begin = dc.indexOf("; " + prefix);
 if (begin == -1){
 begin = dc.indexOf(prefix);
 if (begin != 0) return null;
}else{
 begin += 2;
}
 var end = document.cookie.indexOf(";", begin);
 if (end == -1){
 end = dc.length;
}
 return unescape(dc.substring(begin + prefix.length, end));
},
 
 _computeSize: function(content, id, width, height, margin){
 if (margin == null)
 margin = 5;

 var objBody = document.getElementsByTagName("body").item(0);
 var tmpObj = document.createElement("div");
 tmpObj.setAttribute('id', id);
 
 if (height)
 tmpObj.style.height = height + "px"
 else
 tmpObj.style.width = width + "px"
 
 tmpObj.style.position = 'absolute';
 tmpObj.style.top = '0';
 tmpObj.style.left = '0';
 tmpObj.style.display = 'none';

 tmpObj.innerHTML = content;
 objBody.insertBefore(tmpObj, objBody.firstChild);
 
 var size;
 if (height)
 size = $(id).getDimensions().width + margin;
 else
 size = $(id).getDimensions().height + margin;
 objBody.removeChild(tmpObj);
 
 return size;
}
}



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

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

 return str;
}

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

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

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

if (typeof(console)=="undefined"){
 console ={};
 console.log = printfire;
}else{
 printfire = console.log;
}

function encode_utf8(rohtext){

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

 var c=rohtext.charCodeAt(n);

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

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

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

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

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

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

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

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

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

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



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

 
String.prototype.priceFormat = function(){
 splitext = this.split("");
 revertext = splitext.reverse();
 var html ="";
 for(var i=0;i<revertext.length;i++){
 if( (i%3)==0 && i!=0 ) html += " ";
 html += revertext[i];
}
 var htmlsplit = html.split("");
 var html = htmlsplit.reverse();
 reversed = html.join("");
 return reversed;
}

var browser ={

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

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

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

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


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

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

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

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

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



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

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


Popup.prototype.openCenteredWindow=function(){

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

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


 var pd=popup.document;




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


 popup.focus();
}





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

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

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

 this.openCenteredWindow();
 
}

PopupHTML.prototype.openCenteredWindow=function(){








 var tmp="";

 this.name=this.href;

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


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


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


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


 new Popup(this);

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

 new PopupHTML(this);

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

function init_treemenu(divID)
{

 if (!document.getElementsByTagName) return; 

 var wtm_cookie='openedIDs';

 var buttonclass='wtmbutton';

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

 openedIDs=new Array();

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

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



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

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

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

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

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

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


 openedIDs[openedIDs.length]=i;
}
}





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

 list.insertBefore(newimg, list.firstChild);


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

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

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


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


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


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


 var li=this.parentNode;

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

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

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

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

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

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





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

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

}// end of w_treemenu_Init


function miracleSelector(id, submitid){



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

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


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

this.initPanels();

this.initButtons();

this.initSubmit();

}


miracleSelector.prototype.Move = function(str){

}


miracleSelector.prototype.initPanels = function(){
 var panels=this.fieldset.getElementsByTagName("select");
 for (var i=0; i<panels.length; i++){
 this.panels[ panels[i].className ] = panels[i];

}
 
 var buttons=this.buttons;
 this.panels["left"].onfocus=function(){

 buttons["add"].style.display="inline";
}
 this.panels["right"].onfocus=function(){

 buttons["remove"].style.display="inline";
}
}

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

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

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

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

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


miracleSelector.prototype.moveOptions = function(from, to){

 var selected=getSelectedOptions(this.panels[from]);
 var selected_ids=new Array();

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

 for (var i=0; i<selected.length; i++){

 var si=selected[i]-i;
 var option=this.panels[from][si];

 selected_ids[i]=option.value;
 
 var clone=option.cloneNode(true);
 this.panels[from].removeChild(option);
 var firstbigger=getFirstBiggerOption(this.panels[to], option.firstChild.nodeValue);



 this.panels[to].appendChild(clone, firstbigger);

 
 
}
 
 var module=$('target_module');
 
 var destination_key=$('target_destination_key');

 if (destination_key){
 var destination = destination_key.value;
}

 handleUDRM(selected_ids,todo,module.value,destination);





}



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


addEvent(window, 'load', init_tabs);

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


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


function tabBox(name){

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

}

tabBox.prototype.addTabPanel = function(panel){

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

tabBox.prototype.addTabForPanel = function(panelName){

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

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

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


addEvent(window, 'load', initPlugIns);

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

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

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


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


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

}
}
}

function getBlockId(){

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

 return tmp;
}

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

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

function initSwfUpload(){
 var elements=new Array();
 var fups=new Array();
 var j=0;

 elements=document.getElementsByClassName("swf_file_upload");

 if( elements.length && isNaN(flashVersion) ){//flashVersion változó swf_upload.js-ben van
 elements[0].innerHTML = "Nincs Flash lejátszó telepítve, vagy a plugin ki lett kapcsolva.";
 elements[0].style.display = "block";
 return;
}

 for (var i=0; i<elements.length; i++){
 classname=elements[i].id.substr(0,elements[i].id.length-3);
 temp=document.getElementById(classname+"_hidden_id").name;
 maxfile=elements[i].getAttribute("maxfile");
 if (!maxfile) maxfile=1;
 maxsize=elements[i].getAttribute("maxsize");
 if (!maxsize) maxsize=102400;
 
 window[classname] = new SWFUpload({

 upload_url: "/upload.php?hidden_name="+classname+"_hidden_id&sesid="+temp, // Relative to the SWF file (or you can use absolute paths)
 post_params:{"PHPSESSID" : 1},
 hidden_id: classname+"_hidden_id",

 file_size_limit : maxsize, // "102400", // 100MB
 file_types : "*.*",
 file_types_description : "All Files",
 file_upload_limit : maxfile,
 file_queue_limit : "0",

 

 button_image_url : "/images/miracle/SWFUploader2.2UploadButton.png",
 button_width: 61,
 button_height: 22,


 file_dialog_start_handler : fileDialogStart,
 file_queued_handler : fileQueued,
 file_queue_error_handler : fileQueueError,
 file_dialog_complete_handler : fileDialogComplete,
 upload_start_handler : uploadStart,
 upload_progress_handler : uploadProgress,
 upload_error_handler : uploadError,
 upload_complete_handler : uploadComplete,
 file_complete_handler : fileComplete,

 ui_container_id : classname+"_ui",


 debug: false
});

 if( flashVersion > 8 ){

 window[classname].flash_url = "/flash/swfupload2.swf"; // Relative to this file (or you can use absolute paths)

 var divs = $$("div.swf_file_upload");
 if( divs.length ){
 divs.each( function (div){
 div.style.display = "block";
});
}
}
 else{
 window[classname].flash_url = "/flash/swfupload.swf"; // Relative to this file (or you can use absolute paths)
}

 window[classname].customSettings.progressTarget = classname+"_progress"; // Add an additional setting that will later be used by the handler.
 window[classname].customSettings.cancelButtonId = classname+"_cancel"; // Add an additional setting that will later be used by the handler.
}

}
 
addEvent(window, "load", initSwfUpload);

var fileUpload=Class.create();
fileUpload.prototype ={

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

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

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

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

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

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

 return false; 
},

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

 getFileSize: function(filename){
 var tmp=Math.random()*1000;
 var iframe = document.createElement("iframe");
 var iframe = document.setAttribute("target");
 
 return tmp;
},

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

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

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

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

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

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

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


}

var miracleAjaxUpdater = Class.create();

miracleAjaxUpdater.prototype ={
 
 initialize: function(){


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

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

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

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

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

}


var miracleCheckbox = Class.create();

miracleCheckbox.prototype ={
 
 initialize: function(){

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


 this.checkboxes = document.getElementsByTagNameAndAttribute("input", "src", "/.+/");

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

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

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

},

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

}

var miracleForm = Class.create();

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

 init: function(){

 this.formAcceptNumeric();
 this.initAutoComplete();
 this.initAddress();
 this.initNumberGrouping();
 this.initCaptcha();

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

 autoFocus: function(){
 var f;
 if (
 (mp = document.getElementById("main_padding"))
 && (f = mp.getElementsByTagName("form")[0])
 ){
 Form.focusFirstElement(f);
}
},

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

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

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

 initNumberGrouping: function(){
 $A(document.getElementsByTagName("input")).each(function(element){
 if (element.getAttribute("type") == "text" && $(element).hasClassName("grouped")){
 element.style.textAlign = "right";
 element.style.paddingRight = "2px";
 element.observe("keyup", function(e){
 var _this = Event.element(e);
 var s = $N(parseInt(_this.value.toString().replace(/ /g, "")), "").toString().split('').reverse().join(''), r = ''; 
 for (var i = 0; i < s.length; i++){
 r += (i > 0 && i % 3 == 0 ? ' ' : '') + s.charAt(i);
}
 _this.value = r.split('').reverse().join('');
});
}
});
},

 initAddress: function(){
 this.address = Class.create();
 this.address.prototype ={
 initialize: function (fieldset){
 this.fieldset = fieldset;
 this.zipCode = document.getElementsByClassName("zipcode", fieldset).first();
 this.counties = document.getElementsByClassName("counties", fieldset).first();
 this.city = document.getElementsByClassName("city", fieldset).first();

 this.cities = document.getElementsByClassName("city", fieldset).first();
 
 this.streets = document.getElementsByClassName("street", fieldset).first();
 this.street_other = document.getElementsByClassName("street_other", fieldset).first();
 this.street_number = document.getElementsByClassName("street_number", fieldset).first();

 
 if (this.streets.value=="not_street"){
 this.street_number.disabled=1;
}
 
 if (this.counties.value>0){
}else{
 this.city.disabled = 1;
 this.streets.disabled = 1;
}
 
 if (this.cities.value!=0){
}else this.streets.disabled = 1;

 if ((this.streets.value!="other") || (this.streets.disabled==1)){
 this.street_other.value="NULL";
 this.street_other.style.disabled= 0;
 this.street_other.style.display ="none";
}
 

 Event.observe(this.counties, "change", this.updateCitiesByCountyId.bindAsEventListener(this));
 Event.observe(this.cities, "change", this.updateStreetsByCityIdAndStreet.bindAsEventListener(this));
 Event.observe(this.streets, "change", this.streetOtherOption.bindAsEventListener(this));
},

 resetOnce: function(event){
 var element = Event.element(event);
 if (element.value == element.getAttribute("value")){
 element.value = "";
}
},

 validateAddress: function(event){
 var t = this.streets[this.streets.selectedIndex].value.split("-");
 var streetId = t[0];
 var streetTypeId = t[1];
 var p ={
 city_id: this.city[this.city.selectedIndex].value,
 street_id: streetId,
 street_type_id: streetTypeId,
 street_number: parseInt(this.streetNumber.value)
};

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

 function(address){
 if (address.first().street_number){
 this.streetNumber.value = address.first().street_number;
}
}.bind(this)
 );
}else{
 this.streetNumber.value = $N(this.streetNumber.value, "");
}
},
 streetOtherOption : function(event){
 if (this.streets.options[this.streets.selectedIndex].value=="other"){
 this.street_other.value="";
 this.street_other.style.display="block";
 this.street_other.disabled=0;
}else{
 
 this.street_other.value="NULL";
 this.street_other.style.display="none";
 this.street_other.disabled=1;
}

 if (this.streets.options[this.streets.selectedIndex].value=="not_street"){
 
 
 this.street_number.disabled=1;
 if (this.street_number.value=="") this.street_number.value=Math.round((Math.random()*999)+1); 
}else{
 this.street_number.disabled=0;
}
 
},
 updateCities: function(event){
 var zipCode = Event.element(event);
 miracle.ajax("miracle", "get_cities_by_zipcode", 
{
 zipcode: zipCode.value
}, 

 function(cities){
 if (cities.length > 0){
 this.city.value = cities.first().option;
}

}.bind(this)
 );
},

 updateStreetsByCityIdAndStreet:function(event){
 this.streets.disabled=1;
 this.cityid=this.city.options[this.city.selectedIndex].value;
 miracle.ajax("miracle", "street_by_cityid", 
{
 city_id: this.cityid
 
}, 
 
 function(streets){
 if (streets.length!=0){
 miracle.form.updateSelect(this.streets, streets);
}
}.bind(this)
 );
 this.streets.disabled = 0;
},
 updateCitiesByCountyId: function(event){
 this.city.disabled = 1;
 this.streets.disabled = 1;
 miracle.ajax("miracle", "get_cities_by_county_id", 
{
 county_id: this.counties.options[this.counties.selectedIndex].value
}, 

 function(cities){
 var errors = document.getElementsByClassName("error", this.fieldset);
 if (cities.length > 0){

 if (errors.first()){
 this.fieldset.removeChild(errors.first());
}
 
 this.city = miracle.form.replaceWithSelect(this.city);
 
 miracle.form.updateSelect(this.city, cities);

 Event.observe(this.city, "change", this.updateZipCode.bindAsEventListener(this));
 this.updateZipCode();
 this.city.disabled = 0;

}else{

}
}.bind(this)
 );
},
 
 updateZipCode: function(event){

 this.cityId = this.city.options[this.city.selectedIndex].value;

 if (this.counties.options[this.counties.selectedIndex].value!=5){
 miracle.ajax("miracle", "get_zipcode_by_city", 
{
 city_id: this.cityId
}, 

 function(zipcode){
 this.zipCode.value=zipcode;
}.bind(this)
 );
}else this.zipCode.value='';
 this.streets.disabled=1;
 
 miracle.ajax("miracle", "street_by_cityid", 
{
 city_id: this.cityId
 
}, 
 
 function(streets){
 if (streets.length!=0){
 miracle.form.updateSelect(this.streets, streets);

}
}.bind(this)
 );
 this.streets.disabled=0;

}
 
 
}

},

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

 autoSubmit: function(event){
 var form = Event.findElement(event || window.event, "form");
 var forbidden = Form.getElements(form).pluck("name");
 $H(document.location.search.toQueryParams()).each(function(array){
 if (forbidden.indexOf(array[0]) < 0){
 var input = Builder.node("input",{
 type: "hidden",
 name: array[0],
 value: (array[1] ? array[1] : "")
});
 form.appendChild(input);
}
});
 form.submit();

},

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

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

 alert("WHICH " + event.which);
 alert("KEYCODE" + event.keyCode);
 alert("CHARCODE" + event.charCode);

 if (event.charCode == 0){


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

}else{

}
}
 );
},

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

 var keyCode = (event.which) ? event.which : event.keyCode;

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

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

 return returnValue; 
}
 );
},

 CCCC_formAcceptNumeric: function(){
 return true;
 if (!document.getElementsByTagName("input")) return false;
 miracle.addEventSelectorRule(
 "input[accept=numeric]:change", function(input, event){

 if (parseInt(input.value, 10) != input.value){
 input.value = 
 input.miraclePreviousValue ? input.miraclePreviousValue : "";
 Event.stop(event);
}else{
 input.miraclePreviousValue = input.value;
}
}
 );
},

 formAcceptNumeric: function(){
 if (!document.getElementsByTagName("input")) return false;



 $$("input[accept=numeric]").each(function(input){
 input.observe("keypress", function(event){
 var stop = miracle.form.maskInput(input, event, "9^");
 if (stop){
 Event.stop(event);
 stop = false;
}
});
});

 miracle.addEventSelectorRule(
 "#immo_profi_crm_company_edit_account_number:keypress", function(input, event){
 miracle.form.maskInput(input, event, "99999999-99999999-99999999");
}
 );

},


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

 getValue: function(element){



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

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

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

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

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

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

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

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

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

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

 isRequiredFieldsFilled: function(parent){

 var tmp = this.getRequiredFields(parent).all(function(element){
 var value = miracle.form.getValue(element);
 if (!value){
 miracle.form.errorForField(element, "td", "add");

}else{
 miracle.form.errorForField(element, "td", "remove");
}
 return value;
});

 return tmp;
},

 limitTextArea: function(id, limit){
 if (!(t = document.getElementById(id))) return false;
 var c = document.createElement("div");
 var cs = c.style;
 cs.position = "absolute";
 tPos = miracle.findPos(t);
 cs.left = tPos[0] - 10 + "px";
 cs.top = tPos[1] - 10 + "px";
 Element.addClassName(c, "textarea_counter");
 document.getElementsByTagName("body")[0].appendChild(c);
 c.innerHTML = $N(t.value.length);
 var keyCodes = [8,33,34,36,35,37,38,39,40,46];
 Event.observe(t, "keydown", function(e){
 var k = (e.which + 1 || e.keyCode + 1) - 1 || 0;
 this.value = this.value.substring(0, 40);
 if (this.value.length > limit && !keyCodes.member(k)){
 Event.stop(e);
}
}.bindAsEventListener(t));

 Event.observe(t, "keyup", function(e){
 this.value = this.value.substring(0, 40);
 c.innerHTML = this.value.length;
}.bindAsEventListener(t));
},


 maskInput: function (f, e, m){
 e.key = (e.which + 1 || e.keyCode + 1) - 1 || 0;
 if (
 (document.protocol)
 && ($A([96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 15, 9, 37, 38, 39, 40, 46]).indexOf(e.key) != -1)
 ){
 return false;
}

 var patterns ={"1": /[A-Z]/i, "2": /[0-9]/, "4": /[A-y]/i, "8": /./};
 var rules ={"a": 3, "A": 7, "9": 2, "C":5, "c": 1, "*": 8};

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

 function _stop(){
 stop = true;
 return;
}

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

},


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

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




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



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


 return true;
},

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

 post: function(url){
 var form = Builder.node("form",{
 method: "post",
 action: url
});

 document.getElementsByTagName("body")[0].appendChild(form);
 form.submit();
},

 deleteLink: function(selector){
 $$(selector).each(function(element){
 Event.observe(element, "click", function(event){
 if (confirm(element.getAttribute("confirm"))){
 miracle.form.post(this.href);
}
 Event.stop(event);
}.bind(element));
}.bind(this));
},

 initCaptcha: function(){
 var button=document.getElementById("captcha_button");
 if (button){
 button.onclick=function(){
 var img=document.getElementById("captcha_img");
 img.src="/captcha.jpg?"+Math.random();
 return false;
}
}
}


}// end of class

var miracleTabs = Class.create();

Element._hide = function(element){

 Element.hide(element);
}

Element._show = function(element){

 Element.show(element);
 element.getElementsByClassName("flexcroll").each(function(scroll){
 if (typeof(scroll.scrollUpdate) == "function"){
 scroll.scrollUpdate();
}
});
}

miracleTabs.prototype ={

 initialize: function(){

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

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



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



 if (typeof(unFocus) == "object"){
 unFocus.History.addEventListener("historyChange", this.historyListener.bind(this));
 this.historyListener(unFocus.History.getCurrent());
}
},

 initializeContainer: function(container){

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

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

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

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

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


 panel.miracle ={
 id: i
};

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

}else{

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

}


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

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

 tabControlHTML = tabControlHTML + "</ul>";

 new Insertion.Top(container, tabControlHTML);

 container.tabControl = $(ulId);

 this.initializeTabControl(container);
 container.style.display = "block";
},

 initializeTabControl: function(tabContainer){

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


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

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

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

 switchTab: function(event){


 var source = Event.element(event);

 Event.stop(event);

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

 source.parentNode.firstChild.blur();

 return false;
}

 var control = source.parentNode.parentNode.parentNode;

 var previousNotFilled;
 var actived;


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


 var tab = liTab.firstChild.firstChild;

 

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

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

 if ( (tab == source) ){
 actived = i;
 if (typeof(unFocus) == "object"){

 unFocus.History.addHistory(liTab.id.replace("miracle_tab_control", "mtc"));
}


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

 Element._show(tab.miracle.panel);


 liTab.firstChild.blur();
 if (notFilled) return notFilled;
}else{



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


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

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

 previousNotFilled = notFilled;
 return notFilled;
});

 return false;
},

 showTab: function(id){
 return false;
 if (!id) return false;
 var parts = id.split("_");
 var active = parts[3];
 var selector = "#miracle_tab_control_" + parts[1] + " .miracle_tab_panel";
 $$(selector).each(function(panel, i){
 printfire("panel");
 if (i == active){
 Element._show(panel);
}else{
 Element._hide(panel);
}
});
},

 historyListener: function(historyHash){

 var i = $N(historyHash.split("_")[3] - 1);
 if (!this.containers[0]){
 return false;
}
 var p = this.containers[0].panels[i];
 if (!Element.visible(p) && historyHash){
 this.switchTab({
 target: p.miracle.tab
});
}

}

}// end of class




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


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


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


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

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

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

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

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

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

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

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

}


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


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

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

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


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


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


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


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


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


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



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


var sweetTitles ={
 xCord : 0, // @Number: x pixel value of current cursor position
 yCord : 0, // @Number: y pixel value of current cursor position
 tipElements : ['abbr','acronym', 'img', 'a'], // @Array: Allowable elements that can have the toolTip
 obj : Object, // @Element: That of which you're hovering over
 tip : Object, // @Element: The actual toolTip itself
 active : 0, // @Number: 0: Not Active || 1: Active
 init : function(){
 if ( !document.getElementById ||
 !document.createElement ||
 !document.getElementsByTagName ){
 return;
}
 var i,j;
 this.tip = document.createElement('div');
 this.tip.id = 'toolTip';
 document.getElementsByTagName('body')[0].appendChild(this.tip);
 this.tip.style.top = '0';
 this.tip.style.visibility = 'hidden';
 var tipLen = this.tipElements.length;
 for ( i=0; i<tipLen; i++ ){
 var current = document.getElementsByTagName(this.tipElements[i]);
 var curLen = current.length;
 for ( j=0; j<curLen; j++ ){
 if (current[j].title){



 Event.observe(current[j], "mouseover", this.tipOver.bindAsEventListener(current[j]));
 Event.observe(current[j], "mouseout", this.tipOut.bindAsEventListener(current[j]));
 current[j].setAttribute('tip',current[j].title);
 current[j].removeAttribute('title');
}
}
}
},
 updateXY : function(e){
 if ( document.captureEvents ){
 sweetTitles.xCord = e.pageX;
 sweetTitles.yCord = e.pageY;
}else if ( window.event.clientX ){
 sweetTitles.xCord = window.event.clientX+document.documentElement.scrollLeft;
 sweetTitles.yCord = window.event.clientY+document.documentElement.scrollTop;
}
},
 tipOut: function(){
 if ( window.tID ){
 clearTimeout(tID);
}
 if ( window.opacityID ){
 clearTimeout(opacityID);
}
 sweetTitles.tip.style.visibility = 'hidden';
},
 checkNode : function(){
 var trueObj = this.obj;

 if (this.tipElements.inArray(trueObj.nodeName.toLowerCase()) ){
 return trueObj;
}else{
 return trueObj.parentNode;
}
},
 
 tipOver : function(e){
 sweetTitles.obj = this;
 tID = window.setTimeout("sweetTitles.tipShow()", 10);
 sweetTitles.updateXY(e);
},
 tipShow : function(){
 var scrX = Number(this.xCord);
 var scrY = Number(this.yCord);
 var tp = parseInt(scrY+15);
 var lt = parseInt(scrX+10);
 var anch = this.checkNode();
 var addy = '';
 var access = '';
 if ( anch.nodeName.toLowerCase() == 'a' ){


}else{
 if (anch.firstChild){
 addy = anch.firstChild.nodeValue;
}
}
 this.tip.innerHTML = "<p>"+anch.getAttribute('tip')+"<em>"+access+addy+"</em></p>";
 if ( parseInt(document.documentElement.clientWidth+document.documentElement.scrollLeft) < parseInt(this.tip.offsetWidth+lt) ){
 this.tip.style.left = parseInt(lt-(this.tip.offsetWidth+10))+'px';
}else{
 this.tip.style.left = lt+'px';
}
 if ( parseInt(document.documentElement.clientHeight+document.documentElement.scrollTop) < parseInt(this.tip.offsetHeight+tp) ){
 this.tip.style.top = parseInt(tp-(this.tip.offsetHeight+10))+'px';
}else{
 this.tip.style.top = tp+'px';
}
 this.tip.style.visibility = 'visible';
 this.tip.style.opacity = '.1';
 this.tipFade(10);
},
 tipFade: function(opac){
 var passed = parseInt(opac);
 var newOpac = parseInt(passed+10);
 if ( newOpac < 100 ){
 this.tip.style.opacity = '.'+newOpac;
 this.tip.style.filter = "alpha(opacity:"+newOpac+")";
 opacityID = window.setTimeout("sweetTitles.tipFade('"+newOpac+"')",20);
}
 else{
 this.tip.style.opacity = '1.0';
 this.tip.style.filter = "alpha(opacity:100)";
}
}
};



var Stars = Class.create();
Stars.prototype ={

 _x: 0,

 _y: 0,

 initialize: function(options)
{

 
 this._initialized = false;

 
 this.options ={
 bindField: null, // Form Field to bind the value to
 maxRating: 5, // Maximum rating, determines number of stars
 container: null, // Container of stars
 imagePath: 'images/', // Path to star images
 callback: null, // Callback function, fires when the stars are clicked
 actionURL: null, // URL to call when clicked. The rating will be appended to the end of the URL (eg: /rate.php?id=5&rating=)
 value: 0, // Initial Value
 locked: false
};
 Object.extend(this.options, options);
 this.locked = this.options.locked ? true : false;
 
 this._starSrc ={
 empty: this.options.imagePath + "star-empty.gif",
 full: this.options.imagePath + "star.gif",
 half: this.options.imagePath + "star-half.gif"
};
 
 for(var x in this._starSrc)
{
 var y = new Image();
 y.src = this._starSrc[x];
}

 document.getElem

 
 this._setStarSrc ={
 empty: this.options.imagePath + "star-ps-empty.gif",
 full: this.options.imagePath + "star-ps.gif",
 half: this.options.imagePath + "star-ps-half.gif"
};

 
 for(var x in this._setStarSrc)
{
 var y = new Image();
 y.src = this._setStarSrc[x];
}

 this.value = -1;
 this.stars = [];
 this._clicked = false;


 if(this.options.container)
{
 this._container = $(this.options.container);
 this.id = this._container.id;
}
 else
{
 this.id = 'starsContainer.' + Math.random(0, 100000);
 document.write('<span id="' + this.id + '"></span>');
 this._container = $(this.id);
}
 this._display();
 this.setValue(this.options.value);
 this._initialized = true;
},
 _display: function()
{
 for(var i = 0; i < this.options.maxRating; i++)
{
 var star = new Image();
 star.src = this.locked ? this._starSrc.empty : this._setStarSrc.empty;
 star.style.cursor = 'pointer';
 star.title = ' ' + (i + 1);
 !this.locked && Event.observe(star, 'mouseover', this._starHover.bind(this));
 !this.locked && Event.observe(star, 'click', this._starClick.bind(this));
 !this.locked && Event.observe(star, 'mouseout', this._starClear.bind(this));
 this.stars.push(star);
 this._container.appendChild(star);
}
},
 _starHover: function(e)
{
 if(this.locked) return;
 if(!e) e = window.event;
 var star = Event.element(e);

 var greater = false;
 for(var i = 0; i < this.stars.length; i++)
{
 this.stars[i].src = greater ? this._starSrc.empty : this._starSrc.full;
 if(this.stars[i] == star) greater = true;
}
},
 _starClick: function(e)
{
 if(this.locked) return;
 if(!e) e = window.event;
 var star = Event.element(e);
 this._clicked = true;
 for(var i = 0; i < this.stars.length; i++)
{
 if(this.stars[i] == star)
{
 this.setValue(i+1);
 break;
}
}
},
 _starClear: function(e)
{
 if(this.locked && this._initialized) return;
 var greater = false;
 for(var i = 0; i < this.stars.length; i++)
{
 if(i > this.value) greater = true;
 if((this._initialized && this._clicked) || this.value == -1)
 this.stars[i].src = greater ? (this.value + .5 == i) ? this._starSrc.half : this._starSrc.empty : this._starSrc.full;
 else
 this.stars[i].src = greater ? (this.value + .5 == i) ? this._setStarSrc.half : this._setStarSrc.empty : this._setStarSrc.full;
}
},

 setValue: function(val)
{
 var doCallBack = arguments.length > 1 ? !!arguments[1] : true;
 if(this.locked && this._initialized) return;
 this.value = val-1; //0-based
 if(this.options.bindField)
 $(this.options.bindField).value = val;
 if(this._initialized && doCallBack)
{
 if(this.options.actionURL)
 new Ajax.Request(this.options.actionURL + val,{onComplete: this.options['callback'], method: 'get'});
 else
 if(this.options.callback)
 this.options['callback'](val);
}
 this._starClear();
}
};

var d = document;

document.documentElement.className = 'js';



var miracleConfig=new Array();

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





var Miracle = Class.create();
Miracle.prototype ={

 initialize: function(){
 this.initActions = new Array();
 this.ajaxCache = [];
 this.eventSelectorRules = new Object();
 this.isEventSelectorRules = false;
 this.initDone = false;
 this.isIE = !!document.protocol;
 this.isIE6 = !!(document.protocol && !window.XMLHttpRequest);
 this.isIE7 = !!(document.protocol && window.XMLHttpRequest);

 if (this.isIE){
 this.ieCacheStyleSheet = document.createStyleSheet();
 this.ieCacheSelectors ={};
}

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

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

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



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

 this.config.initExtensions.miracleFileUploads = true;

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


},

 
 init: function(){

 if (this.initDone) return;

 this.initDone=true;

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

 this.loadMetaConfig();

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

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


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

 if (this.config.initExtensions.lightBox && typeof(Lightbox) == "function"){
 myLightbox = new Lightbox();
}

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

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

 

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

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

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

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

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

 

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

 this.initWindows();

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


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

 this.startEventSelectors();
},

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

 

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

 
 ajax: function(module, method, parameters, callback){
 var options ={
 asynchronous: false, 
 method: "post",
 parameters: "module=" + module
 + "&method=" + method
 + "&parameters=" + JSON.stringify(parameters)
};
 var hash = hex_md5(options.parameters);

 if (false && callback && this.ajaxCache[hash]){
 return callback(this.ajaxCache[hash]);
}
 miracle.ajaxIndicator(true);

 if (callback){
 options.asynchronous = true;
 options.onSuccess = function (xmlhttp){
 var response = eval(xmlhttp.responseText);
 callback(response);
 miracle.ajaxIndicator(false);
 miracle.ajaxCache[hash] = response;
}
}
 var myAjax = new Ajax.Request("/-/", options);
 if (callback){
 return true;
}

 var tmp = myAjax.responseIsSuccess() ? eval(myAjax.transport.responseText) : "";
 miracle.ajaxIndicator(false);
 miracle.ajaxCache[hash] = tmp;
 return tmp;
},

 ajaxAction: function(element, module, action, entity){

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

 var tmp = miracle.ajax(module, action, params, false);
}


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

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

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

 if (tmp && (action=="delete" || action=="delete_"+entity)){
 var trId=entity+"_"+element.getAttribute("recordid")+"_tr";

 var tr=document.getElementById(trId);
 var parent=tr;

 if (parent){
 do{
 parent=parent.parentNode;
}while (parent.tagName != "TABLE");
 
 parent.deleteRow(tr.rowIndex);
 var recordCountId = "miracle_pager_record_count";
 if ($(recordCountId)){
 $(recordCountId).innerHTML = 
 $(recordCountId).innerHTML - 1;
}
}else{
 alert("Error! #"+trId+" not found! Can't delete the row!");
}
}
},

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

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

 data: function(id){
 if (!(e=$("data_" + id))) return $A([]);
 var src = e.getAttribute("src");
 var data = eval(base64_decode(src.substring(src.indexOf(",") + 1)));
 return data;
},

 

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

 
 hoverEmulation: function(){
 if (!this.isIE6) return;


 this.config.miracleHoverEmulation = this.config.miracleHoverEmulation.concat($A(arguments));
},

 ieCacheSelector: function(selectors){
 var cssText = [];
 for (var i = 0; i < selectors.length; i++){
 var selector = selectors[i].replace(" ", "@");
 this.ieCacheSelectors[selector] = [];
 cssText.push(selectors[i] + "{behavior:expression(miracle.ieCacheStore('" + selector.replace(" ", "@") + "',this))}");
}
 this.ieCacheStyleSheet.cssText = cssText.join("\n");
},

 ieCacheStore: function(selector, element){
 miracle.ieCacheSelectors[selector].push(element);
 element.runtimeStyle.behavior = "none";
},

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

 findPos: function(obj){
 var curleft = curtop = 0;
 if (obj.offsetParent){
 curleft = obj.offsetLeft
 curtop = obj.offsetTop
 while (obj = obj.offsetParent){
 curleft += obj.offsetLeft
 curtop += obj.offsetTop
}
}
 return [curleft, curtop];
},

 IFrameShim: function(selector){
 if (!this.isIE6 || document.getElementsByTagName("select").length == 0) return false;
 $$(selector).each(function(e){
 var i = document.createElement("iframe");
 var is = i.style;
 i.frameBorder = 0;
 i.scrolling = "no";
 is.position = "absolute";
 is.left = 0;
 is.top = 0;
 is.width = e.offsetWidth;
 is.height = e.offsetHeight;
 is.left = e.offsetLeft + e.offsetParent.offsetLeft;
 is.top = e.offsetTop + e.offsetParent.offsetTop;
 is.zIndex = e.style.zIndex - 1;
 i.id = "__shim_" + e.uniqueID;
 e.parentNode.appendChild(i);
 Element.addClassName(e, "shimmed");
}.bind(this));
},

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

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

 includeExternalCSS: function(url){

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

 initAction: function(event){

 this.initActions.push(event);
},

 
 initAjax: function(selector){
 var selector = selector || "table.lister";
 $A($$(selector)).each(function(lister){
 var module = lister.getAttribute("module");

 var entity = lister.getAttribute("entity");
 if (!entity) entity = "record";

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

 initCalendar: function(){


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

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

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

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

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


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

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

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

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

},


 initMiracleFileUploads: function(){
 var fups=new Array();
 var j=0;

 var elements=document.getElementsByTagNameAndAttribute("fieldset", "class", "file_upload");

 var elementsIE=document.getElementsByTagNameAndAttribute("fieldset", "classname", "file_upload");
 for (i=0; i < elementsIE.length; i++){
 elements[elements.length++] = elementsIE[i];
}

 for (var i=0; i<elements.length; i++){
 fups[j]=new fileUpload(elements[i].getAttribute("id"));
 j++;
}
},

 initMiracleHover: function(){
 if (!this.isIE6) return;

 
 this.config.miracleHoverEmulation.each(function(selector){





 $$(selector).each(function(node){



 node.observe('mouseover', function(){

 this.className+=" hover";
}.bindAsEventListener(node));

 node.observe('mouseout', function(){


 this.className=this.className.replace(new RegExp(" hover\\b"), "");
}.bindAsEventListener(node));
});
}.bind(this));
 
},

 initMiraclePopups: function(){

 init_Popups();
},

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

 initMooFX: function(){


},

 initWindows: function(){
 $$("a[rel=inner_popup]").each(function(element){
 Event.observe(element, "click", function(event){
 
 var element = this;
 var win = new Window("_window",{
 className: "dialog", 
 title: element.title, 
 width: 825, 
 height:518,
 draggable: true,
 minimizable: false,
 maximizable: false,
 resizable: false, 
 url: element.getAttribute("href") 
});
 win.show(); 
 win.setDestroyOnClose()
 win.showCenter();
 Event.stop(event); 
}.bind(element));
});
},


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

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

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

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

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


}


function str_replace(search, replace, subject){
 var result = "";
 var oldi = 0;
 for (var i = subject.indexOf (search); i > -1; i = subject.indexOf (search, i))
{
 result += subject.substring (oldi, i);
 result += replace;
 i += search.length;
 oldi = i;
}
 return result + subject.substring (oldi, subject.length);
}

function loremipsum(num){
 var szavak = new Array("alma","dió","mogyoró","körte","dinnye","málna","meggy","cseresznye","kókusz","szilva","barack","szőlő","ribizli",
 "cica","kutya","majom","zsiráf","degu","nyuszi","rozmár","zebra","cinege","mókus","koala","sün","rókakoma","motkány","jak","hal","teknős","pulyka","tatu","ürge","tapír",
 "piros","kék","sárga","zöld","türkiz","okker","fekete","fehér","lila","barna","pink","egyetem","damil","lapát","bakancs","csizma","szalonna",
 "perec","koponya","virág","monitor","indigó","toboz","tank","kifli","bolygó","csillag","por","pokróc",
 "orgona","hegedű","brácsa","gordonka","zongora","gitár","furulya","cimbalom","dob","oboa","szakszofon","cintányér","balalajka","harmónika",
 "Delhusa Johnny","Dolly Rambo",
 "Hold","Nap","Föld","Mars","Vénusz","Merkúr","Jupiter","Szaturnusz","Uránusz","Neptunusz","Plútó","naprendszer"
 );

 var str="";
 for (var i=1; i<=num; i++){
 var k=parseInt(Math.random()*szavak.length);
 str+=szavak[k]+" ";
}
 return str;
}

function auto_formkitoltes(){
 var firstnames=new Array("Kis","Nagy","Toth","Magyar","Liszkai","Kovacs","Olah","Erdos","Kiskunfelegyhazi","Lorinc","Hegedus","Asztalos","Bognar");
 var lastnames=new Array("Agota","Bernadett","Karoly","Antal","Anita","Krisztian","Laszlo","Szilvia","Daniel","Robert","Noemi","Henrietta","Norbert","Zsolt","Balazs","Erika");
 var FN=firstnames.length;
 var LN=lastnames.length;

 var elements=document.getElementsByTagName('input');
 var element;
 for (var ii=0; elements[ii]; ii++){
 element=elements[ii];
 if (element.hasClassName("hide")) continue;
 var tmp=element.getAttribute('name');
 var name="";
 if (tmp){
 var n=tmp.split("[");
 if (n[1]) name=str_replace("]","",n[1]);
}

 if (element.getAttribute('type')=="text"){


 if (name=="name" || name=="fullname") element.value=firstnames[parseInt(Math.random()*FN)]+" "+lastnames[parseInt(Math.random()*LN)];
 else if (name=="email") element.value=lastnames[parseInt(Math.random()*LN)].toLowerCase()+"@akarmi.hu";
 else if (name=="webpage" || name=="weboldal") element.value="http://www."+lastnames[parseInt(Math.random()*LN)].toLowerCase()+"_"+firstnames[parseInt(Math.random()*FN)].toLowerCase()+".hu";
 else if (name=="lastname") element.value=firstnames[parseInt(Math.random()*FN)];
 else if (name=="firstname") element.value=lastnames[parseInt(Math.random()*LN)];
 else if (element.getAttribute('accept')=="numeric") element.value=parseInt(Math.random()*82500);
 else if (name=="phone") element.value="06 30 "+parseInt(Math.random()*999)+" "+parseInt(Math.random()*999);
 else if (name=="fax") element.value="06 35 "+parseInt(Math.random()*999)+" "+parseInt(Math.random()*999);
 else element.value=loremipsum(parseInt(Math.random()*4)+1);
}

 if (element.getAttribute('type')=="checkbox"){

 if (parseInt(Math.random()*2)==1) element.checked=true;
 else element.checked=false;
}
 if (element.getAttribute('type')=="radio"){

 if (parseInt(Math.random()*2)==1) element.checked=true;
 else element.checked=false;
}

 if (element.getAttribute('type')=="date"){
 var year=2000+(parseInt(Math.random()*14)-7);
 var month=parseInt(Math.random()*11)+1;
 if (month<10) month="0"+month;
 var day=parseInt(Math.random()*28)+1;
 if (day<10) day="0"+day;
 element.value=year+"-"+month+"-"+day;
}
}

 var elements=document.getElementsByTagName('select');
 var element;
 for (var ii=0; elements[ii]; ii++){
 element=elements[ii];
 for (var j=0; element.options[j]; j++);

 if (element.getAttribute('multiple')){

 for (var jj=0; element.options[jj]; jj++){
 if (element.options[jj]) element.options[jj].selected=false;
}

 for (var jj=0; jj<parseInt(Math.random()*6); jj++){
 var kij=parseInt(Math.random()*j);
 if (element.options[kij] && element.options[kij].value!="NULL") element.options[kij].selected=true;
}
}
 else{
 var kij=parseInt(Math.random()*j);
 element.selectedIndex=kij;
}
}

 var elements=document.getElementsByTagName('textarea');
 var element;
 for (var ii=0; elements[ii]; ii++){
 element=elements[ii];
 element.value=loremipsum(parseInt(Math.random()*105)+1);
}
}

function shake(i){
 var uji=i+1;
 if (i<30){
 var x=5-(Math.random()*10);
 var y=5-(Math.random()*10);
 document.body.style.left=x+"px";
 document.body.style.top=y+"px";

 setTimeout("shake("+uji+")",10);
}
 else document.body.style.position="static";
}

var pvd_visible=true;
var hangyaid=0;
var hangyaw=56;
var hangyah=42;

function keyDown(event){
 var key, e, tag;

 (e = event) || (e = window.event);
 (tag = e.target) || (tag = e.srcElement);

 if (window.event) key = window.event.keyCode;
 else if (event.which) key = event.which;
 else return true; // Unknown browser


 if (window.location.href.substr(0,11)=="http://dev." && tag.tagName != "INPUT" && tag.tagName != "TEXTAREA"){
 if (key == 80){
 if (pvd_visible){
 $A(document.getElementsByClassName('pvd')).each(function(element){
 element.style.display="none";
});
 pvd_visible=false;
}
 else{
 $A(document.getElementsByClassName('pvd')).each(function(element){
 element.style.display="block";
});
 pvd_visible=true;
}
}

 if (key == 87){
 document.body.style.position="relative";
 setTimeout("shake(1)",10);
}


 if (key == 81){

 auto_formkitoltes();
}
 
 if (key == 74){

 try{
 var element = document.createElement('<a rel="kwindow" module="miracle" method="kwindow_password_generator" id="kwindow_password_generator" class="hide">');
}catch (e){
 var element = document.createElement("a");
 element.setAttribute("rel", "kwindow");
 element.setAttribute("module", "miracle");
 element.setAttribute("method", "kwindow_password_generator");
 element.setAttribute("id", "kwindow_password_generator");
 element.setAttribute("class", "hide");
}
 document.body.appendChild(element);
 kwindow.kwindow_show($("kwindow_password_generator"));
}
 
 if (key == 75){

 try{
 element = document.createElement("<img src='/images/miracle/setalo.gif?r="+parseInt(Math.random()*1000)+"' alt=' ' id='kurva' />");
}catch (e){
 element = document.createElement("img");
 element.setAttribute("src", "/images/miracle/setalo.gif?r="+parseInt(Math.random()*1000));
 element.setAttribute("id", "kurva");
}
 
 $("body").appendChild(element);
 
 $('kurva').style.position="absolute";
 var kx=parseInt(Math.random()*1000);
 var ky=parseInt(Math.random()*800);
 $('kurva').style.top=kx+"px;"
 $('kurva').style.left=ky+"px;";
}

 

 if (key == 72){
 plusz_egy_hangya();
}

 if (key == 78){
 hangyaw+=2;
 hangyah+=2;
 $A(document.getElementsByClassName("hangya")).each(function(element){
 element.style.width=hangyaw+"px";
 element.style.height=hangyah+"px";
});
}
 
 if(key == 79 && tag.tagName != "INPUT" && tag.tagName != "TEXTAREA"){
 var obj = prompt('Add meg az objektumot:');

 eval("showProps("+obj+", '"+obj+"');");
 return true;
}

}
 
 return true;
}

document.onkeydown = keyDown;

function showProps(obj, objName){
 if (typeof(objName) == "undefined") objName = "object";
 var result = "";
 for (var i in obj){
 result += objName + "." + i + " = ";
 try{
 result += obj[i];
}
 catch (e){
 result += e;
}
 result += "\n";
}
 var w = window.open("", "w", "width=560,height=450,resizable=yes,scrollbars=yes");
 w.document.write("<pre>" + result + "</pre>");
 w.document.close();
}

function after_kwindow_password_generator(){
 var r=kwindow.kwindow_post_response_text;
 $("kwindow_passwords").innerHTML=r;
}


function plusz_egy_hangya(){
 hangyaid++;

 try{
 var element = document.createElement("<img src='/images/miracle/hangya.gif?r="+hangyaid+"' alt=' ' id='hangya"+hangyaid+"' class='hangya' />");
}catch (e){
 var element = document.createElement("img");
 element.setAttribute("src", "/images/miracle/hangya.gif?r="+hangyaid);
 element.setAttribute("id", "hangya"+hangyaid);
 element.setAttribute("class", "hangya");
}

 document.body.appendChild(element);

 $('hangya'+hangyaid).style.position="absolute";
 var kx=parseInt(Math.random()*1300);
 var ky=parseInt(Math.random()*800);
 $('hangya'+hangyaid).style.top=ky+"px";
 $('hangya'+hangyaid).style.left=kx+"px";
}





var miracle = new Miracle();

miracle.form = new miracleForm();


miracle.tree = Class.create();

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

 if (!$(id)) return false;

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

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

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

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

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

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

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

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


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

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

 this.newButtonId = this.id + "_new_button";
},

 addNewButton: function(){



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


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

 addRemoveButtons: function(){
 this.container.getElementsByClassName("repeat").each(function(repeat){

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



 repeat.appendChild(removeButton);
}.bind(this));
},

 createMaster: function(){
 var repeatable = $$("#" + this.id +" .repeat").first();
 if (!repeatable){
 return false;
}else{
 return this.reset(repeatable);
}
},



 doAdd: function(event){



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


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






 var clone = this.masterHTML.cloneNode(true);
 console.log(this.masterHTML);
 console.log(clone);
 console.log(clone == this.masterHTML);
 var options = clone.getElementsByTagName("option");
 for (var i = 0; i < options.length; i++){
 options[i].selected = false;
}
 newBlock.appendChild(clone);
 newBlock.appendChild(removeButton);
 Element.addClassName(newBlock, "repeat");



 var elements = Form.getElements(newBlock);
 elements.each(function(elem){
 var newName = elem.getAttribute("name").replace(new RegExp(this.counterRegExp), this.counter);
 elem.setAttribute("name", newName);
}.bind(this));

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

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

 doRemove: function(event){

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

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

 reset: function(source){
 var master = source.cloneNode(true);
 Form.getElements(master).each(function(element){
 console.log(element);
 switch (element.tagName){
 case "SELECT":
 console.log(element.selectedIndex);
 element.options[0].selected = true;


 break;
 default: 
 element.setAttribute("value", "");

}
});



 console.log(master.innerHTML);
 return master;
}



}// end of class
var Kwindow = Class.create();

function getScrollXY(){
 var scrOfX = 0, scrOfY = 0;
 if( typeof( window.pageYOffset ) == 'number' ){

 scrOfY = window.pageYOffset;
 scrOfX = window.pageXOffset;
}else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ){

 scrOfY = document.body.scrollTop;
 scrOfX = document.body.scrollLeft;
}else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ){

 scrOfY = document.documentElement.scrollTop;
 scrOfX = document.documentElement.scrollLeft;
}
 return [ scrOfX, scrOfY ];
}


function urldecode(str){
 if (str=="") return "";
 var ret = str;
 ret = ret.replace(/\+/g, '%20');
 ret = decodeURIComponent(ret);
 ret = ret.toString();
 return ret;
}

function urlencode(str){
 if (str=="") return "";
 var ret = str;
 ret = ret.toString();
 ret = ret.replace(/\?/g, 'xkerdojelx');
 ret = encodeURIComponent(ret);
 ret = ret.replace(/%20/g, '+');
 return ret;
}

Kwindow.prototype ={

 initialize: function(){

},
 
 init: function(loc){
 this.init_auto_kwindow(loc);
 this.init_kwindow(loc);
 this.init_kwindow_gallery(loc);

 this.kwindow_post_response_text="";
 this.gallery_move_up=false;
 this.gallery_move_down=false;
 this.gallery_scrollspeed=10;
},

 vIE: function(){
 return (navigator.appName=='Microsoft Internet Explorer')?parseFloat((new RegExp("MSIE ([0-9]{1,}[.0-9]{0,})")).exec(navigator.userAgent)[1]):-1;
},

 init_auto_kwindow: function(loc){
 if(loc){loc+=" ";}else{loc='';}
 $$(loc+"a[rel=auto_kwindow]").each(function(element){
 kwindow.kwindow_show(element);
});
},

 init_kwindow: function(loc){
 if(loc){loc+=" ";}else{loc='';}
 $$(loc+"a[rel=kwindow]").each(function(element){
 Event.observe(element, "click", function(event){
 kwindow.kwindow_show(element);
 Event.stop(event);
}.bind(element));
});
},

 init_kwindow_gallery: function(loc){
 if(loc){loc+=" ";}else{loc='';}
 $$(loc+"a[rel=kwindow_gallery]").each(function(element){
 Event.observe(element, "click", function(event){
 kwindow.kwindow_show(element);
 Event.stop(event);
}.bind(element));
});
},

 init_kwindow_close: function(loc){
 if(loc){loc+=" ";}else{loc='';}
 $$(loc+"a[rel=kwindow_close]").each(function(element){
 Event.observe(element, "click", function(event){
 kwindow.kwindow_close();

 if (element.getAttribute('run_js')){
 var run_js_fgv_name=element.getAttribute('run_js');
 var ret=eval(run_js_fgv_name)();
}

 if (element.getAttribute('module')) kwindow.kwindow_show(element);
 Event.stop(event);
}.bind(element));
});
},
 
 init_kwindow_post: function(loc){
 if(loc){loc+=" ";}else{loc='';}
 $$(loc+"a[rel=kwindow_post]").each(function(element){
 Event.observe(element, "click", function(event){

 if (element.getAttribute('check_form_js')){
 var check_js_fgv_name=element.getAttribute('check_form_js');
 var valid=eval(check_js_fgv_name)();
 if (valid) kwindow.kwindow_post(element);
}
 else // ha nincs akkor egybol mehet a post:
 kwindow.kwindow_post(element);
 Event.stop(event);
}.bind(element));
});
},
 
 kwindow_post: function(element){
 var form_id=element.getAttribute('form_id');
 var update_div=element.getAttribute('update_div');
 var url=element.getAttribute('url');

 var serializedForm = Form.serialize(form_id);

 if (update_div){

 var myAjax = new Ajax.Updater(update_div, url,
{
 asynchronous:true,
 onComplete: function(response){

 if (element.getAttribute('close_after_post')=="true") kwindow.kwindow_close();

 kwindow.kwindow_post_response_text=response.responseText;

 kwindow.init('#'+update_div);

 kwindow.init_kwindow_close('#'+update_div);

 kwindow.init_kwindow_post('#'+update_div);


 if (element.getAttribute('run_js_after_post')){
 var run_js_fgv_name=element.getAttribute('run_js_after_post');
 var ret=eval(run_js_fgv_name)();
}
},
 parameters: serializedForm,
 method: 'post'
});
}
 else{

 var myAjax = new Ajax.Request(url,
{
 asynchronous:true,
 onComplete: function(response){

 if (element.getAttribute('close_after_post')=="true") kwindow.kwindow_close();

 kwindow.kwindow_post_response_text=response.responseText;

 if (element.getAttribute('run_js_after_post')){
 var run_js_fgv_name=element.getAttribute('run_js_after_post');
 var ret=eval(run_js_fgv_name)();
}
},
 parameters: serializedForm,
 method: 'post'
});
}
},
 
 kwindow_close: function(element_id){

 $("kwindow").style.display="none";

 if ($("kwindow_content").down(0) && !kwindow.vIE()) $("kwindow_content").removeChild($("kwindow_content").down(0));

 $("photogallery2_darken").style.display="none";

 if (element_id) kwindow.kwindow_show($(element_id));

 if (kwindow.vIE()==6)
 $("body").getElementsBySelector("select").each(function(element){
 element.style.visibility="visible";
});
},

 kwindow_show: function(element){

 var rel=element.getAttribute("rel");

 var bg_color=element.getAttribute('bg_color');
 if (bg_color) $("photogallery2_darken").style.background="#"+bg_color;

 var bg_transparency=element.getAttribute('bg_transparency');
 if (bg_transparency){
 $("photogallery2_darken").style.filter = "alpha(opacity="+bg_transparency+")";
 $("photogallery2_darken").style.opacity = (bg_transparency/100);
 $("photogallery2_darken").style.MozOpacity = (bg_transparency/100);
 $("photogallery2_darken").style.KhtmlOpacity = (bg_transparency/100);
}

 var top=element.getAttribute('top');

 var positions=getScrollXY();
 var _top=positions[1]+top;
 $("kwindow_center").style.top=_top+"px";

 var disable_darken=element.getAttribute('disable_darken');

 var module=element.getAttribute('module');

 var template=element.getAttribute('template');

 var method=element.getAttribute('method');

 var params=element.getAttribute('params');
 if (params) params=urlencode(params);

 var width=element.getAttribute('width');
 if (width) $("kwindow").style.width=width+(isNaN(width)?'':"px");
 else $("kwindow").style.width="500px";

 var height=element.getAttribute('height');
 if (height) $("kwindow").style.height=height+"px";
 else $("kwindow").style.height="auto";

 var autoclose=parseInt(element.getAttribute('autoclose'),10);

 if (autoclose>0) var kwindow_after_autoclose=element.getAttribute('kwindow_after_autoclose');

 var loading_animation=element.getAttribute('loading_animation');

 var alert_text=element.getAttribute('alert');
 if (alert_text){
 alert_text=urlencode(alert_text);
 var alert_mode=element.getAttribute('mode');
 if (alert_mode) alert_mode=urlencode(alert_mode);
 else alert_mode='alert';
 url="/ajax__kwindow_alert/"+alert_text+"/"+alert_mode;
}

 if (kwindow.vIE()==6)
 $("body").getElementsBySelector("select").each(function(element){
 element.style.visibility="hidden";
});

 if (disable_darken!="true")

 $("photogallery2_darken").style.display="block";


 var bodyHeight=document.body.offsetHeight
 $("photogallery2_darken").style.height=bodyHeight+"px";

 if (loading_animation!="false") $("kwindow_loading").style.display="block";


 $("kwindow_content").innerHTML="";

 $("kwindow").style.display="block";


 if (rel=="kwindow_gallery"){

 var gallery_id=element.getAttribute('gallery_id');
 if (!gallery_id) gallery_id="0";
 if (!template) template="1";
 var startpic=element.getAttribute('startpic');
 if (!startpic) startpic="0";
 var main_image_size=element.getAttribute('main_image_size');
 if (!main_image_size) main_image_size="666x500";
 var thumb_image_size=element.getAttribute('thumb_image_size');
 if (!thumb_image_size) thumb_image_size="130x130";
 var title=element.getAttribute('title');
 if (!title) title="-";
 title=urlencode(title);
 var filter_picture_title=element.getAttribute('filter_picture_title');
 if (!filter_picture_title) filter_picture_title="-";
 filter_picture_title=urlencode(filter_picture_title);
 var gallery_module=element.getAttribute('gallery_module');
 if (!gallery_module) gallery_module="gallery";
 var gallery_scrollspeed=parseInt(element.getAttribute('scrollspeed'));
 if (!gallery_scrollspeed) gallery_scrollspeed=10;
 kwindow.gallery_scrollspeed=gallery_scrollspeed;

 if (!width){
 var mis=main_image_size.split("x");
 var tis=thumb_image_size.split("x");
 width=parseInt(mis[0])+parseInt(tis[0])+50;
 $("kwindow").style.width=width+"px";
}

 url="/ajax__get_kwindow_gallery_template/"+gallery_id+"/"+template+"/"+startpic+"/"+main_image_size+"/"+thumb_image_size+"/"+title+"/"+filter_picture_title+"/"+gallery_module;
}
 
 if (!method && template && rel!="kwindow_gallery" && !alert_text) url="/ajax__get_kwindow_content_from_template/"+module+"/"+template+"/params?"+params;
 if (method && !alert_text) url="/ajax__get_kwindow_content_from_method/"+module+"/"+method+"/params?"+params;
 var pars = '';
 var myAjax = new Ajax.Updater('kwindow_content', url,{
 method: 'get',
 parameters: pars,
 evalScripts: true,
 onComplete : function(valasz){

 if (loading_animation!="false") $("kwindow_loading").style.display="none";

 kwindow.init('#kwindow_content');

 kwindow.init_kwindow_close('#kwindow_content');

 kwindow.init_kwindow_post('#kwindow_content');

 if (autoclose>0 && !kwindow_after_autoclose) setTimeout("kwindow.kwindow_close()",parseInt(autoclose));

 if (autoclose>0 && kwindow_after_autoclose) setTimeout("kwindow.kwindow_close('"+kwindow_after_autoclose+"')",autoclose);
}
});

},
 
 change_main_image: function(){
 if (!$("kwindow_gallery")) return;
 $A($("kwindow_gallery").getElementsByClassName("change_kwindow_main_image")).each(function(element){
 element.observe("click", function(event){
 $A($("kwindow_gallery").getElementsByClassName("main_image")).each(function(element2){
 element2.style.display="none";
});
 var image_id=element.up('td',0).getAttribute('image_id');
 $("kg_image_"+image_id).style.display="block";
});
});
},
 
 gallery_move: function(){
 if (!$("kwindow_gallery")) return;
 $A($("kwindow_gallery").getElementsByClassName("move_up")).each(function(element){
 element.observe("mouseover", function(event){
 kwindow.gallery_move_up=true;
 setTimeout("kwindow.gallery_scroll('up')",20);
});
});
 $A($("kwindow_gallery").getElementsByClassName("move_down")).each(function(element){
 element.observe("mouseover", function(event){
 kwindow.gallery_move_down=true;
 setTimeout("kwindow.gallery_scroll('down')",20);
});
});
 $A($("kwindow_gallery").getElementsByClassName("move_up")).each(function(element){
 element.observe("mouseout", function(event){
 kwindow.gallery_move_up=false;
});
});
 $A($("kwindow_gallery").getElementsByClassName("move_down")).each(function(element){
 element.observe("mouseout", function(event){
 kwindow.gallery_move_down=false;
});
});
},

 gallery_scroll: function(dir){
 if (dir=="up"){
 var top=parseInt($("kwindow_gallery_thumbs").style.top);
 if (!top) top=0;
 top+=kwindow.gallery_scrollspeed;
 if (top>0) top=0;
 $("kwindow_gallery_thumbs").style.top=top+"px";
 if (kwindow.gallery_move_up) setTimeout("kwindow.gallery_scroll('up')",20);
}
 if (dir=="down"){

 var thumbsHeight=400;
 $A($("kwindow_gallery").getElementsByClassName("thumbs")).each(function(element){
 thumbsHeight=parseInt(element.style.height);
});

 var top=parseInt($("kwindow_gallery_thumbs").style.top);
 if (!top) top=0;
 top-=kwindow.gallery_scrollspeed;
 var hossz=-parseInt($("kwindow_gallery_thumbs").offsetHeight);
 hossz=hossz+thumbsHeight;
 if (top<=hossz) top=hossz;
 if (parseInt($("kwindow_gallery_thumbs").offsetHeight)<thumbsHeight) top=0;
 $("kwindow_gallery_thumbs").style.top=top+"px";
 if (kwindow.gallery_move_down) setTimeout("kwindow.gallery_scroll('down')",20);
}
}
 
}

var kwindow=new Kwindow;
var DDcode = Class.create();

DDcode.prototype ={
 
 initialize: function(){

 addEvent(window, "load", this.init.bind(this));
},
 init: function(){
 $$("a[rel=ddcode_button]").each(function(element){

 var areas = (element.parentNode).parentNode.getElementsByTagName('textarea');

 element.textarea = (areas[0].id).substr(7);

 Event.observe(element, "click", function(event){

 var target = this.textarea;
 var div_id = $( this.id.substr(2,(this.id.length-2)) );

 var ddcode = div_id.getAttribute('code');
 var ddtype = div_id.getAttribute('type');
 var ddalt = div_id.getAttribute('alt');
 
 if(!ddcode && ddtype!='smile_btn')return true;

 var txt = $('ddcode_'+target).value;
 var sta = $('ddcode_'+target).selectionStart;
 var end = $('ddcode_'+target).selectionEnd;
 
 if(ddtype=='prompt'){

 var dd = ddcode.split('\%s'); 
 if(!dd)return true;
 
 if(sta==end){
 var prom = "";
 while(1){

 prom = prompt(ddalt, prom);
 if(!prom) return true;
 
 if(dd[0]=="[mail]")
 var regxp = new RegExp(/^(("[\w-\s]+")|([\w-]+(?:\.[\w-]+)*)|("[\w-\s]+")([\w-]+(?:\.[\w-]+)*))(@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$)|(@\[?((25[0-5]\.|2[0-4][0-9]\.|1[0-9]{2}\.|[0-9]{1,2}\.))((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\.){2}(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})\]?$)/i);
 else if(dd[0]=="[url]")
 var regxp = new RegExp(/((ftp|http|https):\/\/|)(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/);
 else if(dd[0]=="[img]")
 var regxp = new RegExp(/((ftp|http|https):\/\/|)(.*)(jpg|png|gif)/);
 else return false;
 
 if(prom.match(regxp)) break;
 else alert('Hibás adat!');
}

 var txt1 = txt.substr(0,sta);
 var txt2 = txt.substr(end,txt.length);
 var new_txt = (txt1+" "+dd[0]+prom+dd[1]+txt2);
}
 else{

 var txt1 = txt.substr(0,sta);
 var txt2 = txt.substr(sta,(end-sta));
 var txt3 = txt.substr(end,txt.length);
 var new_txt = (txt1+dd[0]+txt2+dd[1]+txt3);
}
}

 else if(ddtype=='smile_btn') $('ddcode_layer_'+target+'_emoticons').toggle();

 else if(ddtype=='smile'){

 var txt1 = (txt.substr(0,sta))||"";
 var txt2 = (txt.substr(end,txt.length))||"";
 var new_txt = (txt1+" "+ddcode+" "+txt2);
}

 else if(ddtype=='help'){

 window.open('http://hu.wikipedia.org/wiki/BBCode', 'bbcodeinfo');
}

 else if(!ddtype){

 var dd = ddcode.split('\%s');
 if(!dd)return true;
 
 if(sta==end){

 var txt1 = (txt.substr(0,sta))||"";
 var txt2 = (txt.substr(end,txt.length))||"";
 var new_txt = (txt1+" "+dd[0]+dd[1]+txt2);
}
 else{

 var txt1 = (txt.substr(0,sta))||"";
 var txt2 = (txt.substr(sta,(end-sta)))||"";
 var txt3 = (txt.substr(end,txt.length))||"";
 var new_txt = (txt1+dd[0]+txt2+dd[1]+txt3);
}
}
 if(new_txt) $('ddcode_'+target).value = new_txt;


 
}.bind(element));
}.bind(this));
},
 vars:{
 container: false,
 textarea: false
}
};

var ddcode = new DDcode;


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


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

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


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





function server_action(module, method, parameters){
 return miracle.ajax(module, method, parameters);
}
miracle.config.initExtensions.lightBox = true;
resizeSpeed = 10;

var classMenuHover = function(){

 this.init = function(){
 var subMenus = $$("#div-header-bottom li ul.submenu");
 if( !subMenus.length ) return false;
 subMenus.each(function(item){
 Event.observe(item.parentNode, "mouseover", function(ev){
 item.style.display = "block";
}.bind(item));

 Event.observe(item.parentNode, "mouseout", function(ev){
 item.style.display = "none";
}.bind(item));
});
}

}

var oMenuHover = new classMenuHover();
Event.observe(window, "load", function(){oMenuHover.init()});

var classInsertText = function(){

 this.init = function(){
 var loc = window.location.href.split("/");
 if( loc.length>2 ) loc = loc[2];

 if( loc.indexOf("kereso") != -1 ) var banners = $$("#module_base div.banner"); //(fog)orvos-kereso oldalakon spéci helyzet van
 else var banners = $$("#container div.banner");

 if( !banners.length ) return false;

 banners.each(function(item){
 var dom = $(document.createElement("span"));
 dom.addClassName("advert");
 dom.innerHTML = "hirdetés";
 if( item.firstChild ) item.insertBefore(dom, item.firstChild);
 else item.appendChild(dom);
});
}

}

var oInsertText = new classInsertText();
Event.observe(window, "load", function(){oInsertText.init()});

var classTooltipText = function(){
 var self = this;
 var tooltip = null;

 this.init = function(){
 var tooltips = $$("#div-header-bottom li a[tooltip]", "#top ul.menu li a[tooltip]");

 if( !tooltips.length ) return false;

 tooltips.each(function(item){
 Event.observe(item, "mouseover", function(ev){
 self.generateTooltip(ev, item);
}.bind(item));

 Event.observe(item, "mousemove", function(ev){
 self.moveTooltip(ev);
}.bind(item));

 Event.observe(item, "mouseout", function(){
 self.removeTooltip();
}.bind(item));
});
}

 this.generateTooltip = function(ev, item){
 var tooltipText = item.getAttribute("tooltip");
 if( !tooltipText ) return false;

 self.tooltip = $(document.createElement("div"));
 self.tooltip.setAttribute("id", "menu-tip");
 self.tooltip.innerHTML = tooltipText;
 document.body.appendChild(self.tooltip);

 if( self.tooltip ){
 self.tooltip.style.left = (document.all ? ev.clientX-0 : ev.pageX-0 + "px");
 self.tooltip.style.top = (document.all ? ev.clientY + document.body.scrollTop + document.documentElement.scrollTop + 15 : (ev.pageY + 15) + "px");
 self.tooltip.style.display = "block";
}
}

 this.removeTooltip = function(){
 if( !self.tooltip ) return false;
 
 self.tooltip.parentNode.removeChild(self.tooltip);
 self.tooltip = null;
}

 this.moveTooltip = function(ev){
 if( !self.tooltip ) return false;

 self.tooltip.style.left = (document.all ? ev.clientX-0 : ev.pageX-0 + "px");
 self.tooltip.style.top = (document.all ? ev.clientY + document.body.scrollTop + document.documentElement.scrollTop + 15 : (ev.pageY + 15) + "px");
}

}

var oTooltipText = new classTooltipText();
Event.observe(window, "load", function(){oTooltipText.init()});

var classBorzeScroller = function(){
 var self = this;
 var direction;
 var speed;
 var counter;
 var area;

 this.init = function(){
 var buttons = $$("#borze-wrapper span.borze-button");
 self.area = $("borze-moveable-area");
 self.speed = 50;

 if( !buttons.length || !self.area ) return false;

 buttons.each(function(item){
 Event.observe(item, "mouseover", function(ev){
 if( item.getAttribute("id") == "boze-button-up" ) self.direction = -1;
 else self.direction = 1;
 self.executeScroll();
}.bind(item));

 Event.observe(item, "mouseout", function(ev){
 self.stopScroll();
});

 Event.observe(item, "mouseup", function(ev){
 self.speed = 50;
});

 Event.observe(item, "mousedown", function(ev){
 self.speed = 10;
});
});
}

 this.executeScroll = function(){
 if( self.direction == 1 ){//felfelé megy a scroll, tehát a lefelé gombot nyomja
 var nPos = Math.round((parseInt(self.area.style.top) || 0) - 10);

 if( nPos < (-1) * self.area.scrollHeight + 156 ) nPos = (-1) * self.area.scrollHeight + 156; //156, mert ennyi a borze-body magassága
}
 else{//lefelé megy a scroll, tehát a felfelé gombot nyomja
 var nPos = Math.round((parseInt(self.area.style.top) || 0) + 10);
 if( nPos > 0 ) nPos = 0;
}

 self.area.style.top = nPos + "px";
 self.counter = setTimeout(function(){self.executeScroll()}, self.speed);
}

 this.stopScroll = function(){
 clearTimeout(self.counter);
}
}

var oBorzeScroller = new classBorzeScroller();
Event.observe(window, "load", function(){oBorzeScroller.init()});





addEvent(window, "load", popup_banner_init);

function popup_banner_init(){
 if( $('dental_welcome') ){
 document.cookie=("dental_welcome=disabled;");
}
}





function table_order(method,rekordid)
{
 var url = '/order_table/label/table_order';
 var pars = 'ajax[labelid]=' + rekordid + '&ajax[todo]=' + method;
 var myAjax = new Ajax.Updater( 'labels_table', url,{method: 'post', parameters: pars});
 return false;
}










miracle.initAction(tabs);
miracle.initAction(mini_w);

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

var breaker = false;
function initStars(){
 if( !$("stars") ) return;
 var article_id = $("stars").getAttribute("article");
 var voted_value = $("stars").getAttribute("voted");

 breaker = false;
 var cookies = explode("; ", document.cookie); //Cookie-k mutatják milyen cikkekre szavazott eddig
 cookies.each( function(co){
 var c = explode("=", co);
 if( c[0] == "voted_article" ){//voted_article nevű cookie-ban van a lényeg
 var arts = explode("-", c[1]); //Ezek pedig a cikkek száma, amire már leadta a voksát. (Cookie sajnos nem terhelhető a végtelenségig, X mennyiségű cikk után ki fog akadni)
 if( in_array(article_id, arts) ) breaker = true;
}
});
 if( breaker ) return;

 var stars = $$(".ertekelo_csillag");
 stars.each(function(element){

 Event.observe(element, "mouseover", function(){
 for (var i=1;i<=5;i++){
 if( i<=element.getAttribute("number") ) $("ertekelo_csillag_"+i).src="/images/design/star"+i+".gif";
 else $("ertekelo_csillag_"+i).src="/images/design/star0.gif";
}
}.bind(element));

 Event.observe(element, "mouseout", function(){
 for (var i=1;i<=5;i++){
 if( i<=voted_value ) $("ertekelo_csillag_"+i).src="/images/design/star"+i+".gif";
 else $("ertekelo_csillag_"+i).src="/images/design/star0.gif";
}
}.bind(element));

 Event.observe(element, "click", function(){
 var ertek = element.getAttribute("number");
 var result = miracle.ajax("dental_newsz", "vote_article",{'article_id': article_id, 'num': ertek});
 var block = $("vote_block"); 
 if( block ){block.innerHTML = result; initStars();}
}.bind(element));
});
}



function tabs(){
 if( !$("module_dental_newsz") ) return; //Biztosítás, hogy több féle tab ne ütközzön

 $A(document.getElementsByClassName("tab_container")).each(function(element){
 $A(element.getElementsByClassName("tab")).each(function(element2){
 element2.observe("click", function(event){
 var actual_id=element2.getAttribute('tab');

 $A(element.getElementsByClassName("tab")).each(function(element3){
 element3.removeClassName("active");
 element3.addClassName("inactive");
 if( element3.getAttribute('tab') == actual_id ){

 element3.removeClassName("inactive");
 element3.addClassName("active");
}
});

 $A(document.getElementsByClassName("tab_content")).each(function(element4){
 if (!element4.hasClassName('tab'+actual_id)) element4.addClassName("hide");
 else element4.removeClassName("hide");
});
 
});
});
});
}

function mini_w(){
 $$("a[rel=send_article]").each(function(element){
 Event.observe(element, "click", function(event){

 var banners = $$("div.banner");

 if( banners.length ){
 banners.each( function (banner){
 banner.style.display = "none";
});
}

 var darker = $("photogallery2_darken");
 if( darker ) darker.style.display = "block";
 
 var element = this;
 var win = new Window("IE_window",{
 className: "dialog", 
 title: element.title, 
 width: 400, 
 height: 300,
 draggable: true,
 minimizable: false,
 maximizable: false,
 resizable: false, 
 url: element.getAttribute("href") 
});
 win.show(); 
 win.setDestroyOnClose()
 win.showCenter();
 Event.stop(event); 
}.bind(element));
});

 $$("a[rel=send_oppinion]").each(function(element){
 Event.observe(element, "click", function(event){

 var banners = $$("div.banner");

 if( banners.length ){
 banners.each( function (banner){
 banner.style.display = "none";
});
}

 var darker = $("photogallery2_darken");
 if( darker ) darker.style.display = "block";
 
 var element = this;

 var win = new Window("IE_window",{
 className: "dialog", 
 title: element.title, 
 width: 400, 
 height: 350,
 draggable: true,
 minimizable: false,
 maximizable: false,
 resizable: false, 
 url: element.getAttribute("href") 
});
 win.show(); 
 win.setDestroyOnClose();
 win.showCenter();

 Event.stop(event); 
}.bind(element));
});
}


function bannersOn(){

 var banners = $$("div.banner");
 if( banners.length){
 banners.each( function (elem){
 elem.style.display = "block";
})
}
}




function explode( delimiter, string, limit ){













 
 var emptyArray ={0: ''};

 if ( arguments.length < 2
 || typeof arguments[0] == 'undefined'
 || typeof arguments[1] == 'undefined' )
{
 return null;
}
 
 if ( delimiter === ''
 || delimiter === false
 || delimiter === null )
{
 return false;
}
 
 if ( typeof delimiter == 'function'
 || typeof delimiter == 'object'
 || typeof string == 'function'
 || typeof string == 'object' )
{
 return emptyArray;
}
 
 if ( delimiter === true ){
 delimiter = '1';
}
 
 if (!limit){
 return string.toString().split(delimiter.toString());
}else{

 var splitted = string.toString().split(delimiter.toString());
 var partA = splitted.splice(0, limit - 1);
 var partB = splitted.join(delimiter.toString());
 partA.push(partB);
 return partA;
}
}

function in_array(needle, haystack, strict){








 var found = false, key, strict = !!strict;

 for (key in haystack){
 if ((strict && haystack[key] === needle) || (!strict && haystack[key] == needle)){
 found = true;
 break;
}
}

 return found;
}





 



var moduleTags = function(){
 var self = this;
 var tags = new Array(); // cimkék tomb elinditasa




 var miracleModuleName = "tags";
 var ModuleNameForAjax;
 var elementfocus = false;

 this.init = function(){

 var searchAttribute = $$("div[tagsmodulename]");
 if( !searchAttribute.length ) return false;
 ModuleNameForAjax = searchAttribute[0].getAttribute("tagsmodulename");

 var TagInput = $(miracleModuleName+'-tag'); // input mezo

 if(!TagInput) return false;
 Event.observe(TagInput, "keypress", function(ev){
 if(ev.keyCode==13){
 self.AddNewTag();
 ev || (ev = window.event); 
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 return false;
}
});

 var submitButton = $('tags-SubmitButton');
 if( submitButton ){
 submitButton.onclick = function(ev){
 var params ={};
 params.tags = tags; 
 
 var parentId = $(miracleModuleName+"-parentId");
 var parentTable = $(miracleModuleName+"-parentTable");
 var lang = $(miracleModuleName+"-lang");
 
 if( parentId ){
 params.parentId = parentId.value;
}
 if( parentTable ){
 params.parentTable = parentTable.value;
}
 if( lang ){
 params.lang = lang.value;
}
 
 miracle.ajax(ModuleNameForAjax, "add_tags", params);
 alert("Címkék sikeresen mentve!");
}
}

 if($('AddNewTagImage') && $('AddNewTag')){
 $('AddNewTagImage').style.display="none";
 $('AddNewTag').style.display="block";
}

 if(!$('tag_container')){
 return false;
}
 
 var Container = $('tag_container');
 if(Container.value!=""){
 tags = self.GenererateArrayFromContainer();
 self.UpdatePublicTags();
}
}

 this.get_tags = function(){
 var cont = $('tags_sample');
 var parentTable = $(miracleModuleName+"-parentTable");
 var lang = $(miracleModuleName+"-lang");
 var param ={};
 
 if( parentTable ) param.parentTable = parentTable.value;
 if( lang ) param.lang = lang.value;
 
 result = miracle.ajax(ModuleNameForAjax, "get_tags", param);
 if( typeof(result) == "object" ){
 var htmlContent = "";
 result.each( function(obj){
 htmlContent += '<span class="oftenTag"><a href="javascript:void(0)">'+obj+'</a>, </span>';
});
 cont.innerHTML = htmlContent;
 var oftenTags = $$("span.oftenTag a");
 oftenTags.each( function(oftenTag){
 oftenTag.onclick = function(){
 self.AddNewTagForce(oftenTag.innerHTML);
 oftenTag.parentNode.parentNode.removeChild(oftenTag.parentNode);
}
});
}
}

 this.AddNewTag = function(){
 var TagInput = $(miracleModuleName+'-tag'); // input mezo
 var Container = $('tag_container'); // textarea mezo
 
 TagInput.value = (TagInput.value.strip());
 TagInput.value = (TagInput.value.stripTags());
 
 if(self.CheckTagValidation()=="stop"){// kodmentesites, vesszotlenites, trim (strip), stb.
 return false;
}
 else if(self.CheckTagEmpty()=="stop"){// ellenorzi, hogy ne elgyen ures a cimke
 return false;
}
 else if(self.CheckTagHTML()=="stop"){// html elemek kezelese
 return false;
}
 else if(self.CheckTagRegExp()=="stop"){// nem lehet 1 betus cimke specialis karakter
 return false;
}
 
 var TagIsInvalid = self.CheckTag(TagInput.value);

 if(TagIsInvalid['error'] == false){// ellenorzi, hogy letezik -e mar ilyen cimke
 Container.value = (Container.value + TagInput.value+", ");
 tags.push( TagInput.value ); // beteszi a tombbe




 TagInput.value = "";

 self.UpdatePublicTags();
}
 else{
 self.NotAllowedTag(3, TagIsInvalid);

 TagInput.select();
}
}

 this.AddNewTagForce = function(x){
 if(!x)return false;
 var TagInput = $(miracleModuleName+'-tag'); // input mezo
 TagInput.value = x;
 self.AddNewTag();
}

 this.CheckTagRegExp = function(){
 var TagInput=$(miracleModuleName+'-tag'); // input mezo
 var re=new RegExp("\\b[a-zA-Z0-9]+\\b");
 if (TagInput.value.match(re)){

 return true;
}else{

 self.NotAllowedTag(4, false);
 TagInput.select();
 return "stop";
}
}

 this.CheckTag = function(newTag){
 var Output=new Array();
 var i=0;
 for (i;i<=(tags.length-1);i++){
 if(tags[i].toLowerCase()==newTag.toLowerCase()){

 Output['error']=true;
 if(tags[i]==newTag){
 Output[0]=newTag;
}
 else{
 Output[0]=tags[i]+" (<b>"+newTag+"</b>)";
}
 Output[1]=newTag;
 Output[2]=tags[i];
 return Output;
}
}

 Output[0] = Output[1] = Output[2] = Output['error'] = false;
 return Output;
}

 this.CheckTagValidation = function(){
 var TagInput=$(miracleModuleName+'-tag'); // input mezo
 var InValid=new RegExp(",");
 if(InValid.test(TagInput.value) == true){
 TagInput.value = (TagInput.value.replace(",", ""));
 TagInput.value = (TagInput.value.strip());
 TagInput.value = (TagInput.value.stripTags());
 if(!self.CheckTagValidation()){
 self.NotAllowedTag(1, false);
}
}

 

 

 else{
 self.CheckTagEmpty();
 return false;
}
}

 this.CheckTagEmpty = function(){
 var TagInput = $(miracleModuleName+'-tag'); // input mezo
 if(TagInput.value=="" || TagInput.value==","){
 self.NotAllowedTag(2,false);
 return "stop";
}
}
 
 this.CheckTagHTML = function(){
 var TagInput=$(miracleModuleName+'-tag');
 var InValid=new Array();
 InValid[0]=new RegExp("&");
 InValid[1]=new RegExp("\"");
 InValid[2]=new RegExp("\'");
 InValid[3]=new RegExp("<");
 InValid[4]=new RegExp(">");
 var i=0;
 for (i; i<=(InValid.length-1); i++){
 if(InValid[i].test(TagInput.value) == true){
 self.NotAllowedTag(5, false);
 TagInput.select();
 return "stop";
}
}
 return true;
}

 this.hideError = function(){
 var tagError = $('TagError');
 tagError.hide();
}
 
 this.showError = function(){
 var tagError = $('TagError');
 tagError.show();
}

 this.NotAllowedTag = function(errormsg, extramsg){
 var TagInput = $(miracleModuleName+'-tag'); // input mezo
 var TagContainer = $('Tags'); // 'Tags' div mezo

 if(errormsg<1){errormsg = 0;}
 if(errormsg>10){errormsg = 0;}
 
 if(errormsg == 0){
 $('TagError').innerHTML = self.ErrorMassage(0) +" <u>"+extramsg[0]+"</u>";
 self.showError();
 setTimeout(function(){self.hideError();}, 10000);
}
 else if(errormsg == 3){
 $('TagError').innerHTML = self.ErrorMassage(errormsg) +" <u>"+extramsg[0]+"</u>";
 self.showError();
 setTimeout(function(){self.hideError();}, 10000);
 TagContainer.innerHTML = (TagContainer.innerHTML.replace("> "+extramsg[2]+", ", "> <b>"+extramsg[2]+"</b>, "));
 setTimeout("$('Tags').innerHTML = ($('Tags').innerHTML.replace(' <b>"+extramsg[2]+"</b>, ', ' "+extramsg[2]+", '));", 10000);
}
 else{
 $('TagError').innerHTML = self.ErrorMassage(errormsg);
 self.showError();
 setTimeout(function(){self.hideError();}, 10000);
}
 return "";
}
 
 this.ErrorMassage = function(errorid){
 if(errorid < 0) errorid=0;
 var ReturnText = $('Lang'+(errorid)).value.strip();


 return ReturnText;
}

 this.Button = function(i){
 var button_layer = '<span id="TagContainer'+i+'">';
 var button_edit = '<span onclick="tagsControl.EditTag('+i+')"><img src="/images/miracle/icons/pencil.png" border="0" /></span>';
 var button_del = '<span onclick="tagsControl.RemoveTag('+i+')"><img src="/images/miracle/icons/delete.png" border="0" /></span>';



 return button_layer + button_edit + button_del + " ";
}

 this.UpdatePublicTags = function(){

 var TagContainer = $('Tags'); // ide mennek a tomb elemei (publikus)

 var AllTagInOne = "";
 
 i=0;
 for (i; i<=(tags.length-1); i++){
 if(tags[i]!=""){
 AllTagInOne += self.Button(i)+tags[i].stripTags()+", </span>";
}
}
 TagContainer.innerHTML = AllTagInOne;
 self.UpdateBackendTags();
}

 this.UpdateBackendTags = function(){
 var Container = $('tag_container');
 var AllTagInOne = "";
 var i=0;
 for (i; i<=(tags.length-1); i++){
 if(tags[i]!=""){
 AllTagInOne += tags[i].stripTags()+', ';
}
}
 Container.value = AllTagInOne;
}

 this.EditTag = function(index){

 var TagInput = $(miracleModuleName+'-tag');
 var i=0;
 for (i; i<=(tags.length-1); i++){
 if(i == index){
 TagInput.value = tags[i];
 TagInput.select();
 tags[i] = "";
 self.KillTagSpan(index);
}
}
 self.UpdatePublicTags();
}

 this.RemoveTag = function(index){

 var i=0;
 for (i; i<=(tags.length-1); i++){
 if(i == index){
 tags[i] = "";
 self.KillTagSpan(index);
}
}
 self.UpdatePublicTags();
}
 
 this.KillTagSpan = function(index){
 var TagSpan = $('TagContainer'+index);
 TagSpan.innerHTML = "";
}

 this.GenererateArrayFromContainer = function(){
 var Container = $('tag_container');
 var AllTagFromCont = explode(', ', Container.value);
 var AllTagInOne = "";
 var i=0;

 AllTagFromCont[(AllTagFromCont.length-1)] = (AllTagFromCont[(AllTagFromCont.length-1)].replace(",", ""));
 return AllTagFromCont;
}
}


var tagsControl = new moduleTags();
Event.observe(window, "load", function(){tagsControl.init()});



function explode( delimiter, string ){


 var emptyArray ={0: ''};
 if ( arguments.length != 2
 || typeof arguments[0] == 'undefined'
 || typeof arguments[1] == 'undefined' )
{
 return null;
}
 if ( delimiter === ''
 || delimiter === false
 || delimiter === null )
{
 return false;
}
 if ( typeof delimiter == 'function'
 || typeof delimiter == 'object'
 || typeof string == 'function'
 || typeof string == 'object' )
{
 return emptyArray;
}
 if ( delimiter === true ){
 delimiter = '1';
}
 return string.toString().split ( delimiter.toString() );
}









addEvent(window, "load", init_login);
miracle.initAction(init_login);


function init_login(){
 init_zipcode();
}

function init_zipcode(){
 zipcodes=document.getElementsByTagNameAndAttribute("input", "accept", "zipcode");


 for (var i=0; i<zipcodes.length; i++){
 zipcodes[i].onchange=getCityByZipCode;
}
}

function getCityByZipCode(){

 zipcode=parseInt(this.value, 10);
 if (zipcode>999 && zipcode<10000){
 pattern=new RegExp ('zipcode','ig');
 cityid=this.id.replace(pattern, 'city');
 if (document.getElementById(cityid)){
 params=new Array();
 params[0]=zipcode;
 cityNode=document.getElementById(cityid);
 handlerparams=new Array(cityNode)
 miracle.ajax("miracle", "zipcode", params, 
 function (response){
 cityHandler(handlerparams, response);
});
}
}else{
 cityNode.readOnly=false;
}
}

function cityHandler(handlerparams, response){
 if (response!=''){
 handlerparams[0].value=response;
 handlerparams[0].readOnly=true;
}else{
 handlerparams[0].readOnly=false;
}
}

function getZipCodeBy(){

 zipcode=parseInt(this.value, 10);
 if (zipcode>999 && zipcode<10000){
 pattern=new RegExp ('zipcode','ig');
 cityid=this.id.replace(pattern, 'city');
 if (document.getElementById(cityid)){
 params=new Array();
 params[0]=zipcode;
 cityNode=document.getElementById(cityid);
 city=server_action("miracle","zipcode", params, false);
 if (city!=''){
 cityNode.value=city;
}
}
}
}



function onlyInteger(){

}





miracle.initAction(tabsy);

addEvent(window, "load", initDental);
addEvent(window, "load", initCaptcha);
addEvent(window, "load", initSameas);




var cRegHelp = function(){
 var self = this;
 var pages;

 this.hidePages = function(){
 pages.each( function(page){
 page.addClassName("hide");
});
}

 this.visiblePage = function(which){
 if( which <= pages.length ){
 self.hidePages();
 pages[which-1].removeClassName("hide");
}
}

 this.init = function(){
 pages = $$("div.reg-help-page");
}
}

var RegHelp = new cRegHelp();
Event.observe(window, "load", RegHelp.init);


function initSameas(){
 var i = $("sameas");
 if( i ){
 i.checked = false;
 Event.observe(i, "click", function (ev){
 if( i.checked == true ){
 var s, s2, d;

 var poss = new Array("reg_step0", "modify_user");
 for( x in poss ){
 s = $(poss[x]+"_address__address_zipcode_");
 d = $(poss[x]+"_address__zipcode_");
 if( s && d ){
 d.value = s.value;
}
 
 s = $(poss[x]+"_lastname");
 s2 = $(poss[x]+"_firstname");
 d = $(poss[x]+"_address__name_");
 if( s && d ){
 d.value = s.value + " " + s2.value;
}
 
 s = $(poss[x]+"_address__address_street_");
 d = $(poss[x]+"_address__address_"); //Nem elírás, DB-ben address van.
 if( s && d ){
 d.value = s.value;
}
 
 s = $(poss[x]+"_address__address_city_");
 d = $(poss[x]+"_address__city_");
 if( s && d ){
 d.value = s.value;
}
 
 s = $(poss[x]+"_address__address_countyid_");
 d = $(poss[x]+"_address__countyid_");
 if( s && d ){
 d.value = s.value;
}
}
}//checked

});
}
}

function initCaptcha(){
 var button=document.getElementById("captcha_button");
 if (button){
 button.onclick=function(ev){
 var img=document.getElementById("captcha_img");
 img.src="/captcha.jpg?"+Math.random();

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

 return false;
}
}
}

function initDental(){

 var reg_button = document.getElementById("reg_step0_check_fields");
 if (reg_button) addEvent(reg_button,"click",check_fields);

 var reg_button2 = document.getElementById("check_fields2");
 if (reg_button2) addEvent(reg_button2,"click",check_fields2);

 var reg_button = document.getElementById("modify_user_check_fields");
 if (reg_button) addEvent(reg_button,"click",mu_check_fields);

 var del_pp_button = document.getElementsByClassName("del_pp");
 if( del_pp_button && del_pp_button.length>0){
 del_pp_button.each( function (button){
 addEvent(button,"click", function (ev){
 if( confirm("Biztosan törölni akarja a személyes honlapját?") &&
 miracle.ajax("dental_user", "delete_personal_page", null, false) ){
 alert("A honlapot sikeresen töröltük!");
 var elmnts = $('modify_user_subdomain');
 if( elmnts ) elmnts.value = "";
}
});
});
}

 var submit_buttons = document.getElementsByClassName("regbutton_left");
 var sm_bt = document.getElementsByClassName("regbutton_center");
 if( sm_bt && sm_bt.length>0 ) submit_buttons.push(sm_bt[0]);
 if (submit_buttons){
 submit_buttons.each( function (button){
 addEvent(button,"click", function (ev){
 ev || (ev = window.event); 
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 
 if( $("reg_step0_form") ) is_valid_domain($("reg_step0_form"));
 if( $("modify_user_form") ) is_valid_domain($("modify_user_form"));
});
});
}
}

function is_valid_domain(submitter){
 var fields = field_value_collector();
 if( !error_report("is_valid_domain", miracle.ajax("dental_user", "is_valid_domain", fields, false)) ){
 return false;
}
 submitter.submit();
}


function error_report(where, err_num){
 var what = "";
 $(where).style.display = "none";
 if( !err_num ) return 1;
 if( (err_num & 1)==1 ) what += "A csillaggal megjelölt mezők kitöltése kötelező!<br />";
 if( (err_num & 2)==2 ) what += "A két jelszó nem egyezik!<br />";
 if( (err_num & 4)==4 ) what += "Az igényelt domain név már foglalt!<br />";
 if( (err_num & 8)==8 ) what += "Az igényelt felhasználó név már foglalt!<br />";
 if( what!="" ){
 $(where).style.display = "block";
 $(where).innerHTML = what;
 return 0; //have error
}
 return 1; //no error
}

function field_value_collector(){
 var values ={}
 var x,y;

 if (!$("module_reg_step0")){
 if (!$("module_modify_user")) return 0;
 else y = $("module_modify_user").getElementsByTagName("input");
}
 else y = $("module_reg_step0").getElementsByTagName("input");
 
 for(x in y){
 if( y[x].type && (y[x].type=="hidden" || y[x].type=="text" || y[x].type=="checkbox" || y[x].type=="password") ) values[y[x].name] = y[x].value;
}

 return values; 
}

function check_fields(ev, manual){
 ev || (ev = window.event); 

 var fields = field_value_collector();

 if( !fields ){
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 
 return false;
}

 if( !error_report("error_step1", miracle.ajax("dental_user", "checkfield1", fields, false)) ||
 !error_report("error_step4", miracle.ajax("dental_user", "checkpass", fields, false))){
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 
 return false;
}

 if( manual ) return true;

 tabselect(2);

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

 return false;
}

function check_fields2(ev, manual){
 ev || (ev = window.event); 

 var fields = field_value_collector();
 if( !fields ){
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 
 return false;
}


 if( !error_report("error_step2", miracle.ajax("dental_user", "checkfield2", fields, false)) ||
 !error_report("error_step3", miracle.ajax("dental_user", "checkfield3", fields, false))){
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 
 return false;
}

 if( manual ) return true;

 tabselect(3)

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

 return false;
}

function mu_check_fields(ev, manual){
 ev || (ev = window.event); 

 var fields = field_value_collector();
 if( !fields ){
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}
 
 return false;
}

 if( !error_report("error_step1", miracle.ajax("dental_user", "mu_checkfield", fields, false)) ){
 if (ev.preventDefault){
 ev.preventDefault(); ev.stopPropagation(); 
}else{
 ev.cancelBubble = true; ev.returnValue = false; 
}

 return false;
}

 if( manual ) return true;

 tabselect(2);

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

 return false;
}

function tabselect(ke){
 if( !ke ) return 0;
 $A(document.getElementsByClassName("tab_container")).each(function(element){
 $A(element.getElementsByClassName("tab")).each(function(element2){

 element2.removeClassName("active");
 element2.addClassName("inactive");

 if( element2.getAttribute('tab') == ke ){
 element2.removeClassName("inactive");
 element2.addClassName("active");

 var actual_id=element2.getAttribute('tab');
 
 $A(document.getElementsByClassName("tab_content")).each(function(element4){
 if (!element4.hasClassName('tab'+actual_id)) element4.addClassName("hide");
 else element4.removeClassName("hide");
});
}
 
});
});
 RegHelp.visiblePage(ke);
 return 1;
}

function tabsy(){
 if( !$("module_reg_step0") && !$("module_modify_user") ) return; //Védelem

 $A(document.getElementsByClassName("tab_container")).each(function(element){
 $A(element.getElementsByClassName("tab")).each(function(element2){
 element2.observe("click", function(event){
 var actual_id=element2.getAttribute('tab');

 var current_tabid = element.getElementsByClassName("active")[0].getAttribute('tab');
 var result = 1;
 switch (current_tabid){
 case "1":
 $("error_step1").style.display = "none";
 $("error_step4").style.display = "none";

 if( $("reg_step0_check_fields") ) result = check_fields(1,1)
 else result = mu_check_fields(1,1)
 if( actual_id == 3){
 if( !check_fields2(1,1) ) actual_id = 2;
}
 break;
 case "2":
 $("error_step2").style.display = "none";
 $("error_step3").style.display = "none";
 if( actual_id<current_tabid ) break;
 result = check_fields2(1,1);
 break;
 case "3":
 $("is_valid_domain").style.display = "none";
}
 if( !result ) return;

 $A(element.getElementsByClassName("tab")).each(function(element3){
 element3.removeClassName("active");
 element3.addClassName("inactive");
 if( element3.getAttribute('tab') == actual_id ){

 element3.removeClassName("inactive");
 element3.addClassName("active");
}
});

 $A(document.getElementsByClassName("tab_content")).each(function(element4){
 if (!element4.hasClassName('tab'+actual_id)) element4.addClassName("hide");
 else element4.removeClassName("hide");
});
 RegHelp.visiblePage(actual_id);
 
});
});
});

}





Event.observe(window, 'load', function(){
 var subpageLogo = $$("div.registration a");
 if( subpageLogo.length ){
 subpageLogo.each( function(logo){
 Event.observe(logo, "mouseover", function(ev){createTooltip(ev);});
 Event.observe(logo, "mousemove", function(ev){moveTooltip(ev);});
 Event.observe(logo, "mouseout", function(ev){removeTooltip();});
});
}
});


function createTooltip(ev){
 ev || (ev = window.event); 
 
 var source; 
 if (typeof ev.target != 'undefined'){
 source = ev.target; 
}else if (typeof ev.srcElement != 'undefined'){
 source = ev.srcElement; 
}else{return(true);}

 var tooltip = $("tooltip");
 if( tooltip ){
 tooltip.style.left = (document.all ? ev.clientX-150 : ev.pageX-150 + "px");
 tooltip.style.top = (document.all ? ev.clientY + document.body.scrollTop + document.documentElement.scrollTop + 15 : (ev.pageY + 15) + "px");
 tooltip.style.display = "block";
}
}

function removeTooltip(){
 var tooltip = $("tooltip");
 if( tooltip ){
 tooltip.style.display = "none";
}
}

function moveTooltip(ev){
 var tooltip = $("tooltip");
 if( tooltip ){

 ev || (ev = window.event); 

 tooltip.style.left = (document.all ? ev.clientX-150 : ev.pageX-150 + "px");
 tooltip.style.top = (document.all ? ev.clientY + document.body.scrollTop + document.documentElement.scrollTop + 15 : (ev.pageY + 15) + "px");
}
}





miracle.config.initExtensions.lightBox = true;
addEvent(window, "load", initGallery);

function initGallery(){
 var img_list_block = $('image_list_container');
 if (img_list_block){
 var module = img_list_block.getAttribute("module");
 var entity = img_list_block.getAttribute("entity");
 $A(img_list_block.getElementsByTagName("*")).each(function(element){
 var action = element.getAttribute("action");
 var parameters = element.getAttribute("parameters"); 
 if (action && parameters){
 var message = element.getAttribute("message");
 Event.observe(element, 'click', function(event){
 if (message) miracle.ajaxMessage(message);
 if (browser.isOpera){
 action = action.split("/").last();
}
 if (
 (action.substring(0, 6)!="delete") ||
 (action.substring(0, 6)=="delete" && confirm("Biztos törlöd?")) 
 ){
 var tmp = miracle.ajax(module, action, parameters, false);
 if (tmp){
 var pic_id=entity+"_"+element.getAttribute("recordid");
 var pic_div=document.getElementById(pic_id);
 $(pic_id).setStyle({display: 'none'});
}
}
});
}
});
}
}

function change_main_image(newSrc, imageId){
 
 $(imageId).src = newSrc;
}

miracle.hoverEmulation("#module_photogallery2 .thumb_container .scroll_left");

function photogallery2(){
 $$("a[rel=photogallery2]").each(function(element){
 Event.observe(element, "click", function(event){

 $("photogallery2_darken").style.display="block";

 var element = this;
 var win = new Window("photogallery2_window",{
 className: "dialog",
 title: element.title,
 width: 681,
 height: 450,
 draggable: true,
 minimizable: false,
 maximizable: false,
 resizable: false,
 url: element.getAttribute("href")
});
 win.show();
 win.setDestroyOnClose();
 win.showCenter();
 Event.stop(event);
}.bind(element));
});
}

function photogallery2_scroll(){
 if (!$("module_photogallery2")) return


 $("scroll_table").style.left="1px";
 var ua = navigator.userAgent.toLowerCase();
 
 $("module_photogallery2").getElementsByClassName("scroll_left").each(function(element){
 element.observe("mouseover", function(event){
 $("is_scroll_left").value="true";
 scroll_left(0);
});
});
 
 $("module_photogallery2").getElementsByClassName("scroll_right").each(function(element){
 element.observe("mouseover", function(event){
 $("is_scroll_right").value="true";

 if (ua.indexOf('msie') != -1)
 $("sr").style.background="#f2f1f0 url(/images/window/photogallery2_scroll_right_hover.jpg) no-repeat 50%";

 scroll_right(0);
});
});
 
 $("module_photogallery2").getElementsByClassName("scroll_left").each(function(element){
 element.observe("mouseout", function(event){
 $("is_scroll_left").value="false";
});
});

 $("module_photogallery2").getElementsByClassName("scroll_right").each(function(element){
 element.observe("mouseout", function(event){
 if (ua.indexOf('msie') != -1)
 $("sr").style.background="#f2f1f0 url(/images/window/photogallery2_scroll_right.jpg) no-repeat 50%";

 $("is_scroll_right").value="false";
});
});
}

function scroll_left(width){
 if (!$("scroll_table")) return;
 var scroll=$("scroll_table").style.left;
 scroll=parseInt(scroll,10);

 var ua = navigator.userAgent.toLowerCase();
 if (ua.indexOf('msie') != -1) var speed=10;
 else var speed=1;

 if (width>0) scroll=scroll+width;
 else scroll=scroll+speed;
 scroll=parseInt(scroll,10);
 if (scroll>0){
 $("scroll_table").style.left=10+"px";
 return;
}
 $("scroll_table").style.left=scroll+"px";
 if ($("is_scroll_left").value=="true") setTimeout(scroll_left,30);
}

function scroll_right(width){
 if (!$("scroll_table")) return;
 if ($("scroll_table").offsetWidth<600) return;
 var scroll=$("scroll_table").style.left;
 scroll=parseInt(scroll,10);

 var ua = navigator.userAgent.toLowerCase();
 if (ua.indexOf('msie') != -1) var speed=10;
 else var speed=1;

 if (width>0) scroll=scroll-width;
 else scroll=scroll-speed;
 scroll=parseInt(scroll,10);

 var ua = navigator.userAgent.toLowerCase();
 if (ua.indexOf('msie') != -1) var hossz=594;
 else var hossz=610;

 hatar=($("scroll_table").offsetWidth)-hossz;
 if (scroll<-hatar){
 $("scroll_table").style.left=-hatar+"px";
 return;
}
 $("scroll_table").style.left=scroll+"px";
 if ($("is_scroll_right").value=="true") setTimeout(scroll_right,30);
}

function change_main_image(src,act_thumb){
 if (!$("gallery_main_image")) return;
 $("gallery_main_image").src="/gallery/"+src;
 $("gallery_main_image").style.width="1px";
 $("gallery_main_image").style.height="1px";

 $("gallery_main_image").style.width="auto";
 $("gallery_main_image").style.height="auto";

 $("module_photogallery2").getElementsByClassName("photogallery2_thumb_image").each(function(element){
 element.style.padding="3px";
 element.style.border="1px solid #b7b0aa";
});

 thumb=$("thumb_"+act_thumb);
 thumb.style.padding="1px";
 thumb.style.border="3px solid #C12226";

 x=Position.cumulativeOffset(thumb);
 x=parseInt(x,10);
 if (x+thumb.offsetWidth>637) scroll_right(thumb.offsetWidth-(637-x));
 if (x<35) scroll_left(Math.abs(35-x));

 $("actual_image").value=act_thumb;


 $("module_photogallery2").getElementsByClassName("picture_title").each(function(element){
 element.style.display="none";
});

 $("picture_title_"+act_thumb).style.display="block";

}

function next_image(){
 if (!$("module_photogallery2")) return;
 $("module_photogallery2").getElementsByClassName("next_image").each(function(element){
 element.observe("click", function(event){
 var actual=parseInt($("actual_image").value,10);
 var max_images=parseInt($("max_images").value,10);
 if (actual>=max_images) return;
 actual++;
 $("actual_image").value=actual;
 image_change(actual);
});
});
}

function previous_image(){
 if (!$("module_photogallery2")) return;
 $("module_photogallery2").getElementsByClassName("previous_image").each(function(element){
 element.observe("click", function(event){
 actual=parseInt($("actual_image").value,10);
 if (actual<=1) return;
 actual--;
 $("actual_image").value=actual;
 image_change(actual);
});
});
}

function image_change(actual){
 if (!$("module_photogallery2")) return;

 $("module_photogallery2").getElementsByClassName("thumbs").each(function(element){
 if (element.hasClassName("thumb_"+actual)){
 src=element.getAttribute("next_img");
 change_main_image(src,actual);
 return;
}
});
}

function pg2_change_image_hover(){
 document.getElementsByClassName("pg2_change_image").each(function(element){
 element.observe("mouseover", function(event){
 if (parseInt($("pg2_image_count").innerHTML)<2) return;
 if ($("pg2_image_hover").innerHTML=="true") return;
 $("pg2_image_hover").innerHTML="true";
 pg2_change_img(element,'',1,2000);
});
});
}

function pg2_change_image_out(){
 document.getElementsByClassName("pg2_change_image").each(function(element){
 element.observe("mouseout", function(event){
 $("pg2_image_hover").innerHTML="false";
});
});
}

function pg2_change_img(element,img,x,time){
 if ($("pg2_image_hover").innerHTML!="true"){
 $("pg2_timer").innerHTML="false";
 return;
}
 
 if (x==2){
 $(element).src="/gallery/"+img;

 $(element).up('a',0).href="/gallery/view_gallery/"+$("pg2_gallery_id").innerHTML.replace(/^\s+|\s+$/g,"")+"/"+$("pg2_full_image_name_"+parseInt($("pg2_actual_image").innerHTML)).innerHTML.replace(/^\s+|\s+$/g,"");
 $(element).style.width="auto";
 $(element).style.height="auto";


 x=1;
 element=$(element);
 $("pg2_timer").innerHTML="false";
}
 if (x==1 && $("pg2_timer").innerHTML.replace(/^\s+|\s+$/g,"")=="false"){
 $("pg2_timer").innerHTML="true";
 var actual_image=parseInt($("pg2_actual_image").innerHTML);
 var element_id=element.getAttribute("id");
 var next_image=parseInt(actual_image)+1;
 if (next_image>parseInt($("pg2_image_count").innerHTML)) next_image=1;
 $("pg2_actual_image").innerHTML=next_image;
 new_image=parseInt($("pg2_actual_image").innerHTML);
 var img=$("pg2_image_name_"+new_image).innerHTML.replace(/^\s+|\s+$/g,"");
 
 var fgv="pg2_change_img('"+element_id+"','"+img+"',2,"+time+")";
 setTimeout(fgv,time);
}
}


Event.observe(window, 'load', function(){
 var inputField = $("box_edit_weight");
 if( inputField ){
 Event.observe(inputField, "mouseover", function(ev){createTooltip(ev);});
 Event.observe(inputField, "mousemove", function(ev){moveTooltip(ev);});
 Event.observe(inputField, "mouseout", function(ev){removeTooltip();});
}
});