var Prototype = {
Version: '1.5.0_rc1',
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);

/* Force "Connection: close" for Mozilla browsers to work around
* a bug where XMLHttpReqeuest sends an incorrect Content-length
* header. See Mozilla Bugzilla #246651.
*/
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();
}

document.getElementsByClassName = function(className, parentElement) {
var children = ($(parentElement) || document.body).getElementsByTagName('*');
return $A(children).inject([], function(elements, child) {
if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
elements.push(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)) {
/* Emulate HTMLElement, HTMLFormElement, HTMLInputElement, HTMLTextAreaElement,
and HTMLSelectElement in Safari */
['', '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) {
var elements = Form.getElements($(form));
var queryComponents = new Array();

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

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

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

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

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

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

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

return matchingInputs;
},

disable: function(form) {
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 = '';
return element;
},

enable: function(element) {
element = $(element);
element.blur();
element.disabled = 'true';
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) {
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();











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 : 1.0 });
if(/MSIE/.test(navigator.userAgent) && !window.opera)
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) && !window.opera)
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) {
var classNameRegExp = new RegExp("(^|\\s)" + className + "(\\s|$)");
var results = $A($(element).getElementsByTagName('*'))[findFirst ? 'detect' : 'select']( function(c) { 
return (c.className && c.className.match(classNameRegExp));
});
if(!results) results = [];
return results;
}

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



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



var Effect = {
_elementDoesNotExistError: {
name: 'ElementDoesNotExistError',
message: 'The specified DOM element does not exist, but is required for this effect to operate'
},
tagifyText: function(element) {
if(typeof Builder == 'undefined')
throw("Effect.tagifyText requires including script.aculo.us' builder.js library");

var tagifyStyle = 'position:relative';
if(/MSIE/.test(navigator.userAgent) && !window.opera) 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; 



Effect.Transitions = {}

Effect.Transitions.linear = Prototype.K;

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,
fps:25.0,
sync:false, 
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(!this.element) throw(Effect._elementDoesNotExistError);

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

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




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: Math.round(this.options.x* position + this.originalLeft) + 'px',
top:Math.round(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);
if(!this.element) throw(Effect._elementDoesNotExistError);
var options = Object.extend({
scaleX: true,
scaleY: true,
scaleContent: true,
scaleFromCenter: false,
scaleMode: 'box',
scaleFrom: 100.0,
scaleTo:percent
}, arguments[2] || {});
this.start(options);
},
setup: function() {
this.restoreAfterFinish = this.options.restoreAfterFinish || false;
this.elementPositioning = this.element.getStyle('position');

this.originalStyle = {};
['top','left','width','height','fontSize'].each( function(k) {
this.originalStyle[k] = this.element.style[k];
}.bind(this));

this.originalTop= this.element.offsetTop;
this.originalLeft = this.element.offsetLeft;

var fontSize = this.element.getStyle('font-size') || '100%';
['em','px','%','pt'].each( function(fontSizeType) {
if(fontSize.indexOf(fontSizeType)>0) {
this.fontSize= parseFloat(fontSize);
this.fontSizeType = fontSizeType;
}
}.bind(this));

this.factor = (this.options.scaleTo - this.options.scaleFrom)/100;

this.dims = null;
if(this.options.scaleMode=='box')
this.dims = [this.element.offsetHeight, this.element.offsetWidth];
if(/^content/.test(this.options.scaleMode))
this.dims = [this.element.scrollHeight, this.element.scrollWidth];
if(!this.dims)
this.dims = [this.options.scaleMode.originalHeight,
this.options.scaleMode.originalWidth];
},
update: function(position) {
var currentScale = (this.options.scaleFrom/100.0) + (this.factor * position);
if(this.options.scaleContent && this.fontSize)
this.element.setStyle({fontSize: this.fontSize * currentScale + this.fontSizeType });
this.setDimensions(this.dims[0] * currentScale, this.dims[1] * currentScale);
},
finish: function(position) {
if (this.restoreAfterFinish) this.element.setStyle(this.originalStyle);
},
setDimensions: function(height, width) {
var d = {};
if(this.options.scaleX) d.width = Math.round(width) + 'px';
if(this.options.scaleY) d.height = Math.round(height) + 'px';
if(this.options.scaleFromCenter) {
var topd= (height - this.dims[0])/2;
var leftd = (width- this.dims[1])/2;
if(this.elementPositioning == 'absolute') {
if(this.options.scaleY) d.top = this.originalTop-topd + 'px';
if(this.options.scaleX) d.left = this.originalLeft-leftd + 'px';
} else {
if(this.options.scaleY) d.top = -topd + 'px';
if(this.options.scaleX) d.left = -leftd + 'px';
}
}
this.element.setStyle(d);
}
});

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

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'),
top:element.style.top,
left: element.style.left,
width: element.style.width,
height: element.style.height
};
return new Effect.Parallel(
[ new Effect.Scale(element, 200, 
{ sync: true, scaleFromCenter: true, scaleContent: true, restoreAfterFinish: true }), 
new Effect.Opacity(element, { sync: true, to: 0.0 } ) ], 
Object.extend({ duration: 1.0, 
beforeSetupInternal: function(effect) {
Position.absolutize(effect.effects[0].element)
},
afterFinishInternal: function(effect) {
effect.effects[0].element.hide();
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, Object.extend({
duration: 0.4,
from: 0,
transition: Effect.Transitions.flicker,
afterFinishInternal: function(effect) {
new Effect.Scale(effect.element, 1, { 
duration: 0.3, scaleFromCenter: true,
scaleX: false, scaleContent: false, restoreAfterFinish: true,
beforeSetup: function(effect) { 
effect.element.makePositioned();
effect.element.makeClipping();
},
afterFinishInternal: function(effect) {
effect.element.hide();
effect.element.undoClipping();
effect.element.undoPositioned();
effect.element.setStyle({opacity: oldOpacity});
}
})
}
}, arguments[1] || {}));
}

Effect.DropOut = function(element) {
element = $(element);
var oldStyle = {
top: element.getStyle('top'),
left: element.getStyle('left'),
opacity: element.getInlineOpacity() };
return new Effect.Parallel(
[ new Effect.Move(element, {x: 0, y: 100, sync: true }), 
new Effect.Opacity(element, { sync: true, to: 0.0 }) ],
Object.extend(
{ duration: 0.5,
beforeSetup: function(effect) {
effect.effects[0].element.makePositioned(); 
},
afterFinishInternal: function(effect) {
effect.effects[0].element.hide();
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: window.opera ? 0 : 1,
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) && !window.opera){
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, window.opera ? 0 : 1,
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] || {}));
};

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

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

Element.addMethods();ip = {
pageHistory:array = [],
pageHistoryStep:number = 0,

update:function(placeholder, url, logEvent){
var url = url.replace('__', '?');

if(logEvent){

ip.pageHistory.push(placeholder+'|'+url);

window.location.hash = placeholder+'|'+url.replace('?', '__');
}

var url = url.split('?');
var updater = new Ajax.Updater({success: placeholder}, url[0], {
method: 'get', 
parameters: url[1]+'&rand='+new Date().getTime(),
evalScripts: true
});
}

};

function testimonials(){
var t = $('testimonials');
if(t){
fade_testimonials(t);
}
}

function fade_testimonials(){
var t = $('testimonials');
if(t){
Effect.Appear(t, {duration: 0.5, from:1, to:0, queue: 'end'});
setTimeout(update_testimonials, 1000);
}
}

function update_testimonials(){
var t = $('testimonials');
if(t){
var updater = new Ajax.Updater({success: t}, 'testimonials.php', {
method: 'get', 
parameters: 'rand='+new Date().getTime(),
evalScripts: true,
onSuccess: setTimeout(unfade_testimonials, 500)
});
}
}

function unfade_testimonials(){
var t = $('testimonials');
if(t){
Effect.Appear(t, {duration: 0.5, from:0, to:1, queue: 'end'});
}
}

var testInterval = setInterval(testimonials, 15000);
Ajax.Responders.register({
onCreate:function() {
if(Ajax.activeRequestCount > 0)
Effect.Appear('load_notification',{duration: 0.5, from:0, to:0.8, queue: 'end'});
ir.hideNote();
},
onComplete:function() {
if(Ajax.activeRequestCount == 0)
Effect.Fade('load_notification',{duration: 0.5, from:0.8, to:0, queue: 'end'});
init_scripts();
document.onkeydown = captureKeys; 
}
});

ir = {
addLoadEvent:function(func){
var oldonload = window.onload;
if(typeof window.onload != 'function') {
window.onload = func;
}else{
window.onload = function(){
oldonload();
func();
}
}
},


tooltipCache:object = {},
urlPattern:string = /\.php\?id=/i,

defaltTooltip:string = '<img src="images/ajax_indicator.gif" />',

getScroll:function() {
if(document.body.scrollTop != undefined){
var ieBox = document.compatMode != "CSS1Compat";
var cont = ieBox ? document.body : document.documentElement;
return {x : cont.scrollLeft, y : cont.scrollTop};
}else{
return {x : window.pageXOffset, y : window.pageYOffset};
}
},

showNote:function(e){
var objEvent = e ? e : event;
var objTip = $('tooltip');

if(ir.urlPattern.test(this.getAttribute('alt'))){

/*if(Ajax.activeRequestCount == 0 
&& ir.tooltipCache[this.getAttribute('alt')] 
&& ir.tooltipCache[this.getAttribute('alt')] != ir.defaltTooltip){
objTip.innerHTML = ir.tooltipCache[this.getAttribute('alt')];

}else{*/
ip.update(objTip, this.getAttribute('alt'), false);


}else{
objTip.innerHTML = this.getAttribute('alt');
}

var scroll = ir.getScroll();
ir.moveNote;
objTip.style.visibility = 'visible';
},

hideNote:function(e){
var objTip = $('tooltip');

if(ir.urlPattern.test(this.getAttribute('alt'))){

ir.tooltipCache[this.getAttribute('alt')] = objTip.innerHTML;

}

objTip.innerHTML = ir.defaltTooltip;
objTip.style.visibility = 'hidden';
},

moveNote:function(e){
var objEvent = e ? e : event;
var objTip = $('tooltip');
var scroll = ir.getScroll();


var dw = document.width ? document.width : document.documentElement.offsetWidth - 25;
if (objEvent.clientX > dw - objTip.offsetWidth){
objTip.style.left = dw - objTip.offsetWidth + scroll.x + "px";
}else{
objTip.style.left = objEvent.clientX - 2 + scroll.x + "px";
objTip.style.top = objEvent.clientY + 15 + scroll.y + "px";
}
}

};

function init_scripts(){
var anchors = document.getElementsByTagName('a');
var alength = anchors.length

myLightbox = new Lightbox();

for (i=0; i<alength; i++){
var anchor = anchors[i];


if(anchor.getAttribute('href').match('index.php?')){
anchor.onclick = function(){

if(this.getAttribute('rel') == 'menu'){
Element.removeClassName(document.getElementsByClassName("selected")[0], 'selected');
Element.addClassName(this, 'selected');
}

ip.update('contents', this.href+'&ajax_request=1', true);
return false;
}
}

if(anchor.getAttribute('alt')){


anchor.onmouseover = ir.showNote;
anchor.onmousemove = ir.moveNote;
anchor.onmouseout = ir.hideNote;
}

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

 function captureKeys(e) {
if (e == null) { 
keycode = event.keyCode;
} else { 
keycode = e.which;
}
if (keycode==8){ 
if (ip.pageHistory.length>1){
var url = ip.pageHistory[ip.pageHistory.length-2].split('|');

var oldLocation = ip.pageHistory[ip.pageHistory.length-1].split('location=');
var oldMenu= oldLocation[1].split('&');
var newLocation = url[1].split('location=');
var newMenu= newLocation[1].split('&');
var oMenuOld = document.getElementById("menu_"+oldMenu[0]);
oMenuOld.className = '';
var oMenuNew = document.getElementById("menu_"+newMenu[0]);
oMenuNew.className = 'selected';

ip.update(url[0], url[1], true);
}else{



}
}
 }
i1 = new Image();
i1.src = "images/ajax_indicator.gif";
var fileLoadingImage = "images/ajax_indicator.gif";
var fileBottomNavCloseImage = "images/closelabel.gif";

var resizeSpeed = 7;

var borderSize = 10;



//

//
var imageArray = new Array;
var activeImage;

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



//


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



//



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



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



//

//

//
var Lightbox = Class.create();

Lightbox.prototype = {

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


for (var i=0; i<anchors.length; i++){
var anchor = anchors[i];

var relAttribute = String(anchor.getAttribute('rel'));


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


//

var objBody = document.getElementsByTagName("body").item(0);

var objOverlay = document.createElement("div");
objOverlay.setAttribute('id','overlay');
objOverlay.style.display = 'none';
objOverlay.onclick = function() { myLightbox.end(); return false; }
objBody.appendChild(objOverlay);

var objLightbox = document.createElement("div");
objLightbox.setAttribute('id','lightbox');
objLightbox.style.display = 'none';
objBody.appendChild(objLightbox);

var objOuterImageContainer = document.createElement("div");
objOuterImageContainer.setAttribute('id','outerImageContainer');
objLightbox.appendChild(objOuterImageContainer);

var objImageContainer = document.createElement("div");
objImageContainer.setAttribute('id','imageContainer');
objOuterImageContainer.appendChild(objImageContainer);

var objLightboxImage = document.createElement("img");
objLightboxImage.setAttribute('id','lightboxImage');
objImageContainer.appendChild(objLightboxImage);

var objHoverNav = document.createElement("div");
objHoverNav.setAttribute('id','hoverNav');
objImageContainer.appendChild(objHoverNav);

var objPrevLink = document.createElement("a");
objPrevLink.setAttribute('id','prevLink');
objPrevLink.setAttribute('href','#');
objHoverNav.appendChild(objPrevLink);

var objNextLink = document.createElement("a");
objNextLink.setAttribute('id','nextLink');
objNextLink.setAttribute('href','#');
objHoverNav.appendChild(objNextLink);

var objLoading = document.createElement("div");
objLoading.setAttribute('id','loading');
objImageContainer.appendChild(objLoading);

var objLoadingLink = document.createElement("a");
objLoadingLink.setAttribute('id','loadingLink');
objLoadingLink.setAttribute('href','#');
objLoadingLink.onclick = function() { myLightbox.end(); return false; }
objLoading.appendChild(objLoadingLink);

var objLoadingImage = document.createElement("img");
objLoadingImage.setAttribute('src', fileLoadingImage);
objLoadingLink.appendChild(objLoadingImage);

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

var objImageData = document.createElement("div");
objImageData.setAttribute('id','imageData');
objImageDataContainer.appendChild(objImageData);

var objImageDetails = document.createElement("div");
objImageDetails.setAttribute('id','imageDetails');
objImageData.appendChild(objImageDetails);

var objCaption = document.createElement("span");
objCaption.setAttribute('id','caption');
objImageDetails.appendChild(objCaption);

var objNumberDisplay = document.createElement("span");
objNumberDisplay.setAttribute('id','numberDisplay');
objImageDetails.appendChild(objNumberDisplay);

var objBottomNav = document.createElement("div");
objBottomNav.setAttribute('id','bottomNav');
objImageData.appendChild(objBottomNav);

var objBottomNavCloseLink = document.createElement("a");
objBottomNavCloseLink.setAttribute('id','bottomNavClose');
objBottomNavCloseLink.setAttribute('href','#');
objBottomNavCloseLink.onclick = function() { myLightbox.end(); return false; }
objBottomNav.appendChild(objBottomNavCloseLink);

var objBottomNavCloseImage = document.createElement("img");
objBottomNavCloseImage.setAttribute('src', fileBottomNavCloseImage);
objBottomNavCloseLink.appendChild(objBottomNavCloseImage);
},

//


//
start: function(imageLink) {

hideSelectBoxes();


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

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;


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) { 
keycode = event.keyCode;
} else { 
keycode = e.which;
}

key = String.fromCharCode(keycode).toLowerCase();

if((key == 'x') || (key == 'o') || (key == 'c')){
myLightbox.end();
} else if(key == 'p'){
if(activeImage != 0){
myLightbox.disableKeyboardNav();
myLightbox.changeImage(activeImage - 1);
}
} else if(key == 'n'){
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');

$('overlay').style.display = 'none';
showSelectBoxes();
}
}



//



//
function getPageScroll(){

var yScroll;

if (self.pageYOffset) {
yScroll = self.pageYOffset;
} else if (document.documentElement && document.documentElement.scrollTop){ 
yScroll = document.documentElement.scrollTop;
} else if (document.body) {
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){ 
xScroll = document.body.scrollWidth;
yScroll = document.body.scrollHeight;
} else { 
xScroll = document.body.offsetWidth;
yScroll = document.body.offsetHeight;
}

var windowWidth, windowHeight;
if (self.innerHeight) {
windowWidth = self.innerWidth;
windowHeight = self.innerHeight;
} else if (document.documentElement && document.documentElement.clientHeight) { 
windowWidth = document.documentElement.clientWidth;
windowHeight = document.documentElement.clientHeight;
} else if (document.body) { 
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) { 
keycode = event.keyCode;
} else { 
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;
	}
}

function CSBfleXcroll(targetId){
	var dC=document,wD=window;
	if( !dC.getElementById||
	dC.getElementById(targetId)==null||
	!dC.createElement||
	navigator.userAgent.indexOf('Safari')!=-1||
	navigator.vendor=='KDE'){
		return;
	}

	var dDv=dC.getElementById(targetId);
	if(dDv.fleXcroll)return;
	var cDv=createDiv('contentwrapper',true);var mDv=createDiv('mcontentwrapper',true);
	var tDv=createDiv('scrollwrapper',true); var pDv=createDiv('copyholder',true);

	pDv.style.border='1px solid blue';pDv.style.visibility='hidden';stdMode=false;
	dDv.style.overflow='hidden';
	dDv.fleXdata=new Object();var sC=dDv.fleXdata;
	sC.keyAct={_37:['-1s',0],_38:[0,'-1s'],_39:['1s',0],_40:[0,'1s'],_33:[0,'-1p'],_34:[0,'1p']};
	sC.wheelAct=["-2s","2s"];sC.baseAct=["-2s","2s"];
	var brdHeight=dDv.offsetHeight,brdWidth=dDv.offsetWidth;
	copyStyles(dDv,pDv,'0px',['border-left-width','border-right-width','border-top-width','border-bottom-width']);
	var intlHeight=dDv.offsetHeight,intlWidth=dDv.offsetWidth,brdWidthLoss=brdWidth-intlWidth,brdHeightLoss=brdHeight-intlHeight;
	var oScrollY=(dDv.scrollTop)?dDv.scrollTop:0,oScrollX=(dDv.scrollLeft)?dDv.scrollLeft:0;
	var focusProtectList=['textarea','input','select']
	sC.scrollPos=[0,0,0,0];sC.pageScroll=[0,0];sC.stepScroll=[0,0];
	sC.containerSize=[0,0];sC.contentSize=[0,0];sC.reqH=false;sC.reqV=false;sC.vHspace=0;sC.hVspace=0;
	while (dDv.firstChild) 
		{cDv.appendChild(dDv.firstChild)};
	dDv.appendChild(mDv);dDv.appendChild(pDv);
	if(getActiveStyle(dDv,'position')!='absolute') dDv.style.position="relative";
	mDv.style.width="10px";mDv.style.height="10px";mDv.style.top="0px";mDv.style.left="0px";
	copyStyles(dDv,pDv,"0px",['padding-left','padding-top','padding-right','padding-bottom']);
	var postWidth=dDv.offsetWidth,postHeight=dDv.offsetHeight,heightLoss=intlHeight-postHeight,widthLoss=intlWidth-postWidth;
	if(heightLoss+widthLoss>0) stdMode=true;
	copyStyles(pDv,dDv,false,['padding-left','padding-top','padding-right','padding-bottom']);
	findPos(mDv);findPos(dDv);
	var padTop=mDv.yPos-dDv.yPos,padLeft=mDv.xPos-dDv.xPos;
	dDv.style.paddingTop=getActiveStyle(dDv,"padding-bottom");dDv.style.paddingLeft=getActiveStyle(dDv,"padding-right");
	findPos(mDv);findPos(dDv);
	var padBottom=mDv.yPos-dDv.yPos, padRight=mDv.xPos-dDv.xPos
	dDv.style.paddingTop=getActiveStyle(pDv,"padding-top");dDv.style.paddingLeft=getActiveStyle(pDv,"padding-left");
	var padWidthComp=padRight+padLeft,padHeightComp=padTop+padBottom;

	copyStyles(dDv,mDv,false,['padding-left','padding-right','padding-top','padding-bottom']);
	tDv.style.width=dDv.offsetWidth+'px';tDv.style.height=dDv.offsetHeight+'px';
	mDv.style.width=postWidth+'px'; mDv.style.height=postHeight+'px';
	tDv.style.position='absolute';tDv.style.top='0px';tDv.style.left='0px';
	tDv.style.visibility='hidden';

	mDv.appendChild(cDv);dDv.appendChild(tDv);
	cDv.style.position='relative';mDv.style.position='relative';cDv.style.padding='1px';
	cDv.style.top="0";cDv.style.width="100%";
	mDv.style.overflow='hidden';
	mDv.style.left="-"+getActiveStyle(dDv,"padding-left");
	mDv.style.top="-"+getActiveStyle(dDv,"padding-top");
	sC.hVspace=sC.vHspace=0;

	sC.getContentWidth=function(){
		var cChilds=cDv.childNodes,maxCWidth=compPad=0;
		for(var i=0;i<cChilds.length;i++){if(cChilds[i].offsetWidth){maxCWidth=Math.max(cChilds[i].offsetWidth,maxCWidth)}}
		sC.containerSize[0]=(sC.reqV)?dDv.offsetWidth-sC.hVspace:dDv.offsetWidth;
		sC.contentSize[0]=maxCWidth+padWidthComp;
		return sC.contentSize[0]-50;
	};
	sC.getContentHeight=function(){
		sC.containerSize[1]=(sC.reqH)?dDv.offsetHeight-sC.vHspace:dDv.offsetHeight;
		sC.contentSize[1]=cDv.offsetHeight+padHeightComp;
		return sC.contentSize[1];
	};
	sC.fixIEDispBug=function(){cDv.style.display='none';cDv.style.display='block'};

	sC.setWidth=function(){mDv.style.width=(stdMode)?(sC.containerSize[0]-padWidthComp-brdWidthLoss)+'px':sC.containerSize[0]+'px'}
	sC.setHeight=function(){mDv.style.height=(stdMode)?(sC.containerSize[1]-padHeightComp-brdHeightLoss)+'px':sC.containerSize[1]+'px'}

	sC.createScrollBars=function(){
		sC.getContentWidth();sC.getContentHeight();

		tDv.vrt=new Array();var vrT=tDv.vrt;
		createScrollBars(vrT,'vscroller');
		vrT.barPadding=[parseInt(getActiveStyle(vrT.sBr,'padding-top')),parseInt(getActiveStyle(vrT.sBr,'padding-bottom'))];
		vrT.sBr.style.padding='0px';vrT.sBr.curPos=0;vrT.sBr.vertical=true;
		vrT.sBr.indx=1; cDv.vBar=vrT.sBr;
		prepareScroll(vrT,0);sC.hVspace=vrT.sDv.offsetWidth;
		sC.setWidth();

		tDv.hrz=new Array();var hrZ=tDv.hrz;
		createScrollBars(hrZ,'hscroller');
		hrZ.barPadding=[parseInt(getActiveStyle(hrZ.sBr,'padding-left')),parseInt(getActiveStyle(hrZ.sBr,'padding-right'))];
		hrZ.sBr.style.padding='0px';hrZ.sBr.curPos=0;hrZ.sBr.vertical=false;
		hrZ.sBr.indx=0; cDv.hBar=hrZ.sBr;
		if(wD.opera) hrZ.sBr.style.position='relative';
		prepareScroll(hrZ,0);
		sC.vHspace=hrZ.sDv.offsetHeight;
		sC.setHeight();
		tDv.style.height=dDv.offsetHeight+'px';

		hrZ.jBox=createDiv('scrollerjogbox');
		hrZ.jBox.style.display='none';hrZ.jBox.prnt=tDv;
		tDv.appendChild(hrZ.jBox);
		hrZ.jBox.onmousedown=function(){
			hrZ.sBr.scrollBoth=true;sC.goScroll=hrZ.sBr;hrZ.sBr.clicked=true;
			hrZ.sBr.moved=false;tDv.vrt.sBr.moved=false;dDv.scrollUpdate();
			addTrggr(dC,'selectstart',retFalse);addTrggr(dC,'mousemove',mMoveBar);addTrggr(dC,'mouseup',mMouseUp);
			return false;
		};
	};

	sC.goScroll=null;
	sC.createScrollBars();

	if(!addChckTrggr(dDv,'mousewheel',mWheelProc)||!addChckTrggr(dDv,'DOMMouseScroll',mWheelProc)){dDv.onmousewheel=mWheelProc;}
	dDv.setAttribute('tabIndex','0');

	addTrggr(dDv,'keydown',function(e){
		if(dDv.focusProtect) return;
		if(!e){var e=wD.event;};var pK=e.keyCode;
		if(sC.keyAct['_'+pK]){dDv.contentScroll(sC.keyAct['_'+pK][0],sC.keyAct['_'+pK][1],true);if(e.preventDefault) e.preventDefault();return false;}
	});
	addTrggr(dDv,'keypress',function(e){
		if(dDv.focusProtect) return;
		if(!e){var e=wD.event;};var pK=e.keyCode;
		if(sC.keyAct['_'+pK]){e.preventDefault();return false;}
	});
	addTrggr(dC,'mouseup',tSelectStop);
	addTrggr(dDv,'mousedown',function(e){if(!e) e=wD.event;
	var cTrgt=(e.target)?e.target:(e.srcElement)?e.srcElement:false;
	if(!cTrgt||(cTrgt.className&&cTrgt.className.match(RegExp("\\bscrollgeneric\\b")))) return;
	sC.inMposX=e.clientX;sC.inMposY=e.clientY;
	pageScrolled();findPos(dDv);tSelectStop();
	addTrggr(dC,'mousemove',tSelectMouse);
	sC.mTBox=[dDv.xPos+10,dDv.xPos+sC.containerSize[0]-10,dDv.yPos+10,dDv.yPos+sC.containerSize[1]-10];
	});
	function tSelectStop() {remTrggr(dC,'mousemove',tSelectMouse);if(sC.tSelectFunc) wD.clearInterval(sC.tSelectFunc);sC.tSelectFunc=false;}
	function tSelectMouse(e) {if(!e) e=wD.event;
		var mX=e.clientX,mY=e.clientY,mdX=mX+sC.xScrld,mdY=mY+sC.yScrld;
		sC.mOnXEdge=(mdX<sC.mTBox[0]||mdX>sC.mTBox[1])?1:0;
		sC.mOnYEdge=(mdY<sC.mTBox[2]||mdY>sC.mTBox[3])?1:0;
		sC.xAw=mX-sC.inMposX;sC.yAw=mY-sC.inMposY;
		sC.sXdir=(sC.xAw>40)?1:(sC.xAw<-40)?-1:0;sC.sYdir=(sC.yAw>40)?1:(sC.yAw<-40)?-1:0;
		if((sC.sXdir!=0||sC.sYdir!=0)&&!sC.tSelectFunc) sC.tSelectFunc=wD.setInterval(function(){
			if(sC.sXdir==0&&sC.sYdir==0){wD.clearInterval(sC.tSelectFunc);sC.tSelectFunc=false;return;}; pageScrolled();
			if(sC.mOnXEdge==1||sC.mOnYEdge==1) dDv.contentScroll((sC.sXdir*sC.mOnXEdge)+"s",(sC.sYdir*sC.mOnYEdge)+"s",true);
		},45)
	}

	function pageScrolled(){
		sC.xScrld=(wD.pageXOffset)?wD.pageXOffset:(dC.documentElement&&dC.documentElement.scrollLeft)?dC.documentElement.scrollLeft:0;
		sC.yScrld=(wD.pageYOffset)?wD.pageYOffset:(dC.documentElement&&dC.documentElement.scrollTop)?dC.documentElement.scrollTop:0;
	}

	dDv.scrollUpdate=function(recurse){
		cDv.style.padding='1px';var reqH=sC.reqH,reqV=sC.reqV;
		sC.reqH=sC.getContentWidth()>sC.containerSize[0];
		sC.reqV=sC.getContentHeight()>sC.containerSize[1];
		var stateChange=(reqH!=sC.reqH||reqV!=sC.reqV)?true:false;
		tDv.style.width=dDv.offsetWidth-brdWidthLoss+'px';tDv.style.height=dDv.offsetHeight-brdHeightLoss+'px';

		if(sC.reqV){tDv.vrt.sDv.style.display='block';sC.vScroll=true;}
		else{tDv.vrt.sDv.style.display='none';sC.vScroll=false;tDv.vrt.sBr.curPos=0;cDv.style.top='0px';}
		if(sC.reqH){tDv.hrz.sDv.style.display='block';sC.hScroll=true;if(sC.reqV) tDv.hrz.jBox.style.display='block';}
		else{tDv.hrz.sDv.style.display='none';sC.hScroll=false;tDv.hrz.sBr.curPos=0;cDv.style.left='0px';}

		sC.getContentWidth();sC.getContentHeight();sC.setHeight();sC.setWidth();
		if(!sC.reqH||!sC.reqV) tDv.hrz.jBox.style.display='none';
		if(sC.reqV) updateScroll(tDv.vrt,(sC.reqH)?sC.vHspace:0);
		if(sC.reqH) updateScroll(tDv.hrz,(sC.reqV)?sC.hVspace:0);
		if(stateChange&&!recurse) dDv.scrollUpdate(true);
		cDv.style.padding='0px';
	};

	dDv.commitScroll=function(xScr,yScr,relative){
		var reT=[false,false],Bar;
		if((xScr||xScr===0)&&sC.hScroll){xScr=calcScrollVal(xScr,0);Bar=tDv.hrz.sBr;Bar.curPos=(relative)?Bar.curPos+xScr:xScr;Bar.doScrollPos();reT[0]=[Bar.curPos,Bar.sRange];}
		if((yScr||yScr===0)&&sC.vScroll){yScr=calcScrollVal(yScr,1);Bar=tDv.vrt.sBr;Bar.curPos=(relative)?Bar.curPos+yScr:yScr;Bar.doScrollPos();reT[1]=[Bar.curPos,Bar.sRange];}
		return reT;
	};
	dDv.contentScroll=function(xPos,yPos,relative){ 
		var reT=[false,false],Bar;
		if((xPos||xPos===0)&&sC.hScroll){xPos=calcCScrollVal(xPos,0);Bar=tDv.hrz.sBr;Bar.targetScroll=(relative)?Math.min(Math.max(Bar.mxScroll,Bar.targetScroll-xPos),0):-xPos;Bar.contentScrollPos();reT[0]=[Bar.targetScroll,Bar.mxScroll]}
		if((yPos||yPos===0)&&sC.vScroll){yPos=calcCScrollVal(yPos,1);Bar=tDv.vrt.sBr;Bar.targetScroll=(relative)?Math.min(Math.max(Bar.mxScroll,Bar.targetScroll-yPos),0):-yPos;Bar.contentScrollPos();reT[1]=[Bar.targetScroll,Bar.mxScroll]}
		return reT;
	}

	copyStyles(pDv,dDv,'0px',['border-left-width','border-right-width','border-top-width','border-bottom-width']);

	cDv.style.padding='0px';dDv.removeChild(pDv);dDv.fleXcroll=true;
	dDv.scrollUpdate();
	dDv.contentScroll(oScrollX,oScrollY,true);
	tDv.style.visibility='visible';

	function calcScrollVal(v,i){
		var stR=v.toString();v=parseFloat(stR);
		return parseInt((stR.match(/p$/))?v*sC.pageScroll[i]:(stR.match(/s$/))?v*sC.stepScroll[i]:v);
	}
	function calcCScrollVal(v,i){
		var stR=v.toString();v=parseFloat(stR);
		return parseInt((stR.match(/p$/))?v*sC.containerSize[i]*0.90:(stR.match(/s$/))?v*sC.containerSize[i]*0.1:v);
	}
	function camelConv(spL){
		var spL=spL.split('-'),reT=spL[0],i;
		for(i=1;parT=spL[i];i++) {reT +=parT.charAt(0).toUpperCase()+parT.substr(1);}
		return reT;
	}
	function getActiveStyle(elem,style){
		if(wD.getComputedStyle) return wD.getComputedStyle(elem,null).getPropertyValue(style);
		if(elem.currentStyle) return elem.currentStyle[camelConv(style)];
		return false;
	};
	function copyStyles(src,dest,replaceStr,sList){
		var camelList = new Array();
		for (var i=0;i<sList.length;i++){
			camelList[i]=camelConv(sList[i]);
			dest.style[camelList[i]] = getActiveStyle(src,sList[i],camelList[i]);
			if(replaceStr) src.style[camelList[i]] = replaceStr;
		}
	};
	function createDiv(typeName,noGenericClass){
		var nDiv=dC.createElement('div');
		nDiv.id=targetId+'_'+typeName;
		nDiv.className=(noGenericClass)?typeName:typeName+' scrollgeneric';
		nDiv.getSize=[function(){return nDiv.offsetWidth},function(){return nDiv.offsetHeight}]
		nDiv.setSize=[function(sVal){nDiv.style.width=sVal},function(sVal){nDiv.style.height=sVal}]
		nDiv.setPos=[function(sVal){nDiv.style.left=sVal},function(sVal){nDiv.style.top=sVal}]
		return nDiv;
	};
	function createScrollBars(ary,bse){
		ary.sDv=createDiv(bse+'base');ary.sFDv=createDiv(bse+'basebeg');
		ary.sSDv=createDiv(bse+'baseend');ary.sBr=createDiv(bse+'bar');
		ary.sFBr=createDiv(bse+'barbeg');ary.sSBr=createDiv(bse+'barend');
		tDv.appendChild(ary.sDv);ary.sDv.appendChild(ary.sBr);
		ary.sDv.appendChild(ary.sFDv);ary.sDv.appendChild(ary.sSDv);
		ary.sBr.appendChild(ary.sFBr);ary.sBr.appendChild(ary.sSBr);
	};
	function prepareScroll(bAr,reqSpace){
		var sDv=bAr.sDv,sBr=bAr.sBr,i=sBr.indx;
		sBr.minPos=bAr.barPadding[0];
		sBr.ofstParent=sDv;
		sBr.mDv=mDv;
		sBr.scrlTrgt=cDv;
		sBr.targetSkew=0
		updateScroll(bAr,reqSpace,true);

		sBr.doScrollPos=function(){
			sBr.curPos=(Math.min(Math.max(sBr.curPos,0),sBr.maxPos));
			sBr.targetScroll=parseInt((sBr.curPos/sBr.sRange)*sBr.mxScroll);
			sBr.targetSkew=(sBr.curPos==0)?0:(sBr.curPos==sBr.maxPos)?0:sBr.targetSkew;
			sBr.setPos[i](sBr.curPos+sBr.minPos+"px");
			cDv.setPos[i](sBr.targetScroll+sBr.targetSkew+"px");
			sC.scrollPos[i]=sBr.curPos;sC.scrollPos[i+2]=-sBr.targetScroll;
		};

		sBr.contentScrollPos=function(){
			sBr.curPos=parseInt((sBr.targetScroll*sBr.sRange)/sBr.mxScroll);
			sBr.targetSkew=sBr.targetScroll-parseInt((sBr.curPos/sBr.sRange)*sBr.mxScroll);
			sBr.curPos=(Math.min(Math.max(sBr.curPos,0),sBr.maxPos));
			sBr.setPos[i](sBr.curPos+sBr.minPos+"px");
			sBr.setPos[i](sBr.curPos+sBr.minPos+"px");
			cDv.setPos[i](sBr.targetScroll+"px");
		}

		sC.barZ=getActiveStyle(sBr,'z-index');
		sBr.style.zIndex=(sC.barZ=="auto"||sC.barZ=="0")?2:sC.barZ;
		mDv.style.zIndex=getActiveStyle(sBr,'z-index');

		sBr.onmousedown=function(){
			this.clicked=true;sC.goScroll=this;this.scrollBoth=false;this.moved=false;
			dDv.scrollUpdate();
			addTrggr(dC,'selectstart',retFalse);
			addTrggr(dC,'mousemove',mMoveBar);
			addTrggr(dC,'mouseup',mMouseUp);
			return false;
		};

		sDv.onclick=function(e){
			if(!e){var e=wD.event;}
			if(e.target&&(e.target==bAr.sFBr||e.target==bAr.sSBr||e.srcElement==bAr.sBr)) return;
			if(e.srcElement&&(e.srcElement==bAr.sFBr||e.srcElement==bAr.sSBr||e.srcElement==bAr.sBr)) return;
			var relPos,mV=[];pageScrolled();sBr.mDv.scrollTop=0;sBr.mDv.scrollLeft=0;findPos(sBr);
			relPos=(sBr.vertical)?e.clientY+sC.yScrld-sBr.yPos:e.clientX+sC.xScrld-sBr.xPos;
			mV[sBr.indx]=(relPos<0)?sC.baseAct[0]:sC.baseAct[1];mV[1-sBr.indx]=0;
			dDv.contentScroll(mV[0],mV[1],true);
			return false;
		}
		sDv.onmousedown = retFalse;
	};

	function updateScroll(bAr,reqSpace,firstRun){
		var sDv=bAr.sDv,sBr=bAr.sBr,sFDv=bAr.sFDv,sFBr=bAr.sFBr,sSDv=bAr.sSDv,sSBr=bAr.sSBr,i=sBr.indx;
		sDv.setSize[i](tDv.getSize[i]()-reqSpace+'px');sDv.setPos[1-i](tDv.getSize[1-i]()-sDv.getSize[1-i]()+'px');
		bAr.padLoss=bAr.barPadding[0]+bAr.barPadding[1];
		sBr.aSize=Math.max(Math.min(parseInt(sC.containerSize[i]/sC.contentSize[i]*sDv.getSize[i]()),parseInt((sDv.getSize[i]()-bAr.padLoss)*0.75)),45);
		sBr.setSize[i](sBr.aSize+'px');sBr.maxPos=sDv.getSize[i]()-sBr.getSize[i]()-bAr.padLoss;
		sBr.curPos=Math.min(Math.max(0,sBr.curPos),sBr.maxPos);
		sBr.setPos[i](sBr.curPos+sBr.minPos+'px');sBr.mxScroll=mDv.getSize[i]()-sC.contentSize[i];
		sBr.sRange=sBr.maxPos;
		sC.pageScroll[i]=sBr.pageScroll=parseInt(sBr.getSize[i]()*0.86);
		sC.stepScroll[i]=sBr.stepScroll=Math.min(Math.abs(parseInt((sBr.sRange/sBr.mxScroll)*80)),parseInt(sBr.sRange*0.25));
		sFDv.setSize[i](sDv.getSize[i]()-sSDv.getSize[i]()+'px');
		sFBr.setSize[i](sBr.getSize[i]()-sSBr.getSize[i]()+'px');
		sSBr.setPos[i](sBr.getSize[i]()-sSBr.getSize[i]()+'px');
		sSDv.setPos[i](sFDv.getSize[i]()+'px');
		if(!firstRun) sBr.doScrollPos();
		sC.fixIEDispBug();
	};

	addTrggr(wD,'load',function(){if(dDv.fleXcroll) dDv.scrollUpdate();});
	addTrggr(wD,'resize',function(){
		if(dDv.refreshTimeout) wD.clearTimeout(dDv.refreshTimeout);
		dDv.refreshTimeout=wD.setTimeout(function(){if(dDv.fleXcroll) dDv.scrollUpdate();},80);
	});

	for(var j=0,inputName;inputName=focusProtectList[j];j++){
		var inputList=dDv.getElementsByTagName(inputName);
		for(var i=0,formItem;formItem=inputList[i];i++){
			addTrggr(formItem,'focus',function(){dDv.focusProtect=true;})
			addTrggr(formItem,'blur',onblur=function(){dDv.focusProtect=false;})
		}
	};

	function retFalse(){return false;};
	function mMoveBar(e){
		if(!e){var e=wD.event;}
		var FCBar=sC.goScroll,movBr,maxx,xScroll,yScroll;
		if(FCBar==null) return;
		maxx=(FCBar.scrollBoth)?2:1;
		for (var i=0;i<maxx;i++){
			movBr=(i==1)?FCBar.scrlTrgt.vBar:FCBar;
			if(FCBar.clicked){
				if(!movBr.moved){
					movBr.mDv.scrollTop=0;movBr.mDv.scrollLeft=0;
					findPos(movBr);findPos(movBr.ofstParent);movBr.pointerOffsetY=e.clientY-movBr.yPos;
					movBr.pointerOffsetX=e.clientX-movBr.xPos;movBr.inCurPos=movBr.curPos;movBr.moved=true;
				}
				movBr.curPos=(movBr.vertical)?e.clientY-movBr.pointerOffsetY-movBr.ofstParent.yPos-movBr.minPos:e.clientX-movBr.pointerOffsetX-movBr.ofstParent.xPos-movBr.minPos;
				if(FCBar.scrollBoth) movBr.curPos=movBr.curPos+(movBr.curPos-movBr.inCurPos);
				movBr.doScrollPos();
			} else movBr.moved=false;
		}
	};

	function mMouseUp(){
		if(sC.goScroll!=null){sC.goScroll.clicked=false;}
		sC.goScroll=null;
		remTrggr(dC,'selectstart',retFalse);
		remTrggr(dC,'mousemove',mMoveBar);
		remTrggr(dC,'mouseup',mMouseUp);
	};

	function mWheelProc(e){
		if(!e) e=wD.event;
		if(!this.fleXcroll) return;
		var scrDv=this,vEdge,hEdge,hoverH=false,delta=0,iNDx;
		hElem=(e.target)?e.target:(e.srcElement)?e.srcElement:this;
		if(hElem.id&&hElem.id.match(/_hscroller/)) hoverH=true;
		if(e.wheelDelta) delta=-e.wheelDelta;if(e.detail) delta=e.detail;delta=(delta<0)?-1:+1;iNDx=(delta<0)?0:1;
		if(sC.vScroll&&!hoverH) scrollState=dDv.contentScroll(false,sC.wheelAct[iNDx],true);
		vEdge=!sC.vScroll||hoverH||(sC.vScroll&&((scrollState[1][0]==scrollState[1][1]&&delta>0)||(scrollState[1][0]==0&&delta<0)));
		if(sC.hScroll&&(!sC.vScroll||hoverH)) scrollState=dDv.contentScroll(sC.wheelAct[iNDx],false,true);
		hEdge=!sC.hScroll||(sC.hScroll&&sC.vScroll&&vEdge&&!hoverH)||(sC.hScroll&&((scrollState[0][0]==scrollState[0][1]&&delta>0)||(scrollState[0][0]==0&&delta<0)));
		if(vEdge&&hEdge&&!hoverH) return;
		if(e.preventDefault) e.preventDefault();
		return false;
	};

	function addTrggr(elm,eventname,func){if(!addChckTrggr(elm,eventname,func)&&elm.attachEvent) {elm.attachEvent('on'+eventname,func);}};
	function addChckTrggr(elm,eventname,func){if(elm.addEventListener){elm.addEventListener(eventname,func,false);wD.addEventListener("unload",function(){remTrggr(elm,eventname,func)},false);return true;} else return false;};
	function remTrggr(elm,eventname,func){if(!remChckTrggr(elm,eventname,func)&&elm.detachEvent) elm.detachEvent('on'+eventname,func);};
	function remChckTrggr(elm,eventname,func){if(elm.removeEventListener){elm.removeEventListener(eventname,func,false);return true;} else return false;};

	function findPos(elem){ 
		var obj=elem,curleft=curtop=0;
		if(obj.offsetParent){while(obj){curleft+=obj.offsetLeft;curtop+=obj.offsetTop;obj=obj.offsetParent;}}
		else if(obj.x){curleft+=obj.x;curtop+=obj.y;}
		elem.xPos=curleft;elem.yPos=curtop;
	};

};