/*--------------------------------------------------------------------------*/
///shared/client_scripts/greybox/AJS.js
/*--------------------------------------------------------------------------*/
AJS={BASE_URL:"",drag_obj:null,drag_elm:null,_drop_zones:[],_cur_pos:null,join:function(_1,_2){
try{
return _2.join(_1);
}
catch(e){
var r=_2[0]||"";
AJS.map(_2,function(_4){
r+=_1+_4;
},1);
return r+"";
}
},getScrollTop:function(){
var t;
if(document.documentElement&&document.documentElement.scrollTop){
t=document.documentElement.scrollTop;
}else{
if(document.body){
t=document.body.scrollTop;
}
}
return t;
},addClass:function(){
var _6=AJS.forceArray(arguments);
var _7=_6.pop();
var _8=function(o){
if(!new RegExp("(^|\\s)"+_7+"(\\s|$)").test(o.className)){
o.className+=(o.className?" ":"")+_7;
}
};
AJS.map(_6,function(_a){
_8(_a);
});
},setStyle:function(){
var _b=AJS.forceArray(arguments);
var _c=_b.pop();
var _d=_b.pop();
AJS.map(_b,function(_e){
_e.style[_d]=AJS.getCssDim(_c);
});
},_getRealScope:function(fn,_10,_11,_12){
var _13=window;
_10=AJS.$A(_10);
if(fn._cscope){
_13=fn._cscope;
}
return function(){
var _14=[];
var i=0;
if(_11){
i=1;
}
AJS.map(arguments,function(arg){
_14.push(arg);
},i);
_14=_14.concat(_10);
if(_12){
_14=_14.reverse();
}
return fn.apply(_13,_14);
};
},preloadImages:function(){
AJS.AEV(window,"load",AJS.$p(function(_17){
AJS.map(_17,function(src){
var pic=new Image();
pic.src=src;
});
},arguments));
},_createDomShortcuts:function(){
var _1a=["ul","li","td","tr","th","tbody","table","input","span","b","a","div","img","button","h1","h2","h3","br","textarea","form","p","select","option","iframe","script","center","dl","dt","dd","small","pre"];
var _1b=function(elm){
var _1d="return AJS.createDOM.apply(null, ['"+elm+"', arguments]);";
var _1e="function() { "+_1d+"    }";
eval("AJS."+elm.toUpperCase()+"="+_1e);
};
AJS.map(_1a,_1b);
AJS.TN=function(_1f){
return document.createTextNode(_1f);
};
},documentInsert:function(elm){
if(typeof (elm)=="string"){
elm=AJS.HTML2DOM(elm);
}
document.write("<span id=\"dummy_holder\"></span>");
AJS.swapDOM(AJS.$("dummy_holder"),elm);
},getWindowSize:function(doc){
doc=doc||document;
var _22,_23;
if(self.innerHeight){
_22=self.innerWidth;
_23=self.innerHeight;
}else{
if(doc.documentElement&&doc.documentElement.clientHeight){
_22=doc.documentElement.clientWidth;
_23=doc.documentElement.clientHeight;
}else{
if(doc.body){
_22=doc.body.clientWidth;
_23=doc.body.clientHeight;
}
}
}
return {"w":_22,"h":_23};
},flattenList:function(_24){
var r=[];
var _26=function(r,l){
AJS.map(l,function(o){
if(o==null){
}else{
if(AJS.isArray(o)){
_26(r,o);
}else{
r.push(o);
}
}
});
};
_26(r,_24);
return r;
},setEventKey:function(e){
e.key=e.keyCode?e.keyCode:e.charCode;
if(window.event){
e.ctrl=window.event.ctrlKey;
e.shift=window.event.shiftKey;
}else{
e.ctrl=e.ctrlKey;
e.shift=e.shiftKey;
}
switch(e.key){
case 63232:
e.key=38;
break;
case 63233:
e.key=40;
break;
case 63235:
e.key=39;
break;
case 63234:
e.key=37;
break;
}
},removeElement:function(){
var _2b=AJS.forceArray(arguments);
AJS.map(_2b,function(elm){
AJS.swapDOM(elm,null);
});
},_unloadListeners:function(){
if(AJS.listeners){
AJS.map(AJS.listeners,function(elm,_2e,fn){
AJS.REV(elm,_2e,fn);
});
}
AJS.listeners=[];
},partial:function(fn){
var _31=AJS.forceArray(arguments);
return AJS.$b(fn,null,_31.slice(1,_31.length).reverse(),false,true);
},getIndex:function(elm,_33,_34){
for(var i=0;i<_33.length;i++){
if(_34&&_34(_33[i])||elm==_33[i]){
return i;
}
}
return -1;
},isDefined:function(o){
return (o!="undefined"&&o!=null);
},isArray:function(obj){
return obj instanceof Array;
},setLeft:function(){
var _38=AJS.forceArray(arguments);
_38.splice(_38.length-1,0,"left");
AJS.setStyle.apply(null,_38);
},appendChildNodes:function(elm){
if(arguments.length>=2){
AJS.map(arguments,function(n){
if(AJS.isString(n)){
n=AJS.TN(n);
}
if(AJS.isDefined(n)){
elm.appendChild(n);
}
},1);
}
return elm;
},isOpera:function(){
return (navigator.userAgent.toLowerCase().indexOf("opera")!=-1);
},isString:function(obj){
return (typeof obj=="string");
},hideElement:function(elm){
var _3d=AJS.forceArray(arguments);
AJS.map(_3d,function(elm){
elm.style.display="none";
});
},setOpacity:function(elm,p){
elm.style.opacity=p;
elm.style.filter="alpha(opacity="+p*100+")";
},setHeight:function(){
var _41=AJS.forceArray(arguments);
_41.splice(_41.length-1,0,"height");
AJS.setStyle.apply(null,_41);
},setWidth:function(){
var _42=AJS.forceArray(arguments);
_42.splice(_42.length-1,0,"width");
AJS.setStyle.apply(null,_42);
},createArray:function(v){
if(AJS.isArray(v)&&!AJS.isString(v)){
return v;
}else{
if(!v){
return [];
}else{
return [v];
}
}
},isDict:function(o){
var _45=String(o);
return _45.indexOf(" Object")!=-1;
},isMozilla:function(){
return (navigator.userAgent.toLowerCase().indexOf("gecko")!=-1&&navigator.productSub>=20030210);
},_listenOnce:function(elm,_47,fn){
var _49=function(){
AJS.removeEventListener(elm,_47,_49);
fn(arguments);
};
return _49;
},addEventListener:function(elm,_4b,fn,_4d,_4e){
if(!_4e){
_4e=false;
}
var _4f=AJS.$A(elm);
AJS.map(_4f,function(_50){
if(_4d){
fn=AJS._listenOnce(_50,_4b,fn);
}
if(AJS.isIn(_4b,["submit","load","scroll","resize"])){
var old=elm["on"+_4b];
elm["on"+_4b]=function(){
if(old){
fn(arguments);
return old(arguments);
}else{
return fn(arguments);
}
};
return;
}
if(AJS.isIn(_4b,["keypress","keydown","keyup","click"])){
var _52=fn;
fn=function(e){
AJS.setEventKey(e);
return _52.apply(null,arguments);
};
}
if(_50.attachEvent){
_50.attachEvent("on"+_4b,fn);
}else{
if(_50.addEventListener){
_50.addEventListener(_4b,fn,_4e);
}
}
AJS.listeners=AJS.$A(AJS.listeners);
AJS.listeners.push([_50,_4b,fn]);
});
},createDOM:function(_54,_55){
var i=0,_57;
elm=document.createElement(_54);
if(AJS.isDict(_55[i])){
for(k in _55[0]){
_57=_55[0][k];
if(k=="style"){
elm.style.cssText=_57;
}else{
if(k=="class"||k=="className"){
elm.className=_57;
}else{
elm.setAttribute(k,_57);
}
}
}
i++;
}
if(_55[0]==null){
i=1;
}
AJS.map(_55,function(n){
if(n){
if(AJS.isString(n)||AJS.isNumber(n)){
n=AJS.TN(n);
}
elm.appendChild(n);
}
},i);
return elm;
},setTop:function(){
var _59=AJS.forceArray(arguments);
_59.splice(_59.length-1,0,"top");
AJS.setStyle.apply(null,_59);
},getElementsByTagAndClassName:function(_5a,_5b,_5c){
var _5d=[];
if(!AJS.isDefined(_5c)){
_5c=document;
}
if(!AJS.isDefined(_5a)){
_5a="*";
}
var els=_5c.getElementsByTagName(_5a);
var _5f=els.length;
var _60=new RegExp("(^|\\s)"+_5b+"(\\s|$)");
for(i=0,j=0;i<_5f;i++){
if(_60.test(els[i].className)||_5b==null){
_5d[j]=els[i];
j++;
}
}
return _5d;
},removeClass:function(){
var _61=AJS.forceArray(arguments);
var cls=_61.pop();
var _63=function(o){
o.className=o.className.replace(new RegExp("\\s?"+cls,"g"),"");
};
AJS.map(_61,function(elm){
_63(elm);
});
},bindMethods:function(_66){
for(var k in _66){
var _68=_66[k];
if(typeof (_68)=="function"){
_66[k]=AJS.$b(_68,_66);
}
}
},log:function(o){
if(AJS.isMozilla()){
console.log(o);
}else{
var div=AJS.DIV({"style":"color: green"});
AJS.ACN(AJS.getBody(),AJS.setHTML(div,""+o));
}
},isNumber:function(obj){
return (typeof obj=="number");
},map:function(_6c,fn,_6e,_6f){
var i=0,l=_6c.length;
if(_6e){
i=_6e;
}
if(_6f){
l=_6f;
}
for(i;i<l;i++){
fn.apply(null,[_6c[i],i]);
}
},removeEventListener:function(elm,_73,fn,_75){
if(!_75){
_75=false;
}
if(elm.removeEventListener){
elm.removeEventListener(_73,fn,_75);
if(AJS.isOpera()){
elm.removeEventListener(_73,fn,!_75);
}
}else{
if(elm.detachEvent){
elm.detachEvent("on"+_73,fn);
}
}
},getCssDim:function(dim){
if(AJS.isString(dim)){
return dim;
}else{
return dim+"px";
}
},setHTML:function(elm,_78){
elm.innerHTML=_78;
return elm;
},bind:function(fn,_7a,_7b,_7c,_7d){
fn._cscope=_7a;
return AJS._getRealScope(fn,_7b,_7c,_7d);
},forceArray:function(_7e){
var r=[];
AJS.map(_7e,function(elm){
r.push(elm);
});
return r;
},update:function(l1,l2){
for(var i in l2){
l1[i]=l2[i];
}
return l1;
},getBody:function(){
return AJS.$bytc("body")[0];
},HTML2DOM:function(_84,_85){
var d=AJS.DIV();
d.innerHTML=_84;
if(_85){
return d.childNodes[0];
}else{
return d;
}
},getElement:function(id){
if(AJS.isString(id)||AJS.isNumber(id)){
return document.getElementById(id);
}else{
return id;
}
},showElement:function(){
var _88=AJS.forceArray(arguments);
AJS.map(_88,function(elm){
elm.style.display="";
});
},swapDOM:function(_8a,src){
_8a=AJS.getElement(_8a);
var _8c=_8a.parentNode;
if(src){
src=AJS.getElement(src);
_8c.replaceChild(src,_8a);
}else{
_8c.removeChild(_8a);
}
return src;
},isIn:function(elm,_8e){
var i=AJS.getIndex(elm,_8e);
if(i!=-1){
return true;
}else{
return false;
}
}};
AJS.$=AJS.getElement;
AJS.$$=AJS.getElements;
AJS.$f=AJS.getFormElement;
AJS.$p=AJS.partial;
AJS.$b=AJS.bind;
AJS.$A=AJS.createArray;
AJS.DI=AJS.documentInsert;
AJS.ACN=AJS.appendChildNodes;
AJS.RCN=AJS.replaceChildNodes;
AJS.AEV=AJS.addEventListener;
AJS.REV=AJS.removeEventListener;
AJS.$bytc=AJS.getElementsByTagAndClassName;
AJS.addEventListener(window,"unload",AJS._unloadListeners);
AJS._createDomShortcuts();
AJS.Class=function(_90){
var fn=function(){
if(arguments[0]!="no_init"){
return this.init.apply(this,arguments);
}
};
fn.prototype=_90;
AJS.update(fn,AJS.Class.prototype);
return fn;
};
AJS.Class.prototype={extend:function(_92){
var _93=new this("no_init");
for(k in _92){
var _94=_93[k];
var cur=_92[k];
if(_94&&_94!=cur&&typeof cur=="function"){
cur=this._parentize(cur,_94);
}
_93[k]=cur;
}
return new AJS.Class(_93);
},implement:function(_96){
AJS.update(this.prototype,_96);
},_parentize:function(cur,_98){
return function(){
this.parent=_98;
return cur.apply(this,arguments);
};
}};
AJS.$=AJS.getElement;
AJS.$$=AJS.getElements;
AJS.$f=AJS.getFormElement;
AJS.$b=AJS.bind;
AJS.$p=AJS.partial;
AJS.$FA=AJS.forceArray;
AJS.$A=AJS.createArray;
AJS.DI=AJS.documentInsert;
AJS.ACN=AJS.appendChildNodes;
AJS.RCN=AJS.replaceChildNodes;
AJS.AEV=AJS.addEventListener;
AJS.REV=AJS.removeEventListener;
AJS.$bytc=AJS.getElementsByTagAndClassName;
AJSDeferred=function(req){
this.callbacks=[];
this.errbacks=[];
this.req=req;
};
AJSDeferred.prototype={excCallbackSeq:function(req,_9b){
var _9c=req.responseText;
while(_9b.length>0){
var fn=_9b.pop();
var _9e=fn(_9c,req);
if(_9e){
_9c=_9e;
}
}
},callback:function(){
this.excCallbackSeq(this.req,this.callbacks);
},errback:function(){
if(this.errbacks.length==0){
alert("Error encountered:\n"+this.req.responseText);
}
this.excCallbackSeq(this.req,this.errbacks);
},addErrback:function(fn){
this.errbacks.unshift(fn);
},addCallback:function(fn){
this.callbacks.unshift(fn);
},addCallbacks:function(fn1,fn2){
this.addCallback(fn1);
this.addErrback(fn2);
},sendReq:function(_a3){
if(AJS.isObject(_a3)){
this.req.send(AJS.queryArguments(_a3));
}else{
if(AJS.isDefined(_a3)){
this.req.send(_a3);
}else{
this.req.send("");
}
}
}};
script_loaded=true;


script_loaded=true;
/*--------------------------------------------------------------------------*/
///shared/client_scripts/greybox/AJS_fx.js
/*--------------------------------------------------------------------------*/
AJS.fx={_shades:{0:"ffffff",1:"ffffee",2:"ffffdd",3:"ffffcc",4:"ffffbb",5:"ffffaa",6:"ffff99"},highlight:function(_1,_2){
var _3=new AJS.fx.Base();
_3.elm=AJS.$(_1);
_3.setOptions(_2);
_3.options.duration=600;
AJS.update(_3,{increase:function(){
if(this.now==7){
_1.style.backgroundColor="transparent";
}else{
_1.style.backgroundColor="#"+AJS.fx._shades[Math.floor(this.now)];
}
}});
return _3.custom(6,0);
},fadeIn:function(_4,_5){
_5=_5||{};
if(!_5.from){
_5.from=0;
AJS.setOpacity(_4,0);
}
if(!_5.to){
_5.to=1;
}
var s=new AJS.fx.Style(_4,"opacity",_5);
return s.custom(_5.from,_5.to);
},fadeOut:function(_7,_8){
_8=_8||{};
if(!_8.from){
_8.from=1;
}
if(!_8.to){
_8.to=0;
}
_8.duration=300;
var s=new AJS.fx.Style(_7,"opacity",_8);
return s.custom(_8.from,_8.to);
},setWidth:function(_a,_b){
var s=new AJS.fx.Style(_a,"width",_b);
return s.custom(_b.from,_b.to);
},setHeight:function(_d,_e){
var s=new AJS.fx.Style(_d,"height",_e);
return s.custom(_e.from,_e.to);
}};
AJS.fx.Base=new AJS.Class({init:function(){
AJS.bindMethods(this);
},setOptions:function(_10){
this.options=AJS.update({onStart:function(){
},onComplete:function(){
},transition:AJS.fx.Transitions.sineInOut,duration:500,wait:true,fps:50},_10||{});
},step:function(){
var _11=new Date().getTime();
if(_11<this.time+this.options.duration){
this.cTime=_11-this.time;
this.setNow();
}else{
setTimeout(AJS.$b(this.options.onComplete,this,[this.elm]),10);
this.clearTimer();
this.now=this.to;
}
this.increase();
},setNow:function(){
this.now=this.compute(this.from,this.to);
},compute:function(_12,to){
var _14=to-_12;
return this.options.transition(this.cTime,_12,_14,this.options.duration);
},clearTimer:function(){
clearInterval(this.timer);
this.timer=null;
return this;
},_start:function(_15,to){
if(!this.options.wait){
this.clearTimer();
}
if(this.timer){
return;
}
setTimeout(AJS.$p(this.options.onStart,this.elm),10);
this.from=_15;
this.to=to;
this.time=new Date().getTime();
this.timer=setInterval(this.step,Math.round(1000/this.options.fps));
return this;
},custom:function(_17,to){
return this._start(_17,to);
},set:function(to){
this.now=to;
this.increase();
return this;
},setStyle:function(elm,_1b,val){
if(this.property=="opacity"){
AJS.setOpacity(elm,val);
}else{
AJS.setStyle(elm,_1b,val);
}
}});
AJS.fx.Style=AJS.fx.Base.extend({init:function(elm,_1e,_1f){
this.parent();
this.elm=elm;
this.setOptions(_1f);
this.property=_1e;
},increase:function(){
this.setStyle(this.elm,this.property,this.now);
}});
AJS.fx.Styles=AJS.fx.Base.extend({init:function(elm,_21){
this.parent();
this.elm=AJS.$(elm);
this.setOptions(_21);
this.now={};
},setNow:function(){
for(p in this.from){
this.now[p]=this.compute(this.from[p],this.to[p]);
}
},custom:function(obj){
if(this.timer&&this.options.wait){
return;
}
var _23={};
var to={};
for(p in obj){
_23[p]=obj[p][0];
to[p]=obj[p][1];
}
return this._start(_23,to);
},increase:function(){
for(var p in this.now){
this.setStyle(this.elm,p,this.now[p]);
}
}});
AJS.fx.Transitions={linear:function(t,b,c,d){
return c*t/d+b;
},sineInOut:function(t,b,c,d){
return -c/2*(Math.cos(Math.PI*t/d)-1)+b;
}};
script_loaded=true;


script_loaded=true;
/*--------------------------------------------------------------------------*/
///shared/client_scripts/greybox/gb_scripts.js
/*--------------------------------------------------------------------------*/
var GB_CURRENT=null;
GB_hide=function(){
GB_CURRENT.hide();
};
GreyBox=new AJS.Class({init:function(_1){
this.use_fx=AJS.fx;
this.type="page";
this.overlay_click_close=false;
this.salt=0;
this.root_dir=GB_ROOT_DIR;
this.callback_fns=[];
this.reload_on_close=false;
this.src_loader=this.root_dir+"loader_frame.html";
var _2=window.location.hostname.indexOf("www");
var _3=this.src_loader.indexOf("www");
if(_2!=-1&&_3==-1){
this.src_loader=this.src_loader.replace("://","://www.");
}
if(_2==-1&&_3!=-1){
this.src_loader=this.src_loader.replace("://www.","://");
}
this.show_loading=true;
AJS.update(this,_1);
},addCallback:function(fn){
if(fn){
this.callback_fns.push(fn);
}
},show:function(_5){
GB_CURRENT=this;
this.url=_5;
var _6=[AJS.$bytc("object"),AJS.$bytc("select")];
AJS.map(AJS.flattenList(_6),function(_7){
_7.style.visibility="hidden";
});
this.createElements();
return false;
},hide:function(){
var _8=this.callback_fns;
if(_8!=[]){
AJS.map(_8,function(fn){
fn();
});
}
this.onHide();
if(this.use_fx){
var _a=this.overlay;
AJS.fx.fadeOut(this.overlay,{onComplete:function(){
AJS.removeElement(_a);
_a=null;
},duration:300});
AJS.removeElement(this.g_window);
}else{
AJS.removeElement(this.g_window,this.overlay);
}
this.removeFrame();
AJS.REV(window,"scroll",_GB_setOverlayDimension);
AJS.REV(window,"resize",_GB_update);
var _b=[AJS.$bytc("object"),AJS.$bytc("select")];
AJS.map(AJS.flattenList(_b),function(_c){
_c.style.visibility="visible";
});
GB_CURRENT=null;
if(this.reload_on_close){
window.location.reload();
}
},update:function(){
this.setOverlayDimension();
this.setFrameSize();
this.setWindowPosition();
},createElements:function(){
this.initOverlay();
this.g_window=AJS.DIV({"id":"GB_window"});
AJS.hideElement(this.g_window);
AJS.getBody().insertBefore(this.g_window,this.overlay.nextSibling);
this.initFrame();
this.initHook();
this.update();
var me=this;
if(this.use_fx){
AJS.fx.fadeIn(this.overlay,{duration:300,to:0.7,onComplete:function(){
me.onShow();
AJS.showElement(me.g_window);
me.startLoading();
}});
}else{
AJS.setOpacity(this.overlay,0.7);
AJS.showElement(this.g_window);
this.onShow();
this.startLoading();
}
AJS.AEV(window,"scroll",_GB_setOverlayDimension);
AJS.AEV(window,"resize",_GB_update);
},removeFrame:function(){
try{
AJS.removeElement(this.iframe);
}
catch(e){
}
this.iframe=null;
},startLoading:function(){
this.iframe.src=this.src_loader+"?s="+this.salt++;
AJS.showElement(this.iframe);
},setOverlayDimension:function(){
var _e=AJS.getWindowSize();
if(AJS.isMozilla()||AJS.isOpera()){
AJS.setWidth(this.overlay,"100%");
}else{
AJS.setWidth(this.overlay,_e.w);
}
var _f=Math.max(AJS.getScrollTop()+_e.h,AJS.getScrollTop()+this.height);
if(_f<AJS.getScrollTop()){
AJS.setHeight(this.overlay,_f);
}else{
AJS.setHeight(this.overlay,AJS.getScrollTop()+_e.h);
}
},initOverlay:function(){
this.overlay=AJS.DIV({"id":"GB_overlay"});
if(this.overlay_click_close){
AJS.AEV(this.overlay,"click",GB_hide);
}
AJS.setOpacity(this.overlay,0);
AJS.getBody().insertBefore(this.overlay,AJS.getBody().firstChild);
},initFrame:function(){
if(!this.iframe){
var d={"name":"GB_frame","class":"GB_frame","frameBorder":0};
this.iframe=AJS.IFRAME(d);
this.middle_cnt=AJS.DIV({"class":"content"},this.iframe);
this.top_cnt=AJS.DIV();
this.bottom_cnt=AJS.DIV();
AJS.ACN(this.g_window,this.top_cnt,this.middle_cnt,this.bottom_cnt);
}
},onHide:function(){
},onShow:function(){
},setFrameSize:function(){
},setWindowPosition:function(){
},initHook:function(){
}});
_GB_update=function(){
if(GB_CURRENT){
GB_CURRENT.update();
}
};
_GB_setOverlayDimension=function(){
if(GB_CURRENT){
GB_CURRENT.setOverlayDimension();
}
};
AJS.preloadImages(GB_ROOT_DIR+"indicator.gif");
script_loaded=true;
var GB_SETS={};
function decoGreyboxLinks(){
var as=AJS.$bytc("a");
AJS.map(as,function(a){
if(a.getAttribute("href")&&a.getAttribute("rel")){
var rel=a.getAttribute("rel");
if(rel.indexOf("gb_")==0){
var _14=rel.match(/\w+/)[0];
var _15=rel.match(/\[(.*)\]/)[1];
var _16=0;
var _17={"caption":a.title||"","url":a.href};
if(_14=="gb_pageset"||_14=="gb_imageset"){
if(!GB_SETS[_15]){
GB_SETS[_15]=[];
}
GB_SETS[_15].push(_17);
_16=GB_SETS[_15].length;
}
if(_14=="gb_pageset"){
a.onclick=function(){
GB_showFullScreenSet(GB_SETS[_15],_16);
return false;
};
}
if(_14=="gb_imageset"){
a.onclick=function(){
GB_showImageSet(GB_SETS[_15],_16);
return false;
};
}
if(_14=="gb_image"){
a.onclick=function(){
GB_showImage(_17.caption,_17.url);
return false;
};
}
if(_14=="gb_page"){
a.onclick=function(){
var sp=_15.split(/, ?/);
GB_show(_17.caption,_17.url,parseInt(sp[1]),parseInt(sp[0]));
return false;
};
}
if(_14=="gb_page_fs"){
a.onclick=function(){
GB_showFullScreen(_17.caption,_17.url);
return false;
};
}
if(_14=="gb_page_center"){
a.onclick=function(){
var sp=_15.split(/, ?/);
GB_showCenter(_17.caption,_17.url,parseInt(sp[1]),parseInt(sp[0]));
return false;
};
}
}
}
});
}
AJS.AEV(window,"load",decoGreyboxLinks);
GB_showImage=function(_1a,url,_1c){
var _1d={width:300,height:300,type:"image",fullscreen:false,center_win:true,caption:_1a,callback_fn:_1c};
var win=new GB_Gallery(_1d);
return win.show(url);
};
GB_showPage=function(_1f,url,_21){
var _22={type:"page",caption:_1f,callback_fn:_21,fullscreen:true,center_win:false};
var win=new GB_Gallery(_22);
return win.show(url);
};
GB_Gallery=GreyBox.extend({init:function(_24){
this.parent({});
this.img_close=this.root_dir+"g_close.gif";
AJS.update(this,_24);
this.addCallback(this.callback_fn);
},initHook:function(){
AJS.addClass(this.g_window,"GB_Gallery");
var _25=AJS.DIV({"class":"inner"});
this.header=AJS.DIV({"class":"GB_header"},_25);
AJS.setOpacity(this.header,0);
AJS.getBody().insertBefore(this.header,this.overlay.nextSibling);
var _26=AJS.TD({"id":"GB_caption","class":"caption","width":"40%"},this.caption);
var _27=AJS.TD({"id":"GB_middle","class":"middle","width":"20%"});
var _28=AJS.IMG({"src":this.img_close});
AJS.AEV(_28,"click",GB_hide);
var _29=AJS.TD({"class":"close","width":"40%"},_28);
var _2a=AJS.TBODY(AJS.TR(_26,_27,_29));
var _2b=AJS.TABLE({"cellspacing":"0","cellpadding":0,"border":0},_2a);
AJS.ACN(_25,_2b);
if(this.fullscreen){
AJS.AEV(window,"scroll",AJS.$b(this.setWindowPosition,this));
}else{
AJS.AEV(window,"scroll",AJS.$b(this._setHeaderPos,this));
}
},setFrameSize:function(){
var _2c=this.overlay.offsetWidth;
var _2d=AJS.getWindowSize();
if(this.fullscreen){
this.width=_2c-40;
this.height=_2d.h-80;
}
AJS.setWidth(this.iframe,this.width);
AJS.setHeight(this.iframe,this.height);
AJS.setWidth(this.header,_2c);
},_setHeaderPos:function(){
AJS.setTop(this.header,AJS.getScrollTop()+10);
},setWindowPosition:function(){
var _2e=this.overlay.offsetWidth;
var _2f=AJS.getWindowSize();
AJS.setLeft(this.g_window,((_2e-50-this.width)/2));
var _30=AJS.getScrollTop()+55;
if(!this.center_win){
AJS.setTop(this.g_window,_30);
}else{
var fl=((_2f.h-this.height)/2)+20+AJS.getScrollTop();
if(fl<0){
fl=0;
}
if(_30>fl){
fl=_30;
}
AJS.setTop(this.g_window,fl);
}
this._setHeaderPos();
},onHide:function(){
AJS.removeElement(this.header);
AJS.removeClass(this.g_window,"GB_Gallery");
},onShow:function(){
if(this.use_fx){
AJS.fx.fadeIn(this.header,{to:1});
}else{
AJS.setOpacity(this.header,1);
}
}});
AJS.preloadImages(GB_ROOT_DIR+"g_close.gif");
GB_showFullScreenSet=function(set,_33,_34){
var _35={type:"page",fullscreen:true,center_win:false};
var _36=new GB_Sets(_35,set);
_36.addCallback(_34);
_36.showSet(_33-1);
return false;
};
GB_showImageSet=function(set,_38,_39){
var _3a={type:"image",fullscreen:false,center_win:true,width:300,height:300};
var _3b=new GB_Sets(_3a,set);
_3b.addCallback(_39);
_3b.showSet(_38-1);
return false;
};
GB_Sets=GB_Gallery.extend({init:function(_3c,set){
this.parent(_3c);
if(!this.img_next){
this.img_next=this.root_dir+"next.gif";
}
if(!this.img_prev){
this.img_prev=this.root_dir+"prev.gif";
}
this.current_set=set;
},showSet:function(_3e){
this.current_index=_3e;
var _3f=this.current_set[this.current_index];
this.show(_3f.url);
this._setCaption(_3f.caption);
this.btn_prev=AJS.IMG({"class":"left",src:this.img_prev});
this.btn_next=AJS.IMG({"class":"right",src:this.img_next});
AJS.AEV(this.btn_prev,"click",AJS.$b(this.switchPrev,this));
AJS.AEV(this.btn_next,"click",AJS.$b(this.switchNext,this));
GB_STATUS=AJS.SPAN({"class":"GB_navStatus"});
AJS.ACN(AJS.$("GB_middle"),this.btn_prev,GB_STATUS,this.btn_next);
this.updateStatus();
},updateStatus:function(){
AJS.setHTML(GB_STATUS,(this.current_index+1)+" / "+this.current_set.length);
if(this.current_index==0){
AJS.addClass(this.btn_prev,"disabled");
}else{
AJS.removeClass(this.btn_prev,"disabled");
}
if(this.current_index==this.current_set.length-1){
AJS.addClass(this.btn_next,"disabled");
}else{
AJS.removeClass(this.btn_next,"disabled");
}
},_setCaption:function(_40){
AJS.setHTML(AJS.$("GB_caption"),_40);
},updateFrame:function(){
var _41=this.current_set[this.current_index];
this._setCaption(_41.caption);
this.url=_41.url;
this.startLoading();
},switchPrev:function(){
if(this.current_index!=0){
this.current_index--;
this.updateFrame();
this.updateStatus();
}
},switchNext:function(){
if(this.current_index!=this.current_set.length-1){
this.current_index++;
this.updateFrame();
this.updateStatus();
}
}});
AJS.AEV(window,"load",function(){
AJS.preloadImages(GB_ROOT_DIR+"next.gif",GB_ROOT_DIR+"prev.gif");
});
GB_show=function(_42,url,_44,_45,_46){
var _47={caption:_42,height:_44||500,width:_45||500,fullscreen:false,callback_fn:_46};
var win=new GB_Window(_47);
return win.show(url);
};
GB_showCenter=function(_49,url,_4b,_4c,_4d){
var _4e={caption:_49,center_win:true,height:_4b||500,width:_4c||500,fullscreen:false,callback_fn:_4d};
var win=new GB_Window(_4e);
return win.show(url);
};
GB_showFullScreen=function(_50,url,_52){
var _53={caption:_50,fullscreen:true,callback_fn:_52};
var win=new GB_Window(_53);
return win.show(url);
};
GB_Window=GreyBox.extend({init:function(_55){
this.parent({});
this.img_header=this.root_dir+"header_bg.gif";
this.img_close=this.root_dir+"w_close.gif";
this.show_close_img=true;
AJS.update(this,_55);
this.addCallback(this.callback_fn);
},initHook:function(){
AJS.addClass(this.g_window,"GB_Window");
this.header=AJS.TABLE({"class":"header"});
this.header.style.backgroundImage="url("+this.img_header+")";
var _56=AJS.TD({"class":"caption"},this.caption);
var _57=AJS.TD({"class":"close"});
if(this.show_close_img){
var _58=AJS.IMG({"src":this.img_close});
var _59=AJS.SPAN("Close");
var btn=AJS.DIV(_58,_59);
AJS.AEV([_58,_59],"mouseover",function(){
AJS.addClass(_59,"on");
});
AJS.AEV([_58,_59],"mouseout",function(){
AJS.removeClass(_59,"on");
});
AJS.AEV([_58,_59],"mousedown",function(){
AJS.addClass(_59,"click");
});
AJS.AEV([_58,_59],"mouseup",function(){
AJS.removeClass(_59,"click");
});
AJS.AEV([_58,_59],"click",GB_hide);
AJS.ACN(_57,btn);
}
tbody_header=AJS.TBODY();
AJS.ACN(tbody_header,AJS.TR(_56,_57));
AJS.ACN(this.header,tbody_header);
AJS.ACN(this.top_cnt,this.header);
if(this.fullscreen){
AJS.AEV(window,"scroll",AJS.$b(this.setWindowPosition,this));
}
},setFrameSize:function(){
if(this.fullscreen){
var _5b=AJS.getWindowSize();
overlay_h=_5b.h;
this.width=Math.round(this.overlay.offsetWidth-(this.overlay.offsetWidth/100)*10);
this.height=Math.round(overlay_h-(overlay_h/100)*10);
}
AJS.setWidth(this.header,this.width+6);
AJS.setWidth(this.iframe,this.width);
AJS.setHeight(this.iframe,this.height);
},setWindowPosition:function(){
var _5c=AJS.getWindowSize();
AJS.setLeft(this.g_window,((_5c.w-this.width)/2)-13);
if(!this.center_win){
AJS.setTop(this.g_window,AJS.getScrollTop());
}else{
var fl=((_5c.h-this.height)/2)-20+AJS.getScrollTop();
if(fl<0){
fl=0;
}
AJS.setTop(this.g_window,fl);
}
}});
AJS.preloadImages(GB_ROOT_DIR+"w_close.gif",GB_ROOT_DIR+"header_bg.gif");


script_loaded=true;
/*--------------------------------------------------------------------------*/
///shared/client_scripts/ajax/scriptaculous/lib/prototype.js
/*--------------------------------------------------------------------------*/
/*  Prototype JavaScript framework, version 1.6.1
 *  (c) 2005-2009 Sam Stephenson
 *
 *  Prototype is freely distributable under the terms of an MIT-style license.
 *  For details, see the Prototype web site: http://www.prototypejs.org/
 *
 *--------------------------------------------------------------------------*/

var Prototype = {
  Version: '1.6.1',

  Browser: (function(){
    var ua = navigator.userAgent;
    var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
    return {
      IE:             !!window.attachEvent && !isOpera,
      Opera:          isOpera,
      WebKit:         ua.indexOf('AppleWebKit/') > -1,
      Gecko:          ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,
      MobileSafari:   /Apple.*Mobile.*Safari/.test(ua)
    }
  })(),

  BrowserFeatures: {
    XPath: !!document.evaluate,
    SelectorsAPI: !!document.querySelector,
    ElementExtensions: (function() {
      var constructor = window.Element || window.HTMLElement;
      return !!(constructor && constructor.prototype);
    })(),
    SpecificElementExtensions: (function() {
      if (typeof window.HTMLDivElement !== 'undefined')
        return true;

      var div = document.createElement('div');
      var form = document.createElement('form');
      var isSupported = false;

      if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
        isSupported = true;
      }

      div = form = null;

      return isSupported;
    })()
  },

  ScriptFragment: '<script[^>]*>([\\S\\s]*?)<\/script>',
  JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,

  emptyFunction: function() { },
  K: function(x) { return x }
};

if (Prototype.Browser.MobileSafari)
  Prototype.BrowserFeatures.SpecificElementExtensions = false;


var Abstract = { };


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

    for (var i = 0, length = arguments.length; i < length; i++) {
      var lambda = arguments[i];
      try {
        returnValue = lambda();
        break;
      } catch (e) { }
    }

    return returnValue;
  }
};

/* Based on Alex Arnell's inheritance implementation. */

var Class = (function() {
  function subclass() {};
  function create() {
    var parent = null, properties = $A(arguments);
    if (Object.isFunction(properties[0]))
      parent = properties.shift();

    function klass() {
      this.initialize.apply(this, arguments);
    }

    Object.extend(klass, Class.Methods);
    klass.superclass = parent;
    klass.subclasses = [];

    if (parent) {
      subclass.prototype = parent.prototype;
      klass.prototype = new subclass;
      parent.subclasses.push(klass);
    }

    for (var i = 0; i < properties.length; i++)
      klass.addMethods(properties[i]);

    if (!klass.prototype.initialize)
      klass.prototype.initialize = Prototype.emptyFunction;

    klass.prototype.constructor = klass;
    return klass;
  }

  function addMethods(source) {
    var ancestor   = this.superclass && this.superclass.prototype;
    var properties = Object.keys(source);

    if (!Object.keys({ toString: true }).length) {
      if (source.toString != Object.prototype.toString)
        properties.push("toString");
      if (source.valueOf != Object.prototype.valueOf)
        properties.push("valueOf");
    }

    for (var i = 0, length = properties.length; i < length; i++) {
      var property = properties[i], value = source[property];
      if (ancestor && Object.isFunction(value) &&
          value.argumentNames().first() == "$super") {
        var method = value;
        value = (function(m) {
          return function() { return ancestor[m].apply(this, arguments); };
        })(property).wrap(method);

        value.valueOf = method.valueOf.bind(method);
        value.toString = method.toString.bind(method);
      }
      this.prototype[property] = value;
    }

    return this;
  }

  return {
    create: create,
    Methods: {
      addMethods: addMethods
    }
  };
})();
(function() {

  var _toString = Object.prototype.toString;

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

  function inspect(object) {
    try {
      if (isUndefined(object)) return 'undefined';
      if (object === null) return 'null';
      return object.inspect ? object.inspect() : String(object);
    } catch (e) {
      if (e instanceof RangeError) return '...';
      throw e;
    }
  }

  function toJSON(object) {
    var type = typeof object;
    switch (type) {
      case 'undefined':
      case 'function':
      case 'unknown': return;
      case 'boolean': return object.toString();
    }

    if (object === null) return 'null';
    if (object.toJSON) return object.toJSON();
    if (isElement(object)) return;

    var results = [];
    for (var property in object) {
      var value = toJSON(object[property]);
      if (!isUndefined(value))
        results.push(property.toJSON() + ': ' + value);
    }

    return '{' + results.join(', ') + '}';
  }

  function toQueryString(object) {
    return $H(object).toQueryString();
  }

  function toHTML(object) {
    return object && object.toHTML ? object.toHTML() : String.interpret(object);
  }

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

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

  function clone(object) {
    return extend({ }, object);
  }

  function isElement(object) {
    return !!(object && object.nodeType == 1);
  }

  function isArray(object) {
    return _toString.call(object) == "[object Array]";
  }


  function isHash(object) {
    return object instanceof Hash;
  }

  function isFunction(object) {
    return typeof object === "function";
  }

  function isString(object) {
    return _toString.call(object) == "[object String]";
  }

  function isNumber(object) {
    return _toString.call(object) == "[object Number]";
  }

  function isUndefined(object) {
    return typeof object === "undefined";
  }

  extend(Object, {
    extend:        extend,
    inspect:       inspect,
    toJSON:        toJSON,
    toQueryString: toQueryString,
    toHTML:        toHTML,
    keys:          keys,
    values:        values,
    clone:         clone,
    isElement:     isElement,
    isArray:       isArray,
    isHash:        isHash,
    isFunction:    isFunction,
    isString:      isString,
    isNumber:      isNumber,
    isUndefined:   isUndefined
  });
})();
Object.extend(Function.prototype, (function() {
  var slice = Array.prototype.slice;

  function update(array, args) {
    var arrayLength = array.length, length = args.length;
    while (length--) array[arrayLength + length] = args[length];
    return array;
  }

  function merge(array, args) {
    array = slice.call(array, 0);
    return update(array, args);
  }

  function argumentNames() {
    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
      .replace(/\s+/g, '').split(',');
    return names.length == 1 && !names[0] ? [] : names;
  }

  function bind(context) {
    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
    var __method = this, args = slice.call(arguments, 1);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(context, a);
    }
  }

  function bindAsEventListener(context) {
    var __method = this, args = slice.call(arguments, 1);
    return function(event) {
      var a = update([event || window.event], args);
      return __method.apply(context, a);
    }
  }

  function curry() {
    if (!arguments.length) return this;
    var __method = this, args = slice.call(arguments, 0);
    return function() {
      var a = merge(args, arguments);
      return __method.apply(this, a);
    }
  }

  function delay(timeout) {
    var __method = this, args = slice.call(arguments, 1);
    timeout = timeout * 1000
    return window.setTimeout(function() {
      return __method.apply(__method, args);
    }, timeout);
  }

  function defer() {
    var args = update([0.01], arguments);
    return this.delay.apply(this, args);
  }

  function wrap(wrapper) {
    var __method = this;
    return function() {
      var a = update([__method.bind(this)], arguments);
      return wrapper.apply(this, a);
    }
  }

  function methodize() {
    if (this._methodized) return this._methodized;
    var __method = this;
    return this._methodized = function() {
      var a = update([this], arguments);
      return __method.apply(null, a);
    };
  }

  return {
    argumentNames:       argumentNames,
    bind:                bind,
    bindAsEventListener: bindAsEventListener,
    curry:               curry,
    delay:               delay,
    defer:               defer,
    wrap:                wrap,
    methodize:           methodize
  }
})());


Date.prototype.toJSON = function() {
  return '"' + this.getUTCFullYear() + '-' +
    (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
    this.getUTCDate().toPaddedString(2) + 'T' +
    this.getUTCHours().toPaddedString(2) + ':' +
    this.getUTCMinutes().toPaddedString(2) + ':' +
    this.getUTCSeconds().toPaddedString(2) + 'Z"';
};


RegExp.prototype.match = RegExp.prototype.test;

RegExp.escape = function(str) {
  return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
};
var PeriodicalExecuter = Class.create({
  initialize: function(callback, frequency) {
    this.callback = callback;
    this.frequency = frequency;
    this.currentlyExecuting = false;

    this.registerCallback();
  },

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

  execute: function() {
    this.callback(this);
  },

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

  onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      try {
        this.currentlyExecuting = true;
        this.execute();
        this.currentlyExecuting = false;
      } catch(e) {
        this.currentlyExecuting = false;
        throw e;
      }
    }
  }
});
Object.extend(String, {
  interpret: function(value) {
    return value == null ? '' : String(value);
  },
  specialChar: {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\\': '\\\\'
  }
});

Object.extend(String.prototype, (function() {

  function prepareReplacement(replacement) {
    if (Object.isFunction(replacement)) return replacement;
    var template = new Template(replacement);
    return function(match) { return template.evaluate(match) };
  }

  function gsub(pattern, replacement) {
    var result = '', source = this, match;
    replacement = prepareReplacement(replacement);

    if (Object.isString(pattern))
      pattern = RegExp.escape(pattern);

    if (!(pattern.length || pattern.source)) {
      replacement = replacement('');
      return replacement + source.split('').join(replacement) + replacement;
    }

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

  function sub(pattern, replacement, count) {
    replacement = prepareReplacement(replacement);
    count = Object.isUndefined(count) ? 1 : count;

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

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

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

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

  function stripTags() {
    return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
  }

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

  function extractScripts() {
    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];
    });
  }

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

  function escapeHTML() {
    return this.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
  }

  function unescapeHTML() {
    return this.stripTags().replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');
  }


  function toQueryParams(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return { };

    return match[1].split(separator || '&').inject({ }, function(hash, pair) {
      if ((pair = pair.split('='))[0]) {
        var key = decodeURIComponent(pair.shift());
        var value = pair.length > 1 ? pair.join('=') : pair[0];
        if (value != undefined) value = decodeURIComponent(value);

        if (key in hash) {
          if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
          hash[key].push(value);
        }
        else hash[key] = value;
      }
      return hash;
    });
  }

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

  function succ() {
    return this.slice(0, this.length - 1) +
      String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  }

  function times(count) {
    return count < 1 ? '' : new Array(count + 1).join(this);
  }

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

    var camelized = this.charAt(0) == '-'
      ? parts[0].charAt(0).toUpperCase() + parts[0].substring(1)
      : parts[0];

    for (var i = 1; i < len; i++)
      camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);

    return camelized;
  }

  function capitalize() {
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  }

  function underscore() {
    return this.replace(/::/g, '/')
               .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
               .replace(/([a-z\d])([A-Z])/g, '$1_$2')
               .replace(/-/g, '_')
               .toLowerCase();
  }

  function dasherize() {
    return this.replace(/_/g, '-');
  }

  function inspect(useDoubleQuotes) {
    var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {
      if (character in String.specialChar) {
        return String.specialChar[character];
      }
      return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
    });
    if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
    return "'" + escapedString.replace(/'/g, '\\\'') + "'";
  }

  function toJSON() {
    return this.inspect(true);
  }

  function unfilterJSON(filter) {
    return this.replace(filter || Prototype.JSONFilter, '$1');
  }

  function isJSON() {
    var str = this;
    if (str.blank()) return false;
    str = this.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
    return (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str);
  }

  function evalJSON(sanitize) {
    var json = this.unfilterJSON();
    try {
      if (!sanitize || json.isJSON()) return eval('(' + json + ')');
    } catch (e) { }
    throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
  }

  function include(pattern) {
    return this.indexOf(pattern) > -1;
  }

  function startsWith(pattern) {
    return this.indexOf(pattern) === 0;
  }

  function endsWith(pattern) {
    var d = this.length - pattern.length;
    return d >= 0 && this.lastIndexOf(pattern) === d;
  }

  function empty() {
    return this == '';
  }

  function blank() {
    return /^\s*$/.test(this);
  }

  function interpolate(object, pattern) {
    return new Template(this, pattern).evaluate(object);
  }

  return {
    gsub:           gsub,
    sub:            sub,
    scan:           scan,
    truncate:       truncate,
    strip:          String.prototype.trim ? String.prototype.trim : strip,
    stripTags:      stripTags,
    stripScripts:   stripScripts,
    extractScripts: extractScripts,
    evalScripts:    evalScripts,
    escapeHTML:     escapeHTML,
    unescapeHTML:   unescapeHTML,
    toQueryParams:  toQueryParams,
    parseQuery:     toQueryParams,
    toArray:        toArray,
    succ:           succ,
    times:          times,
    camelize:       camelize,
    capitalize:     capitalize,
    underscore:     underscore,
    dasherize:      dasherize,
    inspect:        inspect,
    toJSON:         toJSON,
    unfilterJSON:   unfilterJSON,
    isJSON:         isJSON,
    evalJSON:       evalJSON,
    include:        include,
    startsWith:     startsWith,
    endsWith:       endsWith,
    empty:          empty,
    blank:          blank,
    interpolate:    interpolate
  };
})());

var Template = Class.create({
  initialize: function(template, pattern) {
    this.template = template.toString();
    this.pattern = pattern || Template.Pattern;
  },

  evaluate: function(object) {
    if (object && Object.isFunction(object.toTemplateReplacements))
      object = object.toTemplateReplacements();

    return this.template.gsub(this.pattern, function(match) {
      if (object == null) return (match[1] + '');

      var before = match[1] || '';
      if (before == '\\') return match[2];

      var ctx = object, expr = match[3];
      var pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
      match = pattern.exec(expr);
      if (match == null) return before;

      while (match != null) {
        var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];
        ctx = ctx[comp];
        if (null == ctx || '' == match[3]) break;
        expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
        match = pattern.exec(expr);
      }

      return before + String.interpret(ctx);
    });
  }
});
Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;

var $break = { };

var Enumerable = (function() {
  function each(iterator, context) {
    var index = 0;
    try {
      this._each(function(value) {
        iterator.call(context, value, index++);
      });
    } catch (e) {
      if (e != $break) throw e;
    }
    return this;
  }

  function eachSlice(number, iterator, context) {
    var index = -number, slices = [], array = this.toArray();
    if (number < 1) return array;
    while ((index += number) < array.length)
      slices.push(array.slice(index, index+number));
    return slices.collect(iterator, context);
  }

  function all(iterator, context) {
    iterator = iterator || Prototype.K;
    var result = true;
    this.each(function(value, index) {
      result = result && !!iterator.call(context, value, index);
      if (!result) throw $break;
    });
    return result;
  }

  function any(iterator, context) {
    iterator = iterator || Prototype.K;
    var result = false;
    this.each(function(value, index) {
      if (result = !!iterator.call(context, value, index))
        throw $break;
    });
    return result;
  }

  function collect(iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];
    this.each(function(value, index) {
      results.push(iterator.call(context, value, index));
    });
    return results;
  }

  function detect(iterator, context) {
    var result;
    this.each(function(value, index) {
      if (iterator.call(context, value, index)) {
        result = value;
        throw $break;
      }
    });
    return result;
  }

  function findAll(iterator, context) {
    var results = [];
    this.each(function(value, index) {
      if (iterator.call(context, value, index))
        results.push(value);
    });
    return results;
  }

  function grep(filter, iterator, context) {
    iterator = iterator || Prototype.K;
    var results = [];

    if (Object.isString(filter))
      filter = new RegExp(RegExp.escape(filter));

    this.each(function(value, index) {
      if (filter.match(value))
        results.push(iterator.call(context, value, index));
    });
    return results;
  }

  function include(object) {
    if (Object.isFunction(this.indexOf))
      if (this.indexOf(object) != -1) return true;

    var found = false;
    this.each(function(value) {
      if (value == object) {
        found = true;
        throw $break;
      }
    });
    return found;
  }

  function inGroupsOf(number, fillWith) {
    fillWith = Object.isUndefined(fillWith) ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(slice.length < number) slice.push(fillWith);
      return slice;
    });
  }

  function inject(memo, iterator, context) {
    this.each(function(value, index) {
      memo = iterator.call(context, memo, value, index);
    });
    return memo;
  }

  function invoke(method) {
    var args = $A(arguments).slice(1);
    return this.map(function(value) {
      return value[method].apply(value, args);
    });
  }

  function max(iterator, context) {
    iterator = iterator || Prototype.K;
    var result;
    this.each(function(value, index) {
      value = iterator.call(context, value, index);
      if (result == null || value >= result)
        result = value;
    });
    return result;
  }

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

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

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

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

  function sortBy(iterator, context) {
    return this.map(function(value, index) {
      return {
        value: value,
        criteria: iterator.call(context, value, index)
      };
    }).sort(function(left, right) {
      var a = left.criteria, b = right.criteria;
      return a < b ? -1 : a > b ? 1 : 0;
    }).pluck('value');
  }

  function toArray() {
    return this.map();
  }

  function zip() {
    var iterator = Prototype.K, args = $A(arguments);
    if (Object.isFunction(args.last()))
      iterator = args.pop();

    var collections = [this].concat(args).map($A);
    return this.map(function(value, index) {
      return iterator(collections.pluck(index));
    });
  }

  function size() {
    return this.toArray().length;
  }

  function inspect() {
    return '#<Enumerable:' + this.toArray().inspect() + '>';
  }









  return {
    each:       each,
    eachSlice:  eachSlice,
    all:        all,
    every:      all,
    any:        any,
    some:       any,
    collect:    collect,
    map:        collect,
    detect:     detect,
    findAll:    findAll,
    select:     findAll,
    filter:     findAll,
    grep:       grep,
    include:    include,
    member:     include,
    inGroupsOf: inGroupsOf,
    inject:     inject,
    invoke:     invoke,
    max:        max,
    min:        min,
    partition:  partition,
    pluck:      pluck,
    reject:     reject,
    sortBy:     sortBy,
    toArray:    toArray,
    entries:    toArray,
    zip:        zip,
    size:       size,
    inspect:    inspect,
    find:       detect
  };
})();
function $A(iterable) {
  if (!iterable) return [];
  if ('toArray' in Object(iterable)) return iterable.toArray();
  var length = iterable.length || 0, results = new Array(length);
  while (length--) results[length] = iterable[length];
  return results;
}

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

Array.from = $A;


(function() {
  var arrayProto = Array.prototype,
      slice = arrayProto.slice,
      _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available

  function each(iterator) {
    for (var i = 0, length = this.length; i < length; i++)
      iterator(this[i]);
  }
  if (!_each) _each = each;

  function clear() {
    this.length = 0;
    return this;
  }

  function first() {
    return this[0];
  }

  function last() {
    return this[this.length - 1];
  }

  function compact() {
    return this.select(function(value) {
      return value != null;
    });
  }

  function flatten() {
    return this.inject([], function(array, value) {
      if (Object.isArray(value))
        return array.concat(value.flatten());
      array.push(value);
      return array;
    });
  }

  function without() {
    var values = slice.call(arguments, 0);
    return this.select(function(value) {
      return !values.include(value);
    });
  }

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

  function uniq(sorted) {
    return this.inject([], function(array, value, index) {
      if (0 == index || (sorted ? array.last() != value : !array.include(value)))
        array.push(value);
      return array;
    });
  }

  function intersect(array) {
    return this.uniq().findAll(function(item) {
      return array.detect(function(value) { return item === value });
    });
  }


  function clone() {
    return slice.call(this, 0);
  }

  function size() {
    return this.length;
  }

  function inspect() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }

  function toJSON() {
    var results = [];
    this.each(function(object) {
      var value = Object.toJSON(object);
      if (!Object.isUndefined(value)) results.push(value);
    });
    return '[' + results.join(', ') + ']';
  }

  function indexOf(item, i) {
    i || (i = 0);
    var length = this.length;
    if (i < 0) i = length + i;
    for (; i < length; i++)
      if (this[i] === item) return i;
    return -1;
  }

  function lastIndexOf(item, i) {
    i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
    var n = this.slice(0, i).reverse().indexOf(item);
    return (n < 0) ? n : i - n - 1;
  }

  function concat() {
    var array = slice.call(this, 0), item;
    for (var i = 0, length = arguments.length; i < length; i++) {
      item = arguments[i];
      if (Object.isArray(item) && !('callee' in item)) {
        for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
          array.push(item[j]);
      } else {
        array.push(item);
      }
    }
    return array;
  }

  Object.extend(arrayProto, Enumerable);

  if (!arrayProto._reverse)
    arrayProto._reverse = arrayProto.reverse;

  Object.extend(arrayProto, {
    _each:     _each,
    clear:     clear,
    first:     first,
    last:      last,
    compact:   compact,
    flatten:   flatten,
    without:   without,
    reverse:   reverse,
    uniq:      uniq,
    intersect: intersect,
    clone:     clone,
    toArray:   clone,
    size:      size,
    inspect:   inspect,
    toJSON:    toJSON
  });

  var CONCAT_ARGUMENTS_BUGGY = (function() {
    return [].concat(arguments)[0][0] !== 1;
  })(1,2)

  if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;

  if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
  if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
})();
function $H(object) {
  return new Hash(object);
};

var Hash = Class.create(Enumerable, (function() {
  function initialize(object) {
    this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
  }

  function _each(iterator) {
    for (var key in this._object) {
      var value = this._object[key], pair = [key, value];
      pair.key = key;
      pair.value = value;
      iterator(pair);
    }
  }

  function set(key, value) {
    return this._object[key] = value;
  }

  function get(key) {
    if (this._object[key] !== Object.prototype[key])
      return this._object[key];
  }

  function unset(key) {
    var value = this._object[key];
    delete this._object[key];
    return value;
  }

  function toObject() {
    return Object.clone(this._object);
  }

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

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

  function index(value) {
    var match = this.detect(function(pair) {
      return pair.value === value;
    });
    return match && match.key;
  }

  function merge(object) {
    return this.clone().update(object);
  }

  function update(object) {
    return new Hash(object).inject(this, function(result, pair) {
      result.set(pair.key, pair.value);
      return result;
    });
  }

  function toQueryPair(key, value) {
    if (Object.isUndefined(value)) return key;
    return key + '=' + encodeURIComponent(String.interpret(value));
  }

  function toQueryString() {
    return this.inject([], function(results, pair) {
      var key = encodeURIComponent(pair.key), values = pair.value;

      if (values && typeof values == 'object') {
        if (Object.isArray(values))
          return results.concat(values.map(toQueryPair.curry(key)));
      } else results.push(toQueryPair(key, values));
      return results;
    }).join('&');
  }

  function inspect() {
    return '#<Hash:{' + this.map(function(pair) {
      return pair.map(Object.inspect).join(': ');
    }).join(', ') + '}>';
  }

  function toJSON() {
    return Object.toJSON(this.toObject());
  }

  function clone() {
    return new Hash(this);
  }

  return {
    initialize:             initialize,
    _each:                  _each,
    set:                    set,
    get:                    get,
    unset:                  unset,
    toObject:               toObject,
    toTemplateReplacements: toObject,
    keys:                   keys,
    values:                 values,
    index:                  index,
    merge:                  merge,
    update:                 update,
    toQueryString:          toQueryString,
    inspect:                inspect,
    toJSON:                 toJSON,
    clone:                  clone
  };
})());

Hash.from = $H;
Object.extend(Number.prototype, (function() {
  function toColorPart() {
    return this.toPaddedString(2, 16);
  }

  function succ() {
    return this + 1;
  }

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

  function toPaddedString(length, radix) {
    var string = this.toString(radix || 10);
    return '0'.times(length - string.length) + string;
  }

  function toJSON() {
    return isFinite(this) ? this.toString() : 'null';
  }

  function abs() {
    return Math.abs(this);
  }

  function round() {
    return Math.round(this);
  }

  function ceil() {
    return Math.ceil(this);
  }

  function floor() {
    return Math.floor(this);
  }

  return {
    toColorPart:    toColorPart,
    succ:           succ,
    times:          times,
    toPaddedString: toPaddedString,
    toJSON:         toJSON,
    abs:            abs,
    round:          round,
    ceil:           ceil,
    floor:          floor
  };
})());

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

var ObjectRange = Class.create(Enumerable, (function() {
  function initialize(start, end, exclusive) {
    this.start = start;
    this.end = end;
    this.exclusive = exclusive;
  }

  function _each(iterator) {
    var value = this.start;
    while (this.include(value)) {
      iterator(value);
      value = value.succ();
    }
  }

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

  return {
    initialize: initialize,
    _each:      _each,
    include:    include
  };
})());



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

  activeRequestCount: 0
};

Ajax.Responders = {
  responders: [],

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

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

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

  dispatch: function(callback, request, transport, json) {
    this.each(function(responder) {
      if (Object.isFunction(responder[callback])) {
        try {
          responder[callback].apply(responder, [request, transport, json]);
        } catch (e) { }
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate:   function() { Ajax.activeRequestCount++ },
  onComplete: function() { Ajax.activeRequestCount-- }
});
Ajax.Base = Class.create({
  initialize: function(options) {
    this.options = {
      method:       'post',
      asynchronous: true,
      contentType:  'application/x-www-form-urlencoded',
      encoding:     'UTF-8',
      parameters:   '',
      evalJSON:     true,
      evalJS:       true
    };
    Object.extend(this.options, options || { });

    this.options.method = this.options.method.toLowerCase();

    if (Object.isString(this.options.parameters))
      this.options.parameters = this.options.parameters.toQueryParams();
    else if (Object.isHash(this.options.parameters))
      this.options.parameters = this.options.parameters.toObject();
  }
});
Ajax.Request = Class.create(Ajax.Base, {
  _complete: false,

  initialize: function($super, url, options) {
    $super(options);
    this.transport = Ajax.getTransport();
    this.request(url);
  },

  request: function(url) {
    this.url = url;
    this.method = this.options.method;
    var params = Object.clone(this.options.parameters);

    if (!['get', 'post'].include(this.method)) {
      params['_method'] = this.method;
      this.method = 'post';
    }

    this.parameters = params;

    if (params = Object.toQueryString(params)) {
      if (this.method == 'get')
        this.url += (this.url.include('?') ? '&' : '?') + params;
      else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
        params += '&_=';
    }

    try {
      var response = new Ajax.Response(this);
      if (this.options.onCreate) this.options.onCreate(response);
      Ajax.Responders.dispatch('onCreate', this, response);

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

      if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);

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

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

      /* Force Firefox to handle ready state 4 for synchronous requests */
      if (!this.options.asynchronous && this.transport.overrideMimeType)
        this.onStateChange();

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

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

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

    if (this.method == 'post') {
      headers['Content-type'] = this.options.contentType +
        (this.options.encoding ? '; charset=' + this.options.encoding : '');

      /* Force "Connection: close" for older Mozilla browsers to work
       * around a bug where XMLHttpRequest sends an incorrect
       * Content-length header. See Mozilla Bugzilla #246651.
       */
      if (this.transport.overrideMimeType &&
          (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
            headers['Connection'] = 'close';
    }

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

      if (Object.isFunction(extras.push))
        for (var i = 0, length = extras.length; i < length; i += 2)
          headers[extras[i]] = extras[i+1];
      else
        $H(extras).each(function(pair) { headers[pair.key] = pair.value });
    }

    for (var name in headers)
      this.transport.setRequestHeader(name, headers[name]);
  },

  success: function() {
    var status = this.getStatus();
    return !status || (status >= 200 && status < 300);
  },

  getStatus: function() {
    try {
      return this.transport.status || 0;
    } catch (e) { return 0 }
  },

  respondToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);

    if (state == 'Complete') {
      try {
        this._complete = true;
        (this.options['on' + response.status]
         || this.options['on' + (this.success() ? 'Success' : 'Failure')]
         || Prototype.emptyFunction)(response, response.headerJSON);
      } catch (e) {
        this.dispatchException(e);
      }

      var contentType = response.getHeader('Content-type');
      if (this.options.evalJS == 'force'
          || (this.options.evalJS && this.isSameOrigin() && contentType
          && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
        this.evalResponse();
    }

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

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

  isSameOrigin: function() {
    var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
    return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
      protocol: location.protocol,
      domain: document.domain,
      port: location.port ? ':' + location.port : ''
    }));
  },

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

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

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

Ajax.Request.Events =
  ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];








Ajax.Response = Class.create({
  initialize: function(request){
    this.request = request;
    var transport  = this.transport  = request.transport,
        readyState = this.readyState = transport.readyState;

    if((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
      this.status       = this.getStatus();
      this.statusText   = this.getStatusText();
      this.responseText = String.interpret(transport.responseText);
      this.headerJSON   = this._getHeaderJSON();
    }

    if(readyState == 4) {
      var xml = transport.responseXML;
      this.responseXML  = Object.isUndefined(xml) ? null : xml;
      this.responseJSON = this._getResponseJSON();
    }
  },

  status:      0,

  statusText: '',

  getStatus: Ajax.Request.prototype.getStatus,

  getStatusText: function() {
    try {
      return this.transport.statusText || '';
    } catch (e) { return '' }
  },

  getHeader: Ajax.Request.prototype.getHeader,

  getAllHeaders: function() {
    try {
      return this.getAllResponseHeaders();
    } catch (e) { return null }
  },

  getResponseHeader: function(name) {
    return this.transport.getResponseHeader(name);
  },

  getAllResponseHeaders: function() {
    return this.transport.getAllResponseHeaders();
  },

  _getHeaderJSON: function() {
    var json = this.getHeader('X-JSON');
    if (!json) return null;
    json = decodeURIComponent(escape(json));
    try {
      return json.evalJSON(this.request.options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  },

  _getResponseJSON: function() {
    var options = this.request.options;
    if (!options.evalJSON || (options.evalJSON != 'force' &&
      !(this.getHeader('Content-type') || '').include('application/json')) ||
        this.responseText.blank())
          return null;
    try {
      return this.responseText.evalJSON(options.sanitizeJSON ||
        !this.request.isSameOrigin());
    } catch (e) {
      this.request.dispatchException(e);
    }
  }
});

Ajax.Updater = Class.create(Ajax.Request, {
  initialize: function($super, container, url, options) {
    this.container = {
      success: (container.success || container),
      failure: (container.failure || (container.success ? null : container))
    };

    options = Object.clone(options);
    var onComplete = options.onComplete;
    options.onComplete = (function(response, json) {
      this.updateContent(response.responseText);
      if (Object.isFunction(onComplete)) onComplete(response, json);
    }).bind(this);

    $super(url, options);
  },

  updateContent: function(responseText) {
    var receiver = this.container[this.success() ? 'success' : 'failure'],
        options = this.options;

    if (!options.evalScripts) responseText = responseText.stripScripts();

    if (receiver = $(receiver)) {
      if (options.insertion) {
        if (Object.isString(options.insertion)) {
          var insertion = { }; insertion[options.insertion] = responseText;
          receiver.insert(insertion);
        }
        else options.insertion(receiver, responseText);
      }
      else receiver.update(responseText);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
  initialize: function($super, container, url, options) {
    $super(options);
    this.onComplete = this.options.onComplete;

    this.frequency = (this.options.frequency || 2);
    this.decay = (this.options.decay || 1);

    this.updater = { };
    this.container = container;
    this.url = url;

    this.start();
  },

  start: function() {
    this.options.onComplete = this.updateComplete.bind(this);
    this.onTimerEvent();
  },

  stop: function() {
    this.updater.options.onComplete = undefined;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
  },

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

      this.lastText = response.responseText;
    }
    this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
  },

  onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});



function $(element) {
  if (arguments.length > 1) {
    for (var i = 0, elements = [], length = arguments.length; i < length; i++)
      elements.push($(arguments[i]));
    return elements;
  }
  if (Object.isString(element))
    element = document.getElementById(element);
  return Element.extend(element);
}

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

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

if (!window.Node) var Node = { };

if (!Node.ELEMENT_NODE) {
  Object.extend(Node, {
    ELEMENT_NODE: 1,
    ATTRIBUTE_NODE: 2,
    TEXT_NODE: 3,
    CDATA_SECTION_NODE: 4,
    ENTITY_REFERENCE_NODE: 5,
    ENTITY_NODE: 6,
    PROCESSING_INSTRUCTION_NODE: 7,
    COMMENT_NODE: 8,
    DOCUMENT_NODE: 9,
    DOCUMENT_TYPE_NODE: 10,
    DOCUMENT_FRAGMENT_NODE: 11,
    NOTATION_NODE: 12
  });
}


(function(global) {

  var SETATTRIBUTE_IGNORES_NAME = (function(){
    var elForm = document.createElement("form");
    var elInput = document.createElement("input");
    var root = document.documentElement;
    elInput.setAttribute("name", "test");
    elForm.appendChild(elInput);
    root.appendChild(elForm);
    var isBuggy = elForm.elements
      ? (typeof elForm.elements.test == "undefined")
      : null;
    root.removeChild(elForm);
    elForm = elInput = null;
    return isBuggy;
  })();

  var element = global.Element;
  global.Element = function(tagName, attributes) {
    attributes = attributes || { };
    tagName = tagName.toLowerCase();
    var cache = Element.cache;
    if (SETATTRIBUTE_IGNORES_NAME && attributes.name) {
      tagName = '<' + tagName + ' name="' + attributes.name + '">';
      delete attributes.name;
      return Element.writeAttribute(document.createElement(tagName), attributes);
    }
    if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
    return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
  };
  Object.extend(global.Element, element || { });
  if (element) global.Element.prototype = element.prototype;
})(this);

Element.cache = { };
Element.idCounter = 1;

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

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


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

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

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

  update: (function(){

    var SELECT_ELEMENT_INNERHTML_BUGGY = (function(){
      var el = document.createElement("select"),
          isBuggy = true;
      el.innerHTML = "<option value=\"test\">test</option>";
      if (el.options && el.options[0]) {
        isBuggy = el.options[0].nodeName.toUpperCase() !== "OPTION";
      }
      el = null;
      return isBuggy;
    })();

    var TABLE_ELEMENT_INNERHTML_BUGGY = (function(){
      try {
        var el = document.createElement("table");
        if (el && el.tBodies) {
          el.innerHTML = "<tbody><tr><td>test</td></tr></tbody>";
          var isBuggy = typeof el.tBodies[0] == "undefined";
          el = null;
          return isBuggy;
        }
      } catch (e) {
        return true;
      }
    })();

    var SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING = (function () {
      var s = document.createElement("script"),
          isBuggy = false;
      try {
        s.appendChild(document.createTextNode(""));
        isBuggy = !s.firstChild ||
          s.firstChild && s.firstChild.nodeType !== 3;
      } catch (e) {
        isBuggy = true;
      }
      s = null;
      return isBuggy;
    })();

    function update(element, content) {
      element = $(element);

      if (content && content.toElement)
        content = content.toElement();

      if (Object.isElement(content))
        return element.update().insert(content);

      content = Object.toHTML(content);

      var tagName = element.tagName.toUpperCase();

      if (tagName === 'SCRIPT' && SCRIPT_ELEMENT_REJECTS_TEXTNODE_APPENDING) {
        element.text = content;
        return element;
      }

      if (SELECT_ELEMENT_INNERHTML_BUGGY || TABLE_ELEMENT_INNERHTML_BUGGY) {
        if (tagName in Element._insertionTranslations.tags) {
          while (element.firstChild) {
            element.removeChild(element.firstChild);
          }
          Element._getContentFromAnonymousElement(tagName, content.stripScripts())
            .each(function(node) {
              element.appendChild(node)
            });
        }
        else {
          element.innerHTML = content.stripScripts();
        }
      }
      else {
        element.innerHTML = content.stripScripts();
      }

      content.evalScripts.bind(content).defer();
      return element;
    }

    return update;
  })(),

  replace: function(element, content) {
    element = $(element);
    if (content && content.toElement) content = content.toElement();
    else if (!Object.isElement(content)) {
      content = Object.toHTML(content);
      var range = element.ownerDocument.createRange();
      range.selectNode(element);
      content.evalScripts.bind(content).defer();
      content = range.createContextualFragment(content.stripScripts());
    }
    element.parentNode.replaceChild(content, element);
    return element;
  },

  insert: function(element, insertions) {
    element = $(element);

    if (Object.isString(insertions) || Object.isNumber(insertions) ||
        Object.isElement(insertions) || (insertions && (insertions.toElement || insertions.toHTML)))
          insertions = {bottom:insertions};

    var content, insert, tagName, childNodes;

    for (var position in insertions) {
      content  = insertions[position];
      position = position.toLowerCase();
      insert = Element._insertionTranslations[position];

      if (content && content.toElement) content = content.toElement();
      if (Object.isElement(content)) {
        insert(element, content);
        continue;
      }

      content = Object.toHTML(content);

      tagName = ((position == 'before' || position == 'after')
        ? element.parentNode : element).tagName.toUpperCase();

      childNodes = Element._getContentFromAnonymousElement(tagName, content.stripScripts());

      if (position == 'top' || position == 'after') childNodes.reverse();
      childNodes.each(insert.curry(element));

      content.evalScripts.bind(content).defer();
    }

    return element;
  },

  wrap: function(element, wrapper, attributes) {
    element = $(element);
    if (Object.isElement(wrapper))
      $(wrapper).writeAttribute(attributes || { });
    else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
    else wrapper = new Element('div', wrapper);
    if (element.parentNode)
      element.parentNode.replaceChild(wrapper, element);
    wrapper.appendChild(element);
    return wrapper;
  },

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

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

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

  descendants: function(element) {
    return Element.select(element, "*");
  },

  firstDescendant: function(element) {
    element = $(element).firstChild;
    while (element && element.nodeType != 1) element = element.nextSibling;
    return $(element);
  },

  immediateDescendants: function(element) {
    if (!(element = $(element).firstChild)) return [];
    while (element && element.nodeType != 1) element = element.nextSibling;
    if (element) return [element].concat($(element).nextSiblings());
    return [];
  },

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

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

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

  match: function(element, selector) {
    if (Object.isString(selector))
      selector = new Selector(selector);
    return selector.match($(element));
  },

  up: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(element.parentNode);
    var ancestors = Element.ancestors(element);
    return Object.isNumber(expression) ? ancestors[expression] :
      Selector.findElement(ancestors, expression, index);
  },

  down: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return Element.firstDescendant(element);
    return Object.isNumber(expression) ? Element.descendants(element)[expression] :
      Element.select(element, expression)[index || 0];
  },

  previous: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(Selector.handlers.previousElementSibling(element));
    var previousSiblings = Element.previousSiblings(element);
    return Object.isNumber(expression) ? previousSiblings[expression] :
      Selector.findElement(previousSiblings, expression, index);
  },

  next: function(element, expression, index) {
    element = $(element);
    if (arguments.length == 1) return $(Selector.handlers.nextElementSibling(element));
    var nextSiblings = Element.nextSiblings(element);
    return Object.isNumber(expression) ? nextSiblings[expression] :
      Selector.findElement(nextSiblings, expression, index);
  },


  select: function(element) {
    var args = Array.prototype.slice.call(arguments, 1);
    return Selector.findChildElements(element, args);
  },

  adjacent: function(element) {
    var args = Array.prototype.slice.call(arguments, 1);
    return Selector.findChildElements(element.parentNode, args).without(element);
  },

  identify: function(element) {
    element = $(element);
    var id = Element.readAttribute(element, 'id');
    if (id) return id;
    do { id = 'anonymous_element_' + Element.idCounter++ } while ($(id));
    Element.writeAttribute(element, 'id', id);
    return id;
  },

  readAttribute: function(element, name) {
    element = $(element);
    if (Prototype.Browser.IE) {
      var t = Element._attributeTranslations.read;
      if (t.values[name]) return t.values[name](element, name);
      if (t.names[name]) name = t.names[name];
      if (name.include(':')) {
        return (!element.attributes || !element.attributes[name]) ? null :
         element.attributes[name].value;
      }
    }
    return element.getAttribute(name);
  },

  writeAttribute: function(element, name, value) {
    element = $(element);
    var attributes = { }, t = Element._attributeTranslations.write;

    if (typeof name == 'object') attributes = name;
    else attributes[name] = Object.isUndefined(value) ? true : value;

    for (var attr in attributes) {
      name = t.names[attr] || attr;
      value = attributes[attr];
      if (t.values[attr]) name = t.values[attr](element, value);
      if (value === false || value === null)
        element.removeAttribute(name);
      else if (value === true)
        element.setAttribute(name, name);
      else element.setAttribute(name, value);
    }
    return element;
  },

  getHeight: function(element) {
    return Element.getDimensions(element).height;
  },

  getWidth: function(element) {
    return Element.getDimensions(element).width;
  },

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

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

  addClassName: function(element, className) {
    if (!(element = $(element))) return;
    if (!Element.hasClassName(element, className))
      element.className += (element.className ? ' ' : '') + className;
    return element;
  },

  removeClassName: function(element, className) {
    if (!(element = $(element))) return;
    element.className = element.className.replace(
      new RegExp("(^|\\s+)" + className + "(\\s+|$)"), ' ').strip();
    return element;
  },

  toggleClassName: function(element, className) {
    if (!(element = $(element))) return;
    return Element[Element.hasClassName(element, className) ?
      'removeClassName' : 'addClassName'](element, className);
  },

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

  empty: function(element) {
    return $(element).innerHTML.blank();
  },

  descendantOf: function(element, ancestor) {
    element = $(element), ancestor = $(ancestor);

    if (element.compareDocumentPosition)
      return (element.compareDocumentPosition(ancestor) & 8) === 8;

    if (ancestor.contains)
      return ancestor.contains(element) && ancestor !== element;

    while (element = element.parentNode)
      if (element == ancestor) return true;

    return false;
  },

  scrollTo: function(element) {
    element = $(element);
    var pos = Element.cumulativeOffset(element);
    window.scrollTo(pos[0], pos[1]);
    return element;
  },

  getStyle: function(element, style) {
    element = $(element);
    style = style == 'float' ? 'cssFloat' : style.camelize();
    var value = element.style[style];
    if (!value || value == 'auto') {
      var css = document.defaultView.getComputedStyle(element, null);
      value = css ? css[style] : null;
    }
    if (style == 'opacity') return value ? parseFloat(value) : 1.0;
    return value == 'auto' ? null : value;
  },

  getOpacity: function(element) {
    return $(element).getStyle('opacity');
  },

  setStyle: function(element, styles) {
    element = $(element);
    var elementStyle = element.style, match;
    if (Object.isString(styles)) {
      element.style.cssText += ';' + styles;
      return styles.include('opacity') ?
        element.setOpacity(styles.match(/opacity:\s*(\d?\.?\d*)/)[1]) : element;
    }
    for (var property in styles)
      if (property == 'opacity') element.setOpacity(styles[property]);
      else
        elementStyle[(property == 'float' || property == 'cssFloat') ?
          (Object.isUndefined(elementStyle.styleFloat) ? 'cssFloat' : 'styleFloat') :
            property] = styles[property];

    return element;
  },

  setOpacity: function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : value;
    return element;
  },

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

    var els = element.style;
    var originalVisibility = els.visibility;
    var originalPosition = els.position;
    var originalDisplay = els.display;
    els.visibility = 'hidden';
    if (originalPosition != 'fixed') // Switching fixed to absolute causes issues in Safari
      els.position = 'absolute';
    els.display = 'block';
    var originalWidth = element.clientWidth;
    var originalHeight = element.clientHeight;
    els.display = originalDisplay;
    els.position = originalPosition;
    els.visibility = originalVisibility;
    return {width: originalWidth, height: originalHeight};
  },

  makePositioned: function(element) {
    element = $(element);
    var pos = Element.getStyle(element, 'position');
    if (pos == 'static' || !pos) {
      element._madePositioned = true;
      element.style.position = 'relative';
      if (Prototype.Browser.Opera) {
        element.style.top = 0;
        element.style.left = 0;
      }
    }
    return element;
  },

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

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

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

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

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

  absolutize: function(element) {
    element = $(element);
    if (Element.getStyle(element, 'position') == 'absolute') return element;

    var offsets = Element.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';
    return element;
  },

  relativize: function(element) {
    element = $(element);
    if (Element.getStyle(element, 'position') == 'relative') return element;

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

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

  cumulativeScrollOffset: function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.scrollTop  || 0;
      valueL += element.scrollLeft || 0;
      element = element.parentNode;
    } while (element);
    return Element._returnOffset(valueL, valueT);
  },

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

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

    return $(document.body);
  },

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

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

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

    } while (element = element.offsetParent);

    element = forElement;
    do {
      if (!Prototype.Browser.Opera || (element.tagName && (element.tagName.toUpperCase() == 'BODY'))) {
        valueT -= element.scrollTop  || 0;
        valueL -= element.scrollLeft || 0;
      }
    } while (element = element.parentNode);

    return Element._returnOffset(valueL, valueT);
  },

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

    source = $(source);
    var p = Element.viewportOffset(source);

    element = $(element);
    var delta = [0, 0];
    var parent = null;
    if (Element.getStyle(element, 'position') == 'absolute') {
      parent = Element.getOffsetParent(element);
      delta = Element.viewportOffset(parent);
    }

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

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

Object.extend(Element.Methods, {
  getElementsBySelector: Element.Methods.select,

  childElements: Element.Methods.immediateDescendants
});

Element._attributeTranslations = {
  write: {
    names: {
      className: 'class',
      htmlFor:   'for'
    },
    values: { }
  }
};

if (Prototype.Browser.Opera) {
  Element.Methods.getStyle = Element.Methods.getStyle.wrap(
    function(proceed, element, style) {
      switch (style) {
        case 'left': case 'top': case 'right': case 'bottom':
          if (proceed(element, 'position') === 'static') return null;
        case 'height': case 'width':
          if (!Element.visible(element)) return null;

          var dim = parseInt(proceed(element, style), 10);

          if (dim !== element['offset' + style.capitalize()])
            return dim + 'px';

          var properties;
          if (style === 'height') {
            properties = ['border-top-width', 'padding-top',
             'padding-bottom', 'border-bottom-width'];
          }
          else {
            properties = ['border-left-width', 'padding-left',
             'padding-right', 'border-right-width'];
          }
          return properties.inject(dim, function(memo, property) {
            var val = proceed(element, property);
            return val === null ? memo : memo - parseInt(val, 10);
          }) + 'px';
        default: return proceed(element, style);
      }
    }
  );

  Element.Methods.readAttribute = Element.Methods.readAttribute.wrap(
    function(proceed, element, attribute) {
      if (attribute === 'title') return element.title;
      return proceed(element, attribute);
    }
  );
}

else if (Prototype.Browser.IE) {
  Element.Methods.getOffsetParent = Element.Methods.getOffsetParent.wrap(
    function(proceed, element) {
      element = $(element);
      try { element.offsetParent }
      catch(e) { return $(document.body) }
      var position = element.getStyle('position');
      if (position !== 'static') return proceed(element);
      element.setStyle({ position: 'relative' });
      var value = proceed(element);
      element.setStyle({ position: position });
      return value;
    }
  );

  $w('positionedOffset viewportOffset').each(function(method) {
    Element.Methods[method] = Element.Methods[method].wrap(
      function(proceed, element) {
        element = $(element);
        try { element.offsetParent }
        catch(e) { return Element._returnOffset(0,0) }
        var position = element.getStyle('position');
        if (position !== 'static') return proceed(element);
        var offsetParent = element.getOffsetParent();
        if (offsetParent && offsetParent.getStyle('position') === 'fixed')
          offsetParent.setStyle({ zoom: 1 });
        element.setStyle({ position: 'relative' });
        var value = proceed(element);
        element.setStyle({ position: position });
        return value;
      }
    );
  });

  Element.Methods.cumulativeOffset = Element.Methods.cumulativeOffset.wrap(
    function(proceed, element) {
      try { element.offsetParent }
      catch(e) { return Element._returnOffset(0,0) }
      return proceed(element);
    }
  );

  Element.Methods.getStyle = function(element, style) {
    element = $(element);
    style = (style == 'float' || style == 'cssFloat') ? 'styleFloat' : style.camelize();
    var value = element.style[style];
    if (!value && element.currentStyle) value = element.currentStyle[style];

    if (style == 'opacity') {
      if (value = (element.getStyle('filter') || '').match(/alpha\(opacity=(.*)\)/))
        if (value[1]) return parseFloat(value[1]) / 100;
      return 1.0;
    }

    if (value == 'auto') {
      if ((style == 'width' || style == 'height') && (element.getStyle('display') != 'none'))
        return element['offset' + style.capitalize()] + 'px';
      return null;
    }
    return value;
  };

  Element.Methods.setOpacity = function(element, value) {
    function stripAlpha(filter){
      return filter.replace(/alpha\([^\)]*\)/gi,'');
    }
    element = $(element);
    var currentStyle = element.currentStyle;
    if ((currentStyle && !currentStyle.hasLayout) ||
      (!currentStyle && element.style.zoom == 'normal'))
        element.style.zoom = 1;

    var filter = element.getStyle('filter'), style = element.style;
    if (value == 1 || value === '') {
      (filter = stripAlpha(filter)) ?
        style.filter = filter : style.removeAttribute('filter');
      return element;
    } else if (value < 0.00001) value = 0;
    style.filter = stripAlpha(filter) +
      'alpha(opacity=' + (value * 100) + ')';
    return element;
  };

  Element._attributeTranslations = (function(){

    var classProp = 'className';
    var forProp = 'for';

    var el = document.createElement('div');

    el.setAttribute(classProp, 'x');

    if (el.className !== 'x') {
      el.setAttribute('class', 'x');
      if (el.className === 'x') {
        classProp = 'class';
      }
    }
    el = null;

    el = document.createElement('label');
    el.setAttribute(forProp, 'x');
    if (el.htmlFor !== 'x') {
      el.setAttribute('htmlFor', 'x');
      if (el.htmlFor === 'x') {
        forProp = 'htmlFor';
      }
    }
    el = null;

    return {
      read: {
        names: {
          'class':      classProp,
          'className':  classProp,
          'for':        forProp,
          'htmlFor':    forProp
        },
        values: {
          _getAttr: function(element, attribute) {
            return element.getAttribute(attribute);
          },
          _getAttr2: function(element, attribute) {
            return element.getAttribute(attribute, 2);
          },
          _getAttrNode: function(element, attribute) {
            var node = element.getAttributeNode(attribute);
            return node ? node.value : "";
          },
          _getEv: (function(){

            var el = document.createElement('div');
            el.onclick = Prototype.emptyFunction;
            var value = el.getAttribute('onclick');
            var f;

            if (String(value).indexOf('{') > -1) {
              f = function(element, attribute) {
                attribute = element.getAttribute(attribute);
                if (!attribute) return null;
                attribute = attribute.toString();
                attribute = attribute.split('{')[1];
                attribute = attribute.split('}')[0];
                return attribute.strip();
              };
            }
            else if (value === '') {
              f = function(element, attribute) {
                attribute = element.getAttribute(attribute);
                if (!attribute) return null;
                return attribute.strip();
              };
            }
            el = null;
            return f;
          })(),
          _flag: function(element, attribute) {
            return $(element).hasAttribute(attribute) ? attribute : null;
          },
          style: function(element) {
            return element.style.cssText.toLowerCase();
          },
          title: function(element) {
            return element.title;
          }
        }
      }
    }
  })();

  Element._attributeTranslations.write = {
    names: Object.extend({
      cellpadding: 'cellPadding',
      cellspacing: 'cellSpacing'
    }, Element._attributeTranslations.read.names),
    values: {
      checked: function(element, value) {
        element.checked = !!value;
      },

      style: function(element, value) {
        element.style.cssText = value ? value : '';
      }
    }
  };

  Element._attributeTranslations.has = {};

  $w('colSpan rowSpan vAlign dateTime accessKey tabIndex ' +
      'encType maxLength readOnly longDesc frameBorder').each(function(attr) {
    Element._attributeTranslations.write.names[attr.toLowerCase()] = attr;
    Element._attributeTranslations.has[attr.toLowerCase()] = attr;
  });

  (function(v) {
    Object.extend(v, {
      href:        v._getAttr2,
      src:         v._getAttr2,
      type:        v._getAttr,
      action:      v._getAttrNode,
      disabled:    v._flag,
      checked:     v._flag,
      readonly:    v._flag,
      multiple:    v._flag,
      onload:      v._getEv,
      onunload:    v._getEv,
      onclick:     v._getEv,
      ondblclick:  v._getEv,
      onmousedown: v._getEv,
      onmouseup:   v._getEv,
      onmouseover: v._getEv,
      onmousemove: v._getEv,
      onmouseout:  v._getEv,
      onfocus:     v._getEv,
      onblur:      v._getEv,
      onkeypress:  v._getEv,
      onkeydown:   v._getEv,
      onkeyup:     v._getEv,
      onsubmit:    v._getEv,
      onreset:     v._getEv,
      onselect:    v._getEv,
      onchange:    v._getEv
    });
  })(Element._attributeTranslations.read.values);

  if (Prototype.BrowserFeatures.ElementExtensions) {
    (function() {
      function _descendants(element) {
        var nodes = element.getElementsByTagName('*'), results = [];
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.tagName !== "!") // Filter out comment nodes.
            results.push(node);
        return results;
      }

      Element.Methods.down = function(element, expression, index) {
        element = $(element);
        if (arguments.length == 1) return element.firstDescendant();
        return Object.isNumber(expression) ? _descendants(element)[expression] :
          Element.select(element, expression)[index || 0];
      }
    })();
  }

}

else if (Prototype.Browser.Gecko && /rv:1\.8\.0/.test(navigator.userAgent)) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1) ? 0.999999 :
      (value === '') ? '' : (value < 0.00001) ? 0 : value;
    return element;
  };
}

else if (Prototype.Browser.WebKit) {
  Element.Methods.setOpacity = function(element, value) {
    element = $(element);
    element.style.opacity = (value == 1 || value === '') ? '' :
      (value < 0.00001) ? 0 : value;

    if (value == 1)
      if(element.tagName.toUpperCase() == 'IMG' && element.width) {
        element.width++; element.width--;
      } else try {
        var n = document.createTextNode(' ');
        element.appendChild(n);
        element.removeChild(n);
      } catch (e) { }

    return element;
  };

  Element.Methods.cumulativeOffset = function(element) {
    var valueT = 0, valueL = 0;
    do {
      valueT += element.offsetTop  || 0;
      valueL += element.offsetLeft || 0;
      if (element.offsetParent == document.body)
        if (Element.getStyle(element, 'position') == 'absolute') break;

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

    return Element._returnOffset(valueL, valueT);
  };
}

if ('outerHTML' in document.documentElement) {
  Element.Methods.replace = function(element, content) {
    element = $(element);

    if (content && content.toElement) content = content.toElement();
    if (Object.isElement(content)) {
      element.parentNode.replaceChild(content, element);
      return element;
    }

    content = Object.toHTML(content);
    var parent = element.parentNode, tagName = parent.tagName.toUpperCase();

    if (Element._insertionTranslations.tags[tagName]) {
      var nextSibling = element.next();
      var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
      parent.removeChild(element);
      if (nextSibling)
        fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
      else
        fragments.each(function(node) { parent.appendChild(node) });
    }
    else element.outerHTML = content.stripScripts();

    content.evalScripts.bind(content).defer();
    return element;
  };
}

Element._returnOffset = function(l, t) {
  var result = [l, t];
  result.left = l;
  result.top = t;
  return result;
};

Element._getContentFromAnonymousElement = function(tagName, html) {
  var div = new Element('div'), t = Element._insertionTranslations.tags[tagName];
  if (t) {
    div.innerHTML = t[0] + html + t[1];
    t[2].times(function() { div = div.firstChild });
  } else div.innerHTML = html;
  return $A(div.childNodes);
};

Element._insertionTranslations = {
  before: function(element, node) {
    element.parentNode.insertBefore(node, element);
  },
  top: function(element, node) {
    element.insertBefore(node, element.firstChild);
  },
  bottom: function(element, node) {
    element.appendChild(node);
  },
  after: function(element, node) {
    element.parentNode.insertBefore(node, element.nextSibling);
  },
  tags: {
    TABLE:  ['<table>',                '</table>',                   1],
    TBODY:  ['<table><tbody>',         '</tbody></table>',           2],
    TR:     ['<table><tbody><tr>',     '</tr></tbody></table>',      3],
    TD:     ['<table><tbody><tr><td>', '</td></tr></tbody></table>', 4],
    SELECT: ['<select>',               '</select>',                  1]
  }
};

(function() {
  var tags = Element._insertionTranslations.tags;
  Object.extend(tags, {
    THEAD: tags.TBODY,
    TFOOT: tags.TBODY,
    TH:    tags.TD
  });
})();

Element.Methods.Simulated = {
  hasAttribute: function(element, attribute) {
    attribute = Element._attributeTranslations.has[attribute] || attribute;
    var node = $(element).getAttributeNode(attribute);
    return !!(node && node.specified);
  }
};

Element.Methods.ByTag = { };

Object.extend(Element, Element.Methods);

(function(div) {

  if (!Prototype.BrowserFeatures.ElementExtensions && div['__proto__']) {
    window.HTMLElement = { };
    window.HTMLElement.prototype = div['__proto__'];
    Prototype.BrowserFeatures.ElementExtensions = true;
  }

  div = null;

})(document.createElement('div'))

Element.extend = (function() {

  function checkDeficiency(tagName) {
    if (typeof window.Element != 'undefined') {
      var proto = window.Element.prototype;
      if (proto) {
        var id = '_' + (Math.random()+'').slice(2);
        var el = document.createElement(tagName);
        proto[id] = 'x';
        var isBuggy = (el[id] !== 'x');
        delete proto[id];
        el = null;
        return isBuggy;
      }
    }
    return false;
  }

  function extendElementWith(element, methods) {
    for (var property in methods) {
      var value = methods[property];
      if (Object.isFunction(value) && !(property in element))
        element[property] = value.methodize();
    }
  }

  var HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency('object');

  if (Prototype.BrowserFeatures.SpecificElementExtensions) {
    if (HTMLOBJECTELEMENT_PROTOTYPE_BUGGY) {
      return function(element) {
        if (element && typeof element._extendedByPrototype == 'undefined') {
          var t = element.tagName;
          if (t && (/^(?:object|applet|embed)$/i.test(t))) {
            extendElementWith(element, Element.Methods);
            extendElementWith(element, Element.Methods.Simulated);
            extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
          }
        }
        return element;
      }
    }
    return Prototype.K;
  }

  var Methods = { }, ByTag = Element.Methods.ByTag;

  var extend = Object.extend(function(element) {
    if (!element || typeof element._extendedByPrototype != 'undefined' ||
        element.nodeType != 1 || element == window) return element;

    var methods = Object.clone(Methods),
        tagName = element.tagName.toUpperCase();

    if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);

    extendElementWith(element, methods);

    element._extendedByPrototype = Prototype.emptyFunction;
    return element;

  }, {
    refresh: function() {
      if (!Prototype.BrowserFeatures.ElementExtensions) {
        Object.extend(Methods, Element.Methods);
        Object.extend(Methods, Element.Methods.Simulated);
      }
    }
  });

  extend.refresh();
  return extend;
})();

Element.hasAttribute = function(element, attribute) {
  if (element.hasAttribute) return element.hasAttribute(attribute);
  return Element.Methods.Simulated.hasAttribute(element, attribute);
};

Element.addMethods = function(methods) {
  var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;

  if (!methods) {
    Object.extend(Form, Form.Methods);
    Object.extend(Form.Element, Form.Element.Methods);
    Object.extend(Element.Methods.ByTag, {
      "FORM":     Object.clone(Form.Methods),
      "INPUT":    Object.clone(Form.Element.Methods),
      "SELECT":   Object.clone(Form.Element.Methods),
      "TEXTAREA": Object.clone(Form.Element.Methods)
    });
  }

  if (arguments.length == 2) {
    var tagName = methods;
    methods = arguments[1];
  }

  if (!tagName) Object.extend(Element.Methods, methods || { });
  else {
    if (Object.isArray(tagName)) tagName.each(extend);
    else extend(tagName);
  }

  function extend(tagName) {
    tagName = tagName.toUpperCase();
    if (!Element.Methods.ByTag[tagName])
      Element.Methods.ByTag[tagName] = { };
    Object.extend(Element.Methods.ByTag[tagName], methods);
  }

  function copy(methods, destination, onlyIfAbsent) {
    onlyIfAbsent = onlyIfAbsent || false;
    for (var property in methods) {
      var value = methods[property];
      if (!Object.isFunction(value)) continue;
      if (!onlyIfAbsent || !(property in destination))
        destination[property] = value.methodize();
    }
  }

  function findDOMClass(tagName) {
    var klass;
    var trans = {
      "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
      "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
      "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
      "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
      "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
      "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
      "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
      "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
      "FrameSet", "IFRAME": "IFrame"
    };
    if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
    if (window[klass]) return window[klass];
    klass = 'HTML' + tagName + 'Element';
    if (window[klass]) return window[klass];
    klass = 'HTML' + tagName.capitalize() + 'Element';
    if (window[klass]) return window[klass];

    var element = document.createElement(tagName);
    var proto = element['__proto__'] || element.constructor.prototype;
    element = null;
    return proto;
  }

  var elementPrototype = window.HTMLElement ? HTMLElement.prototype :
   Element.prototype;

  if (F.ElementExtensions) {
    copy(Element.Methods, elementPrototype);
    copy(Element.Methods.Simulated, elementPrototype, true);
  }

  if (F.SpecificElementExtensions) {
    for (var tag in Element.Methods.ByTag) {
      var klass = findDOMClass(tag);
      if (Object.isUndefined(klass)) continue;
      copy(T[tag], klass.prototype);
    }
  }

  Object.extend(Element, Element.Methods);
  delete Element.ByTag;

  if (Element.extend.refresh) Element.extend.refresh();
  Element.cache = { };
};


document.viewport = {

  getDimensions: function() {
    return { width: this.getWidth(), height: this.getHeight() };
  },

  getScrollOffsets: function() {
    return Element._returnOffset(
      window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
      window.pageYOffset || document.documentElement.scrollTop  || document.body.scrollTop);
  }
};

(function(viewport) {
  var B = Prototype.Browser, doc = document, element, property = {};

  function getRootElement() {
    if (B.WebKit && !doc.evaluate)
      return document;

    if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
      return document.body;

    return document.documentElement;
  }

  function define(D) {
    if (!element) element = getRootElement();

    property[D] = 'client' + D;

    viewport['get' + D] = function() { return element[property[D]] };
    return viewport['get' + D]();
  }

  viewport.getWidth  = define.curry('Width');

  viewport.getHeight = define.curry('Height');
})(document.viewport);


Element.Storage = {
  UID: 1
};

Element.addMethods({
  getStorage: function(element) {
    if (!(element = $(element))) return;

    var uid;
    if (element === window) {
      uid = 0;
    } else {
      if (typeof element._prototypeUID === "undefined")
        element._prototypeUID = [Element.Storage.UID++];
      uid = element._prototypeUID[0];
    }

    if (!Element.Storage[uid])
      Element.Storage[uid] = $H();

    return Element.Storage[uid];
  },

  store: function(element, key, value) {
    if (!(element = $(element))) return;

    if (arguments.length === 2) {
      Element.getStorage(element).update(key);
    } else {
      Element.getStorage(element).set(key, value);
    }

    return element;
  },

  retrieve: function(element, key, defaultValue) {
    if (!(element = $(element))) return;
    var hash = Element.getStorage(element), value = hash.get(key);

    if (Object.isUndefined(value)) {
      hash.set(key, defaultValue);
      value = defaultValue;
    }

    return value;
  },

  clone: function(element, deep) {
    if (!(element = $(element))) return;
    var clone = element.cloneNode(deep);
    clone._prototypeUID = void 0;
    if (deep) {
      var descendants = Element.select(clone, '*'),
          i = descendants.length;
      while (i--) {
        descendants[i]._prototypeUID = void 0;
      }
    }
    return Element.extend(clone);
  }
});
/* Portions of the Selector class are derived from Jack Slocum's DomQuery,
 * part of YUI-Ext version 0.40, distributed under the terms of an MIT-style
 * license.  Please see http://www.yui-ext.com/ for more information. */

var Selector = Class.create({
  initialize: function(expression) {
    this.expression = expression.strip();

    if (this.shouldUseSelectorsAPI()) {
      this.mode = 'selectorsAPI';
    } else if (this.shouldUseXPath()) {
      this.mode = 'xpath';
      this.compileXPathMatcher();
    } else {
      this.mode = "normal";
      this.compileMatcher();
    }

  },

  shouldUseXPath: (function() {

    var IS_DESCENDANT_SELECTOR_BUGGY = (function(){
      var isBuggy = false;
      if (document.evaluate && window.XPathResult) {
        var el = document.createElement('div');
        el.innerHTML = '<ul><li></li></ul><div><ul><li></li></ul></div>';

        var xpath = ".//*[local-name()='ul' or local-name()='UL']" +
          "//*[local-name()='li' or local-name()='LI']";

        var result = document.evaluate(xpath, el, null,
          XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);

        isBuggy = (result.snapshotLength !== 2);
        el = null;
      }
      return isBuggy;
    })();

    return function() {
      if (!Prototype.BrowserFeatures.XPath) return false;

      var e = this.expression;

      if (Prototype.Browser.WebKit &&
       (e.include("-of-type") || e.include(":empty")))
        return false;

      if ((/(\[[\w-]*?:|:checked)/).test(e))
        return false;

      if (IS_DESCENDANT_SELECTOR_BUGGY) return false;

      return true;
    }

  })(),

  shouldUseSelectorsAPI: function() {
    if (!Prototype.BrowserFeatures.SelectorsAPI) return false;

    if (Selector.CASE_INSENSITIVE_CLASS_NAMES) return false;

    if (!Selector._div) Selector._div = new Element('div');

    try {
      Selector._div.querySelector(this.expression);
    } catch(e) {
      return false;
    }

    return true;
  },

  compileMatcher: function() {
    var e = this.expression, ps = Selector.patterns, h = Selector.handlers,
        c = Selector.criteria, le, p, m, len = ps.length, name;

    if (Selector._cache[e]) {
      this.matcher = Selector._cache[e];
      return;
    }

    this.matcher = ["this.matcher = function(root) {",
                    "var r = root, h = Selector.handlers, c = false, n;"];

    while (e && le != e && (/\S/).test(e)) {
      le = e;
      for (var i = 0; i<len; i++) {
        p = ps[i].re;
        name = ps[i].name;
        if (m = e.match(p)) {
          this.matcher.push(Object.isFunction(c[name]) ? c[name](m) :
            new Template(c[name]).evaluate(m));
          e = e.replace(m[0], '');
          break;
        }
      }
    }

    this.matcher.push("return h.unique(n);\n}");
    eval(this.matcher.join('\n'));
    Selector._cache[this.expression] = this.matcher;
  },

  compileXPathMatcher: function() {
    var e = this.expression, ps = Selector.patterns,
        x = Selector.xpath, le, m, len = ps.length, name;

    if (Selector._cache[e]) {
      this.xpath = Selector._cache[e]; return;
    }

    this.matcher = ['.//*'];
    while (e && le != e && (/\S/).test(e)) {
      le = e;
      for (var i = 0; i<len; i++) {
        name = ps[i].name;
        if (m = e.match(ps[i].re)) {
          this.matcher.push(Object.isFunction(x[name]) ? x[name](m) :
            new Template(x[name]).evaluate(m));
          e = e.replace(m[0], '');
          break;
        }
      }
    }

    this.xpath = this.matcher.join('');
    Selector._cache[this.expression] = this.xpath;
  },

  findElements: function(root) {
    root = root || document;
    var e = this.expression, results;

    switch (this.mode) {
      case 'selectorsAPI':
        if (root !== document) {
          var oldId = root.id, id = $(root).identify();
          id = id.replace(/([\.:])/g, "\\$1");
          e = "#" + id + " " + e;
        }

        results = $A(root.querySelectorAll(e)).map(Element.extend);
        root.id = oldId;

        return results;
      case 'xpath':
        return document._getElementsByXPath(this.xpath, root);
      default:
       return this.matcher(root);
    }
  },

  match: function(element) {
    this.tokens = [];

    var e = this.expression, ps = Selector.patterns, as = Selector.assertions;
    var le, p, m, len = ps.length, name;

    while (e && le !== e && (/\S/).test(e)) {
      le = e;
      for (var i = 0; i<len; i++) {
        p = ps[i].re;
        name = ps[i].name;
        if (m = e.match(p)) {
          if (as[name]) {
            this.tokens.push([name, Object.clone(m)]);
            e = e.replace(m[0], '');
          } else {
            return this.findElements(document).include(element);
          }
        }
      }
    }

    var match = true, name, matches;
    for (var i = 0, token; token = this.tokens[i]; i++) {
      name = token[0], matches = token[1];
      if (!Selector.assertions[name](element, matches)) {
        match = false; break;
      }
    }

    return match;
  },

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

  inspect: function() {
    return "#<Selector:" + this.expression.inspect() + ">";
  }
});

if (Prototype.BrowserFeatures.SelectorsAPI &&
 document.compatMode === 'BackCompat') {
  Selector.CASE_INSENSITIVE_CLASS_NAMES = (function(){
    var div = document.createElement('div'),
     span = document.createElement('span');

    div.id = "prototype_test_id";
    span.className = 'Test';
    div.appendChild(span);
    var isIgnored = (div.querySelector('#prototype_test_id .test') !== null);
    div = span = null;
    return isIgnored;
  })();
}

Object.extend(Selector, {
  _cache: { },

  xpath: {
    descendant:   "//*",
    child:        "/*",
    adjacent:     "/following-sibling::*[1]",
    laterSibling: '/following-sibling::*',
    tagName:      function(m) {
      if (m[1] == '*') return '';
      return "[local-name()='" + m[1].toLowerCase() +
             "' or local-name()='" + m[1].toUpperCase() + "']";
    },
    className:    "[contains(concat(' ', @class, ' '), ' #{1} ')]",
    id:           "[@id='#{1}']",
    attrPresence: function(m) {
      m[1] = m[1].toLowerCase();
      return new Template("[@#{1}]").evaluate(m);
    },
    attr: function(m) {
      m[1] = m[1].toLowerCase();
      m[3] = m[5] || m[6];
      return new Template(Selector.xpath.operators[m[2]]).evaluate(m);
    },
    pseudo: function(m) {
      var h = Selector.xpath.pseudos[m[1]];
      if (!h) return '';
      if (Object.isFunction(h)) return h(m);
      return new Template(Selector.xpath.pseudos[m[1]]).evaluate(m);
    },
    operators: {
      '=':  "[@#{1}='#{3}']",
      '!=': "[@#{1}!='#{3}']",
      '^=': "[starts-with(@#{1}, '#{3}')]",
      '$=': "[substring(@#{1}, (string-length(@#{1}) - string-length('#{3}') + 1))='#{3}']",
      '*=': "[contains(@#{1}, '#{3}')]",
      '~=': "[contains(concat(' ', @#{1}, ' '), ' #{3} ')]",
      '|=': "[contains(concat('-', @#{1}, '-'), '-#{3}-')]"
    },
    pseudos: {
      'first-child': '[not(preceding-sibling::*)]',
      'last-child':  '[not(following-sibling::*)]',
      'only-child':  '[not(preceding-sibling::* or following-sibling::*)]',
      'empty':       "[count(*) = 0 and (count(text()) = 0)]",
      'checked':     "[@checked]",
      'disabled':    "[(@disabled) and (@type!='hidden')]",
      'enabled':     "[not(@disabled) and (@type!='hidden')]",
      'not': function(m) {
        var e = m[6], p = Selector.patterns,
            x = Selector.xpath, le, v, len = p.length, name;

        var exclusion = [];
        while (e && le != e && (/\S/).test(e)) {
          le = e;
          for (var i = 0; i<len; i++) {
            name = p[i].name
            if (m = e.match(p[i].re)) {
              v = Object.isFunction(x[name]) ? x[name](m) : new Template(x[name]).evaluate(m);
              exclusion.push("(" + v.substring(1, v.length - 1) + ")");
              e = e.replace(m[0], '');
              break;
            }
          }
        }
        return "[not(" + exclusion.join(" and ") + ")]";
      },
      'nth-child':      function(m) {
        return Selector.xpath.pseudos.nth("(count(./preceding-sibling::*) + 1) ", m);
      },
      'nth-last-child': function(m) {
        return Selector.xpath.pseudos.nth("(count(./following-sibling::*) + 1) ", m);
      },
      'nth-of-type':    function(m) {
        return Selector.xpath.pseudos.nth("position() ", m);
      },
      'nth-last-of-type': function(m) {
        return Selector.xpath.pseudos.nth("(last() + 1 - position()) ", m);
      },
      'first-of-type':  function(m) {
        m[6] = "1"; return Selector.xpath.pseudos['nth-of-type'](m);
      },
      'last-of-type':   function(m) {
        m[6] = "1"; return Selector.xpath.pseudos['nth-last-of-type'](m);
      },
      'only-of-type':   function(m) {
        var p = Selector.xpath.pseudos; return p['first-of-type'](m) + p['last-of-type'](m);
      },
      nth: function(fragment, m) {
        var mm, formula = m[6], predicate;
        if (formula == 'even') formula = '2n+0';
        if (formula == 'odd')  formula = '2n+1';
        if (mm = formula.match(/^(\d+)$/)) // digit only
          return '[' + fragment + "= " + mm[1] + ']';
        if (mm = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
          if (mm[1] == "-") mm[1] = -1;
          var a = mm[1] ? Number(mm[1]) : 1;
          var b = mm[2] ? Number(mm[2]) : 0;
          predicate = "[((#{fragment} - #{b}) mod #{a} = 0) and " +
          "((#{fragment} - #{b}) div #{a} >= 0)]";
          return new Template(predicate).evaluate({
            fragment: fragment, a: a, b: b });
        }
      }
    }
  },

  criteria: {
    tagName:      'n = h.tagName(n, r, "#{1}", c);      c = false;',
    className:    'n = h.className(n, r, "#{1}", c);    c = false;',
    id:           'n = h.id(n, r, "#{1}", c);           c = false;',
    attrPresence: 'n = h.attrPresence(n, r, "#{1}", c); c = false;',
    attr: function(m) {
      m[3] = (m[5] || m[6]);
      return new Template('n = h.attr(n, r, "#{1}", "#{3}", "#{2}", c); c = false;').evaluate(m);
    },
    pseudo: function(m) {
      if (m[6]) m[6] = m[6].replace(/"/g, '\\"');
      return new Template('n = h.pseudo(n, "#{1}", "#{6}", r, c); c = false;').evaluate(m);
    },
    descendant:   'c = "descendant";',
    child:        'c = "child";',
    adjacent:     'c = "adjacent";',
    laterSibling: 'c = "laterSibling";'
  },

  patterns: [
    { name: 'laterSibling', re: /^\s*~\s*/ },
    { name: 'child',        re: /^\s*>\s*/ },
    { name: 'adjacent',     re: /^\s*\+\s*/ },
    { name: 'descendant',   re: /^\s/ },

    { name: 'tagName',      re: /^\s*(\*|[\w\-]+)(\b|$)?/ },
    { name: 'id',           re: /^#([\w\-\*]+)(\b|$)/ },
    { name: 'className',    re: /^\.([\w\-\*]+)(\b|$)/ },
    { name: 'pseudo',       re: /^:((first|last|nth|nth-last|only)(-child|-of-type)|empty|checked|(en|dis)abled|not)(\((.*?)\))?(\b|$|(?=\s|[:+~>]))/ },
    { name: 'attrPresence', re: /^\[((?:[\w-]+:)?[\w-]+)\]/ },
    { name: 'attr',         re: /\[((?:[\w-]*:)?[\w-]+)\s*(?:([!^$*~|]?=)\s*((['"])([^\4]*?)\4|([^'"][^\]]*?)))?\]/ }
  ],

  assertions: {
    tagName: function(element, matches) {
      return matches[1].toUpperCase() == element.tagName.toUpperCase();
    },

    className: function(element, matches) {
      return Element.hasClassName(element, matches[1]);
    },

    id: function(element, matches) {
      return element.id === matches[1];
    },

    attrPresence: function(element, matches) {
      return Element.hasAttribute(element, matches[1]);
    },

    attr: function(element, matches) {
      var nodeValue = Element.readAttribute(element, matches[1]);
      return nodeValue && Selector.operators[matches[2]](nodeValue, matches[5] || matches[6]);
    }
  },

  handlers: {
    concat: function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        a.push(node);
      return a;
    },

    mark: function(nodes) {
      var _true = Prototype.emptyFunction;
      for (var i = 0, node; node = nodes[i]; i++)
        node._countedByPrototype = _true;
      return nodes;
    },

    unmark: (function(){

      var PROPERTIES_ATTRIBUTES_MAP = (function(){
        var el = document.createElement('div'),
            isBuggy = false,
            propName = '_countedByPrototype',
            value = 'x'
        el[propName] = value;
        isBuggy = (el.getAttribute(propName) === value);
        el = null;
        return isBuggy;
      })();

      return PROPERTIES_ATTRIBUTES_MAP ?
        function(nodes) {
          for (var i = 0, node; node = nodes[i]; i++)
            node.removeAttribute('_countedByPrototype');
          return nodes;
        } :
        function(nodes) {
          for (var i = 0, node; node = nodes[i]; i++)
            node._countedByPrototype = void 0;
          return nodes;
        }
    })(),

    index: function(parentNode, reverse, ofType) {
      parentNode._countedByPrototype = Prototype.emptyFunction;
      if (reverse) {
        for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
          var node = nodes[i];
          if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
        }
      } else {
        for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
          if (node.nodeType == 1 && (!ofType || node._countedByPrototype)) node.nodeIndex = j++;
      }
    },

    unique: function(nodes) {
      if (nodes.length == 0) return nodes;
      var results = [], n;
      for (var i = 0, l = nodes.length; i < l; i++)
        if (typeof (n = nodes[i])._countedByPrototype == 'undefined') {
          n._countedByPrototype = Prototype.emptyFunction;
          results.push(Element.extend(n));
        }
      return Selector.handlers.unmark(results);
    },

    descendant: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        h.concat(results, node.getElementsByTagName('*'));
      return results;
    },

    child: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        for (var j = 0, child; child = node.childNodes[j]; j++)
          if (child.nodeType == 1 && child.tagName != '!') results.push(child);
      }
      return results;
    },

    adjacent: function(nodes) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        var next = this.nextElementSibling(node);
        if (next) results.push(next);
      }
      return results;
    },

    laterSibling: function(nodes) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        h.concat(results, Element.nextSiblings(node));
      return results;
    },

    nextElementSibling: function(node) {
      while (node = node.nextSibling)
        if (node.nodeType == 1) return node;
      return null;
    },

    previousElementSibling: function(node) {
      while (node = node.previousSibling)
        if (node.nodeType == 1) return node;
      return null;
    },

    tagName: function(nodes, root, tagName, combinator) {
      var uTagName = tagName.toUpperCase();
      var results = [], h = Selector.handlers;
      if (nodes) {
        if (combinator) {
          if (combinator == "descendant") {
            for (var i = 0, node; node = nodes[i]; i++)
              h.concat(results, node.getElementsByTagName(tagName));
            return results;
          } else nodes = this[combinator](nodes);
          if (tagName == "*") return nodes;
        }
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.tagName.toUpperCase() === uTagName) results.push(node);
        return results;
      } else return root.getElementsByTagName(tagName);
    },

    id: function(nodes, root, id, combinator) {
      var targetNode = $(id), h = Selector.handlers;

      if (root == document) {
        if (!targetNode) return [];
        if (!nodes) return [targetNode];
      } else {
        if (!root.sourceIndex || root.sourceIndex < 1) {
          var nodes = root.getElementsByTagName('*');
          for (var j = 0, node; node = nodes[j]; j++) {
            if (node.id === id) return [node];
          }
        }
      }

      if (nodes) {
        if (combinator) {
          if (combinator == 'child') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (targetNode.parentNode == node) return [targetNode];
          } else if (combinator == 'descendant') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (Element.descendantOf(targetNode, node)) return [targetNode];
          } else if (combinator == 'adjacent') {
            for (var i = 0, node; node = nodes[i]; i++)
              if (Selector.handlers.previousElementSibling(targetNode) == node)
                return [targetNode];
          } else nodes = h[combinator](nodes);
        }
        for (var i = 0, node; node = nodes[i]; i++)
          if (node == targetNode) return [targetNode];
        return [];
      }
      return (targetNode && Element.descendantOf(targetNode, root)) ? [targetNode] : [];
    },

    className: function(nodes, root, className, combinator) {
      if (nodes && combinator) nodes = this[combinator](nodes);
      return Selector.handlers.byClassName(nodes, root, className);
    },

    byClassName: function(nodes, root, className) {
      if (!nodes) nodes = Selector.handlers.descendant([root]);
      var needle = ' ' + className + ' ';
      for (var i = 0, results = [], node, nodeClassName; node = nodes[i]; i++) {
        nodeClassName = node.className;
        if (nodeClassName.length == 0) continue;
        if (nodeClassName == className || (' ' + nodeClassName + ' ').include(needle))
          results.push(node);
      }
      return results;
    },

    attrPresence: function(nodes, root, attr, combinator) {
      if (!nodes) nodes = root.getElementsByTagName("*");
      if (nodes && combinator) nodes = this[combinator](nodes);
      var results = [];
      for (var i = 0, node; node = nodes[i]; i++)
        if (Element.hasAttribute(node, attr)) results.push(node);
      return results;
    },

    attr: function(nodes, root, attr, value, operator, combinator) {
      if (!nodes) nodes = root.getElementsByTagName("*");
      if (nodes && combinator) nodes = this[combinator](nodes);
      var handler = Selector.operators[operator], results = [];
      for (var i = 0, node; node = nodes[i]; i++) {
        var nodeValue = Element.readAttribute(node, attr);
        if (nodeValue === null) continue;
        if (handler(nodeValue, value)) results.push(node);
      }
      return results;
    },

    pseudo: function(nodes, name, value, root, combinator) {
      if (nodes && combinator) nodes = this[combinator](nodes);
      if (!nodes) nodes = root.getElementsByTagName("*");
      return Selector.pseudos[name](nodes, value, root);
    }
  },

  pseudos: {
    'first-child': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (Selector.handlers.previousElementSibling(node)) continue;
          results.push(node);
      }
      return results;
    },
    'last-child': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (Selector.handlers.nextElementSibling(node)) continue;
          results.push(node);
      }
      return results;
    },
    'only-child': function(nodes, value, root) {
      var h = Selector.handlers;
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!h.previousElementSibling(node) && !h.nextElementSibling(node))
          results.push(node);
      return results;
    },
    'nth-child':        function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root);
    },
    'nth-last-child':   function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, true);
    },
    'nth-of-type':      function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, false, true);
    },
    'nth-last-of-type': function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, formula, root, true, true);
    },
    'first-of-type':    function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, "1", root, false, true);
    },
    'last-of-type':     function(nodes, formula, root) {
      return Selector.pseudos.nth(nodes, "1", root, true, true);
    },
    'only-of-type':     function(nodes, formula, root) {
      var p = Selector.pseudos;
      return p['last-of-type'](p['first-of-type'](nodes, formula, root), formula, root);
    },

    getIndices: function(a, b, total) {
      if (a == 0) return b > 0 ? [b] : [];
      return $R(1, total).inject([], function(memo, i) {
        if (0 == (i - b) % a && (i - b) / a >= 0) memo.push(i);
        return memo;
      });
    },

    nth: function(nodes, formula, root, reverse, ofType) {
      if (nodes.length == 0) return [];
      if (formula == 'even') formula = '2n+0';
      if (formula == 'odd')  formula = '2n+1';
      var h = Selector.handlers, results = [], indexed = [], m;
      h.mark(nodes);
      for (var i = 0, node; node = nodes[i]; i++) {
        if (!node.parentNode._countedByPrototype) {
          h.index(node.parentNode, reverse, ofType);
          indexed.push(node.parentNode);
        }
      }
      if (formula.match(/^\d+$/)) { // just a number
        formula = Number(formula);
        for (var i = 0, node; node = nodes[i]; i++)
          if (node.nodeIndex == formula) results.push(node);
      } else if (m = formula.match(/^(-?\d*)?n(([+-])(\d+))?/)) { // an+b
        if (m[1] == "-") m[1] = -1;
        var a = m[1] ? Number(m[1]) : 1;
        var b = m[2] ? Number(m[2]) : 0;
        var indices = Selector.pseudos.getIndices(a, b, nodes.length);
        for (var i = 0, node, l = indices.length; node = nodes[i]; i++) {
          for (var j = 0; j < l; j++)
            if (node.nodeIndex == indices[j]) results.push(node);
        }
      }
      h.unmark(nodes);
      h.unmark(indexed);
      return results;
    },

    'empty': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++) {
        if (node.tagName == '!' || node.firstChild) continue;
        results.push(node);
      }
      return results;
    },

    'not': function(nodes, selector, root) {
      var h = Selector.handlers, selectorType, m;
      var exclusions = new Selector(selector).findElements(root);
      h.mark(exclusions);
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node._countedByPrototype) results.push(node);
      h.unmark(exclusions);
      return results;
    },

    'enabled': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (!node.disabled && (!node.type || node.type !== 'hidden'))
          results.push(node);
      return results;
    },

    'disabled': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (node.disabled) results.push(node);
      return results;
    },

    'checked': function(nodes, value, root) {
      for (var i = 0, results = [], node; node = nodes[i]; i++)
        if (node.checked) results.push(node);
      return results;
    }
  },

  operators: {
    '=':  function(nv, v) { return nv == v; },
    '!=': function(nv, v) { return nv != v; },
    '^=': function(nv, v) { return nv == v || nv && nv.startsWith(v); },
    '$=': function(nv, v) { return nv == v || nv && nv.endsWith(v); },
    '*=': function(nv, v) { return nv == v || nv && nv.include(v); },
    '~=': function(nv, v) { return (' ' + nv + ' ').include(' ' + v + ' '); },
    '|=': function(nv, v) { return ('-' + (nv || "").toUpperCase() +
     '-').include('-' + (v || "").toUpperCase() + '-'); }
  },

  split: function(expression) {
    var expressions = [];
    expression.scan(/(([\w#:.~>+()\s-]+|\*|\[.*?\])+)\s*(,|$)/, function(m) {
      expressions.push(m[1].strip());
    });
    return expressions;
  },

  matchElements: function(elements, expression) {
    var matches = $$(expression), h = Selector.handlers;
    h.mark(matches);
    for (var i = 0, results = [], element; element = elements[i]; i++)
      if (element._countedByPrototype) results.push(element);
    h.unmark(matches);
    return results;
  },

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

  findChildElements: function(element, expressions) {
    expressions = Selector.split(expressions.join(','));
    var results = [], h = Selector.handlers;
    for (var i = 0, l = expressions.length, selector; i < l; i++) {
      selector = new Selector(expressions[i].strip());
      h.concat(results, selector.findElements(element));
    }
    return (l > 1) ? h.unique(results) : results;
  }
});

if (Prototype.Browser.IE) {
  Object.extend(Selector.handlers, {
    concat: function(a, b) {
      for (var i = 0, node; node = b[i]; i++)
        if (node.tagName !== "!") a.push(node);
      return a;
    }
  });
}

function $$() {
  return Selector.findChildElements(document, $A(arguments));
}

var Form = {
  reset: function(form) {
    form = $(form);
    form.reset();
    return form;
  },

  serializeElements: function(elements, options) {
    if (typeof options != 'object') options = { hash: !!options };
    else if (Object.isUndefined(options.hash)) options.hash = true;
    var key, value, submitted = false, submit = options.submit;

    var data = elements.inject({ }, function(result, element) {
      if (!element.disabled && element.name) {
        key = element.name; value = $(element).getValue();
        if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
            submit !== false && (!submit || key == submit) && (submitted = true)))) {
          if (key in result) {
            if (!Object.isArray(result[key])) result[key] = [result[key]];
            result[key].push(value);
          }
          else result[key] = value;
        }
      }
      return result;
    });

    return options.hash ? data : Object.toQueryString(data);
  }
};

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

  getElements: function(form) {
    var elements = $(form).getElementsByTagName('*'),
        element,
        arr = [ ],
        serializers = Form.Element.Serializers;
    for (var i = 0; element = elements[i]; i++) {
      arr.push(element);
    }
    return arr.inject([], function(elements, child) {
      if (serializers[child.tagName.toLowerCase()])
        elements.push(Element.extend(child));
      return elements;
    })
  },

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

    if (!typeName && !name) return $A(inputs).map(Element.extend);

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

    return matchingInputs;
  },

  disable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('disable');
    return form;
  },

  enable: function(form) {
    form = $(form);
    Form.getElements(form).invoke('enable');
    return form;
  },

  findFirstElement: function(form) {
    var elements = $(form).getElements().findAll(function(element) {
      return 'hidden' != element.type && !element.disabled;
    });
    var firstByIndex = elements.findAll(function(element) {
      return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
    }).sortBy(function(element) { return element.tabIndex }).first();

    return firstByIndex ? firstByIndex : elements.find(function(element) {
      return /^(?:input|select|textarea)$/i.test(element.tagName);
    });
  },

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

  request: function(form, options) {
    form = $(form), options = Object.clone(options || { });

    var params = options.parameters, action = form.readAttribute('action') || '';
    if (action.blank()) action = window.location.href;
    options.parameters = form.serialize(true);

    if (params) {
      if (Object.isString(params)) params = params.toQueryParams();
      Object.extend(options.parameters, params);
    }

    if (form.hasAttribute('method') && !options.method)
      options.method = form.method;

    return new Ajax.Request(action, options);
  }
};

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


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

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

Form.Element.Methods = {

  serialize: function(element) {
    element = $(element);
    if (!element.disabled && element.name) {
      var value = element.getValue();
      if (value != undefined) {
        var pair = { };
        pair[element.name] = value;
        return Object.toQueryString(pair);
      }
    }
    return '';
  },

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

  setValue: function(element, value) {
    element = $(element);
    var method = element.tagName.toLowerCase();
    Form.Element.Serializers[method](element, value);
    return element;
  },

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

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

  activate: function(element) {
    element = $(element);
    try {
      element.focus();
      if (element.select && (element.tagName.toLowerCase() != 'input' ||
          !(/^(?:button|reset|submit)$/i.test(element.type))))
        element.select();
    } catch (e) { }
    return element;
  },

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

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

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

var Field = Form.Element;

var $F = Form.Element.Methods.getValue;

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

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

  inputSelector: function(element, value) {
    if (Object.isUndefined(value)) return element.checked ? element.value : null;
    else element.checked = !!value;
  },

  textarea: function(element, value) {
    if (Object.isUndefined(value)) return element.value;
    else element.value = value;
  },

  select: function(element, value) {
    if (Object.isUndefined(value))
      return this[element.type == 'select-one' ?
        'selectOne' : 'selectMany'](element);
    else {
      var opt, currentValue, single = !Object.isArray(value);
      for (var i = 0, length = element.length; i < length; i++) {
        opt = element.options[i];
        currentValue = this.optionValue(opt);
        if (single) {
          if (currentValue == value) {
            opt.selected = true;
            return;
          }
        }
        else opt.selected = value.include(currentValue);
      }
    }
  },

  selectOne: function(element) {
    var index = element.selectedIndex;
    return index >= 0 ? this.optionValue(element.options[index]) : null;
  },

  selectMany: function(element) {
    var values, length = element.length;
    if (!length) return null;

    for (var i = 0, values = []; i < length; i++) {
      var opt = element.options[i];
      if (opt.selected) values.push(this.optionValue(opt));
    }
    return values;
  },

  optionValue: function(opt) {
    return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
  }
};

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


Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
  initialize: function($super, element, frequency, callback) {
    $super(callback, frequency);
    this.element   = $(element);
    this.lastValue = this.getValue();
  },

  execute: function() {
    var value = this.getValue();
    if (Object.isString(this.lastValue) && Object.isString(value) ?
        this.lastValue != value : String(this.lastValue) != String(value)) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  }
});

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

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

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

Abstract.EventObserver = Class.create({
  initialize: function(element, callback) {
    this.element  = $(element);
    this.callback = callback;

    this.lastValue = this.getValue();
    if (this.element.tagName.toLowerCase() == 'form')
      this.registerFormCallbacks();
    else
      this.registerCallback(this.element);
  },

  onElementEvent: function() {
    var value = this.getValue();
    if (this.lastValue != value) {
      this.callback(this.element, value);
      this.lastValue = value;
    }
  },

  registerFormCallbacks: function() {
    Form.getElements(this.element).each(this.registerCallback, this);
  },

  registerCallback: function(element) {
    if (element.type) {
      switch (element.type.toLowerCase()) {
        case 'checkbox':
        case 'radio':
          Event.observe(element, 'click', this.onElementEvent.bind(this));
          break;
        default:
          Event.observe(element, 'change', this.onElementEvent.bind(this));
          break;
      }
    }
  }
});

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

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

  var Event = {
    KEY_BACKSPACE: 8,
    KEY_TAB:       9,
    KEY_RETURN:   13,
    KEY_ESC:      27,
    KEY_LEFT:     37,
    KEY_UP:       38,
    KEY_RIGHT:    39,
    KEY_DOWN:     40,
    KEY_DELETE:   46,
    KEY_HOME:     36,
    KEY_END:      35,
    KEY_PAGEUP:   33,
    KEY_PAGEDOWN: 34,
    KEY_INSERT:   45,

    cache: {}
  };

  var docEl = document.documentElement;
  var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
    && 'onmouseleave' in docEl;

  var _isButton;
  if (Prototype.Browser.IE) {
    var buttonMap = { 0: 1, 1: 4, 2: 2 };
    _isButton = function(event, code) {
      return event.button === buttonMap[code];
    };
  } else if (Prototype.Browser.WebKit) {
    _isButton = function(event, code) {
      switch (code) {
        case 0: return event.which == 1 && !event.metaKey;
        case 1: return event.which == 1 && event.metaKey;
        default: return false;
      }
    };
  } else {
    _isButton = function(event, code) {
      return event.which ? (event.which === code + 1) : (event.button === code);
    };
  }

  function isLeftClick(event)   { return _isButton(event, 0) }

  function isMiddleClick(event) { return _isButton(event, 1) }

  function isRightClick(event)  { return _isButton(event, 2) }

  function element(event) {
    event = Event.extend(event);

    var node = event.target, type = event.type,
     currentTarget = event.currentTarget;

    if (currentTarget && currentTarget.tagName) {
      if (type === 'load' || type === 'error' ||
        (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
          && currentTarget.type === 'radio'))
            node = currentTarget;
    }

    if (node.nodeType == Node.TEXT_NODE)
      node = node.parentNode;

    return Element.extend(node);
  }

  function findElement(event, expression) {
    var element = Event.element(event);
    if (!expression) return element;
    var elements = [element].concat(element.ancestors());
    return Selector.findElement(elements, expression, 0);
  }

  function pointer(event) {
    return { x: pointerX(event), y: pointerY(event) };
  }

  function pointerX(event) {
    var docElement = document.documentElement,
     body = document.body || { scrollLeft: 0 };

    return event.pageX || (event.clientX +
      (docElement.scrollLeft || body.scrollLeft) -
      (docElement.clientLeft || 0));
  }

  function pointerY(event) {
    var docElement = document.documentElement,
     body = document.body || { scrollTop: 0 };

    return  event.pageY || (event.clientY +
       (docElement.scrollTop || body.scrollTop) -
       (docElement.clientTop || 0));
  }


  function stop(event) {
    Event.extend(event);
    event.preventDefault();
    event.stopPropagation();

    event.stopped = true;
  }

  Event.Methods = {
    isLeftClick: isLeftClick,
    isMiddleClick: isMiddleClick,
    isRightClick: isRightClick,

    element: element,
    findElement: findElement,

    pointer: pointer,
    pointerX: pointerX,
    pointerY: pointerY,

    stop: stop
  };


  var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
    m[name] = Event.Methods[name].methodize();
    return m;
  });

  if (Prototype.Browser.IE) {
    function _relatedTarget(event) {
      var element;
      switch (event.type) {
        case 'mouseover': element = event.fromElement; break;
        case 'mouseout':  element = event.toElement;   break;
        default: return null;
      }
      return Element.extend(element);
    }

    Object.extend(methods, {
      stopPropagation: function() { this.cancelBubble = true },
      preventDefault:  function() { this.returnValue = false },
      inspect: function() { return '[object Event]' }
    });

    Event.extend = function(event, element) {
      if (!event) return false;
      if (event._extendedByPrototype) return event;

      event._extendedByPrototype = Prototype.emptyFunction;
      var pointer = Event.pointer(event);

      Object.extend(event, {
        target: event.srcElement || element,
        relatedTarget: _relatedTarget(event),
        pageX:  pointer.x,
        pageY:  pointer.y
      });

      return Object.extend(event, methods);
    };
  } else {
    Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
    Object.extend(Event.prototype, methods);
    Event.extend = Prototype.K;
  }

  function _createResponder(element, eventName, handler) {
    var registry = Element.retrieve(element, 'prototype_event_registry');

    if (Object.isUndefined(registry)) {
      CACHE.push(element);
      registry = Element.retrieve(element, 'prototype_event_registry', $H());
    }

    var respondersForEvent = registry.get(eventName);
    if (Object.isUndefined(respondersForEvent)) {
      respondersForEvent = [];
      registry.set(eventName, respondersForEvent);
    }

    if (respondersForEvent.pluck('handler').include(handler)) return false;

    var responder;
    if (eventName.include(":")) {
      responder = function(event) {
        if (Object.isUndefined(event.eventName))
          return false;

        if (event.eventName !== eventName)
          return false;

        Event.extend(event, element);
        handler.call(element, event);
      };
    } else {
      if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
       (eventName === "mouseenter" || eventName === "mouseleave")) {
        if (eventName === "mouseenter" || eventName === "mouseleave") {
          responder = function(event) {
            Event.extend(event, element);

            var parent = event.relatedTarget;
            while (parent && parent !== element) {
              try { parent = parent.parentNode; }
              catch(e) { parent = element; }
            }

            if (parent === element) return;

            handler.call(element, event);
          };
        }
      } else {
        responder = function(event) {
          Event.extend(event, element);
          handler.call(element, event);
        };
      }
    }

    responder.handler = handler;
    respondersForEvent.push(responder);
    return responder;
  }

  function _destroyCache() {
    for (var i = 0, length = CACHE.length; i < length; i++) {
      Event.stopObserving(CACHE[i]);
      CACHE[i] = null;
    }
  }

  var CACHE = [];

  if (Prototype.Browser.IE)
    window.attachEvent('onunload', _destroyCache);

  if (Prototype.Browser.WebKit)
    window.addEventListener('unload', Prototype.emptyFunction, false);


  var _getDOMEventName = Prototype.K;

  if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
    _getDOMEventName = function(eventName) {
      var translations = { mouseenter: "mouseover", mouseleave: "mouseout" };
      return eventName in translations ? translations[eventName] : eventName;
    };
  }

  function observe(element, eventName, handler) {
    element = $(element);

    var responder = _createResponder(element, eventName, handler);

    if (!responder) return element;

    if (eventName.include(':')) {
      if (element.addEventListener)
        element.addEventListener("dataavailable", responder, false);
      else {
        element.attachEvent("ondataavailable", responder);
        element.attachEvent("onfilterchange", responder);
      }
    } else {
      var actualEventName = _getDOMEventName(eventName);

      if (element.addEventListener)
        element.addEventListener(actualEventName, responder, false);
      else
        element.attachEvent("on" + actualEventName, responder);
    }

    return element;
  }

  function stopObserving(element, eventName, handler) {
    element = $(element);

    var registry = Element.retrieve(element, 'prototype_event_registry');

    if (Object.isUndefined(registry)) return element;

    if (eventName && !handler) {
      var responders = registry.get(eventName);

      if (Object.isUndefined(responders)) return element;

      responders.each( function(r) {
        Element.stopObserving(element, eventName, r.handler);
      });
      return element;
    } else if (!eventName) {
      registry.each( function(pair) {
        var eventName = pair.key, responders = pair.value;

        responders.each( function(r) {
          Element.stopObserving(element, eventName, r.handler);
        });
      });
      return element;
    }

    var responders = registry.get(eventName);

    if (!responders) return;

    var responder = responders.find( function(r) { return r.handler === handler; });
    if (!responder) return element;

    var actualEventName = _getDOMEventName(eventName);

    if (eventName.include(':')) {
      if (element.removeEventListener)
        element.removeEventListener("dataavailable", responder, false);
      else {
        element.detachEvent("ondataavailable", responder);
        element.detachEvent("onfilterchange",  responder);
      }
    } else {
      if (element.removeEventListener)
        element.removeEventListener(actualEventName, responder, false);
      else
        element.detachEvent('on' + actualEventName, responder);
    }

    registry.set(eventName, responders.without(responder));

    return element;
  }

  function fire(element, eventName, memo, bubble) {
    element = $(element);

    if (Object.isUndefined(bubble))
      bubble = true;

    if (element == document && document.createEvent && !element.dispatchEvent)
      element = document.documentElement;

    var event;
    if (document.createEvent) {
      event = document.createEvent('HTMLEvents');
      event.initEvent('dataavailable', true, true);
    } else {
      event = document.createEventObject();
      event.eventType = bubble ? 'ondataavailable' : 'onfilterchange';
    }

    event.eventName = eventName;
    event.memo = memo || { };

    if (document.createEvent)
      element.dispatchEvent(event);
    else
      element.fireEvent(event.eventType, event);

    return Event.extend(event);
  }


  Object.extend(Event, Event.Methods);

  Object.extend(Event, {
    fire:          fire,
    observe:       observe,
    stopObserving: stopObserving
  });

  Element.addMethods({
    fire:          fire,

    observe:       observe,

    stopObserving: stopObserving
  });

  Object.extend(document, {
    fire:          fire.methodize(),

    observe:       observe.methodize(),

    stopObserving: stopObserving.methodize(),

    loaded:        false
  });

  if (window.Event) Object.extend(window.Event, Event);
  else window.Event = Event;
})();

(function() {
  /* Support for the DOMContentLoaded event is based on work by Dan Webb,
     Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */

  var timer;

  function fireContentLoadedEvent() {
    if (document.loaded) return;
    if (timer) window.clearTimeout(timer);
    document.loaded = true;
    document.fire('dom:loaded');
  }

  function checkReadyState() {
    if (document.readyState === 'complete') {
      document.stopObserving('readystatechange', checkReadyState);
      fireContentLoadedEvent();
    }
  }

  function pollDoScroll() {
    try { document.documentElement.doScroll('left'); }
    catch(e) {
      timer = pollDoScroll.defer();
      return;
    }
    fireContentLoadedEvent();
  }

  if (document.addEventListener) {
    document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
  } else {
    document.observe('readystatechange', checkReadyState);
    if (window == top)
      timer = pollDoScroll.defer();
  }

  Event.observe(window, 'load', fireContentLoadedEvent);
})();

Element.addMethods();

/*------------------------------- DEPRECATED -------------------------------*/

Hash.toQueryString = Object.toQueryString;

var Toggle = { display: Element.toggle };

Element.Methods.childOf = Element.Methods.descendantOf;

var Insertion = {
  Before: function(element, content) {
    return Element.insert(element, {before:content});
  },

  Top: function(element, content) {
    return Element.insert(element, {top:content});
  },

  Bottom: function(element, content) {
    return Element.insert(element, {bottom:content});
  },

  After: function(element, content) {
    return Element.insert(element, {after:content});
  }
};

var $continue = new Error('"throw $continue" is deprecated, use "return" instead');

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

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

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

  withinIncludingScrolloffsets: function(element, x, y) {
    var offsetcache = Element.cumulativeScrollOffset(element);

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

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

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


  cumulativeOffset: Element.Methods.cumulativeOffset,

  positionedOffset: Element.Methods.positionedOffset,

  absolutize: function(element) {
    Position.prepare();
    return Element.absolutize(element);
  },

  relativize: function(element) {
    Position.prepare();
    return Element.relativize(element);
  },

  realOffset: Element.Methods.cumulativeScrollOffset,

  offsetParent: Element.Methods.getOffsetParent,

  page: Element.Methods.viewportOffset,

  clone: function(source, target, options) {
    options = options || { };
    return Element.clonePosition(target, source, options);
  }
};

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

if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
  function iter(name) {
    return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
  }

  instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
  function(element, className) {
    className = className.toString().strip();
    var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
    return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
  } : function(element, className) {
    className = className.toString().strip();
    var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
    if (!classNames && !className) return elements;

    var nodes = $(element).getElementsByTagName('*');
    className = ' ' + className + ' ';

    for (var i = 0, child, cn; child = nodes[i]; i++) {
      if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
          (classNames && classNames.all(function(name) {
            return !name.toString().blank() && cn.include(' ' + name + ' ');
          }))))
        elements.push(Element.extend(child));
    }
    return elements;
  };

  return function(className, parentElement) {
    return $(parentElement || document.body).getElementsByClassName(className);
  };
}(Element.Methods);

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

Element.ClassNames = Class.create();
Element.ClassNames.prototype = {
  initialize: function(element) {
    this.element = $(element);
  },

  _each: function(iterator) {
    this.element.className.split(/\s+/).select(function(name) {
      return name.length > 0;
    })._each(iterator);
  },

  set: function(className) {
    this.element.className = className;
  },

  add: function(classNameToAdd) {
    if (this.include(classNameToAdd)) return;
    this.set($A(this).concat(classNameToAdd).join(' '));
  },

  remove: function(classNameToRemove) {
    if (!this.include(classNameToRemove)) return;
    this.set($A(this).without(classNameToRemove).join(' '));
  },

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

Object.extend(Element.ClassNames.prototype, Enumerable);

/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
///shared/client_scripts/ajax/scriptaculous/src/effects.js
/*--------------------------------------------------------------------------*/
// script.aculo.us effects.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki
// 
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/ 

// converts rgb() and #xxx to #xxxxxx format,  
// returns self (or first argument) if not convertable  
String.prototype.parseColor = function() {  
  var color = '#';
  if (this.slice(0,4) == 'rgb(') {  
    var cols = this.slice(4,this.length-1).split(',');  
    var i=0; do { color += parseInt(cols[i]).toColorPart() } while (++i<3);  
  } else {  
    if (this.slice(0,1) == '#') {  
      if (this.length==4) for(var i=1;i<4;i++) color += (this.charAt(i) + this.charAt(i)).toLowerCase();  
      if (this.length==7) color = this.toLowerCase();  
    }  
  }  
  return (color.length==7 ? color : (arguments[0] || this));  
};

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

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

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

Element.setContentZoom = function(element, percent) {
  element = $(element);  
  element.setStyle({fontSize: (percent/100) + 'em'});   
  if (Prototype.Browser.WebKit) window.scrollBy(0,0);
  return element;
};

Element.getInlineOpacity = function(element){
  return $(element).style.opacity || '';
};

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

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

var Effect = {
  _elementDoesNotExistError: {
    name: 'ElementDoesNotExistError',
    message: 'The specified DOM element does not exist, but is required for this effect to operate'
  },
  Transitions: {
    linear: Prototype.K,
    sinoidal: function(pos) {
      return (-Math.cos(pos*Math.PI)/2) + 0.5;
    },
    reverse: function(pos) {
      return 1-pos;
    },
    flicker: function(pos) {
      var pos = ((-Math.cos(pos*Math.PI)/4) + 0.75) + Math.random()/4;
      return pos > 1 ? 1 : pos;
    },
    wobble: function(pos) {
      return (-Math.cos(pos*Math.PI*(9*pos))/2) + 0.5;
    },
    pulse: function(pos, pulses) { 
      pulses = pulses || 5; 
      return (
        ((pos % (1/pulses)) * pulses).round() == 0 ? 
              ((pos * pulses * 2) - (pos * pulses * 2).floor()) : 
          1 - ((pos * pulses * 2) - (pos * pulses * 2).floor())
        );
    },
    spring: function(pos) { 
      return 1 - (Math.cos(pos * 4.5 * Math.PI) * Math.exp(-pos * 6)); 
    },
    none: function(pos) {
      return 0;
    },
    full: function(pos) {
      return 1;
    }
  },
  DefaultOptions: {
    duration:   1.0,   // seconds
    fps:        100,   // 100= assume 66fps max.
    sync:       false, // true for combining
    from:       0.0,
    to:         1.0,
    delay:      0.0,
    queue:      'parallel'
  },
  tagifyText: function(element) {
    var tagifyStyle = 'position:relative';
    if (Prototype.Browser.IE) tagifyStyle += ';zoom:1';
    
    element = $(element);
    $A(element.childNodes).each( function(child) {
      if (child.nodeType==3) {
        child.nodeValue.toArray().each( function(character) {
          element.insertBefore(
            new Element('span', {style: tagifyStyle}).update(
              character == ' ' ? String.fromCharCode(160) : character), 
              child);
        });
        Element.remove(child);
      }
    });
  },
  multiple: function(element, effect) {
    var elements;
    if (((typeof element == 'object') || 
        Object.isFunction(element)) && 
       (element.length))
      elements = element;
    else
      elements = $(element).childNodes;
      
    var options = Object.extend({
      speed: 0.1,
      delay: 0.0
    }, arguments[2] || { });
    var masterDelay = options.delay;

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

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

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

Effect.ScopedQueue = Class.create(Enumerable, {
  initialize: function() {
    this.effects  = [];
    this.interval = null;    
  },
  _each: function(iterator) {
    this.effects._each(iterator);
  },
  add: function(effect) {
    var timestamp = new Date().getTime();
    
    var position = Object.isString(effect.options.queue) ? 
      effect.options.queue : effect.options.queue.position;
    
    switch(position) {
      case 'front':
        // move unstarted effects after this effect  
        this.effects.findAll(function(e){ return e.state=='idle' }).each( function(e) {
            e.startOn  += effect.finishOn;
            e.finishOn += effect.finishOn;
          });
        break;
      case 'with-last':
        timestamp = this.effects.pluck('startOn').max() || timestamp;
        break;
      case 'end':
        // start effect after last queued effect has finished
        timestamp = this.effects.pluck('finishOn').max() || timestamp;
        break;
    }
    
    effect.startOn  += timestamp;
    effect.finishOn += timestamp;

    if (!effect.options.queue.limit || (this.effects.length < effect.options.queue.limit))
      this.effects.push(effect);
    
    if (!this.interval)
      this.interval = setInterval(this.loop.bind(this), 15);
  },
  remove: function(effect) {
    this.effects = this.effects.reject(function(e) { return e==effect });
    if (this.effects.length == 0) {
      clearInterval(this.interval);
      this.interval = null;
    }
  },
  loop: function() {
    var timePos = new Date().getTime();
    for(var i=0, len=this.effects.length;i<len;i++) 
      this.effects[i] && this.effects[i].loop(timePos);
  }
});

Effect.Queues = {
  instances: $H(),
  get: function(queueName) {
    if (!Object.isString(queueName)) return queueName;
    
    return this.instances.get(queueName) ||
      this.instances.set(queueName, new Effect.ScopedQueue());
  }
};
Effect.Queue = Effect.Queues.get('global');

Effect.Base = Class.create({
  position: null,
  start: function(options) {
    function codeForEvent(options,eventName){
      return (
        (options[eventName+'Internal'] ? 'this.options.'+eventName+'Internal(this);' : '') +
        (options[eventName] ? 'this.options.'+eventName+'(this);' : '')
      );
    }
    if (options && options.transition === false) options.transition = Effect.Transitions.linear;
    this.options      = Object.extend(Object.extend({ },Effect.DefaultOptions), options || { });
    this.currentFrame = 0;
    this.state        = 'idle';
    this.startOn      = this.options.delay*1000;
    this.finishOn     = this.startOn+(this.options.duration*1000);
    this.fromToDelta  = this.options.to-this.options.from;
    this.totalTime    = this.finishOn-this.startOn;
    this.totalFrames  = this.options.fps*this.options.duration;
    
    eval('this.render = function(pos){ '+
      'if (this.state=="idle"){this.state="running";'+
      codeForEvent(this.options,'beforeSetup')+
      (this.setup ? 'this.setup();':'')+ 
      codeForEvent(this.options,'afterSetup')+
      '};if (this.state=="running"){'+
      'pos=this.options.transition(pos)*'+this.fromToDelta+'+'+this.options.from+';'+
      'this.position=pos;'+
      codeForEvent(this.options,'beforeUpdate')+
      (this.update ? 'this.update(pos);':'')+
      codeForEvent(this.options,'afterUpdate')+
      '}}');
    
    this.event('beforeStart');
    if (!this.options.sync)
      Effect.Queues.get(Object.isString(this.options.queue) ? 
        'global' : this.options.queue.scope).add(this);
  },
  loop: function(timePos) {
    if (timePos >= this.startOn) {
      if (timePos >= this.finishOn) {
        this.render(1.0);
        this.cancel();
        this.event('beforeFinish');
        if (this.finish) this.finish(); 
        this.event('afterFinish');
        return;  
      }
      var pos   = (timePos - this.startOn) / this.totalTime,
          frame = (pos * this.totalFrames).round();
      if (frame > this.currentFrame) {
        this.render(pos);
        this.currentFrame = frame;
      }
    }
  },
  cancel: function() {
    if (!this.options.sync)
      Effect.Queues.get(Object.isString(this.options.queue) ? 
        'global' : this.options.queue.scope).remove(this);
    this.state = 'finished';
  },
  event: function(eventName) {
    if (this.options[eventName + 'Internal']) this.options[eventName + 'Internal'](this);
    if (this.options[eventName]) this.options[eventName](this);
  },
  inspect: function() {
    var data = $H();
    for(property in this)
      if (!Object.isFunction(this[property])) data.set(property, this[property]);
    return '#<Effect:' + data.inspect() + ',options:' + $H(this.options).inspect() + '>';
  }
});

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

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

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

Effect.Opacity = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    // make this work on IE on elements without 'layout'
    if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
      this.element.setStyle({zoom: 1});
    var options = Object.extend({
      from: this.element.getOpacity() || 0.0,
      to:   1.0
    }, arguments[1] || { });
    this.start(options);
  },
  update: function(position) {
    this.element.setOpacity(position);
  }
});

Effect.Move = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      x:    0,
      y:    0,
      mode: 'relative'
    }, arguments[1] || { });
    this.start(options);
  },
  setup: function() {
    this.element.makePositioned();
    this.originalLeft = parseFloat(this.element.getStyle('left') || '0');
    this.originalTop  = parseFloat(this.element.getStyle('top')  || '0');
    if (this.options.mode == 'absolute') {
      this.options.x = this.options.x - this.originalLeft;
      this.options.y = this.options.y - this.originalTop;
    }
  },
  update: function(position) {
    this.element.setStyle({
      left: (this.options.x  * position + this.originalLeft).round() + 'px',
      top:  (this.options.y  * position + this.originalTop).round()  + 'px'
    });
  }
});

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

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

Effect.Highlight = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({ startcolor: '#ffff99' }, arguments[1] || { });
    this.start(options);
  },
  setup: function() {
    // Prevent executing on elements not in the layout flow
    if (this.element.getStyle('display')=='none') { this.cancel(); return; }
    // Disable background image during the effect
    this.oldStyle = { };
    if (!this.options.keepBackgroundImage) {
      this.oldStyle.backgroundImage = this.element.getStyle('background-image');
      this.element.setStyle({backgroundImage: 'none'});
    }
    if (!this.options.endcolor)
      this.options.endcolor = this.element.getStyle('background-color').parseColor('#ffffff');
    if (!this.options.restorecolor)
      this.options.restorecolor = this.element.getStyle('background-color');
    // init color calculations
    this._base  = $R(0,2).map(function(i){ return parseInt(this.options.startcolor.slice(i*2+1,i*2+3),16) }.bind(this));
    this._delta = $R(0,2).map(function(i){ return parseInt(this.options.endcolor.slice(i*2+1,i*2+3),16)-this._base[i] }.bind(this));
  },
  update: function(position) {
    this.element.setStyle({backgroundColor: $R(0,2).inject('#',function(m,v,i){
      return m+((this._base[i]+(this._delta[i]*position)).round().toColorPart()); }.bind(this)) });
  },
  finish: function() {
    this.element.setStyle(Object.extend(this.oldStyle, {
      backgroundColor: this.options.restorecolor
    }));
  }
});

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

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

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

/* ------------- combination effects ------------- */

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

Effect.Appear = function(element) {
  element = $(element);
  var options = Object.extend({
  from: (element.getStyle('display') == 'none' ? 0.0 : element.getOpacity() || 0.0),
  to:   1.0,
  // force Safari to render floated elements properly
  afterFinishInternal: function(effect) {
    effect.element.forceRerendering();
  },
  beforeSetup: function(effect) {
    effect.element.setOpacity(effect.options.from).show(); 
  }}, arguments[1] || { });
  return new Effect.Opacity(element,options);
};

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

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

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

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

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

Effect.Shake = function(element) {
  element = $(element);
  var options = Object.extend({
    distance: 20,
    duration: 0.5
  }, arguments[1] || {});
  var distance = parseFloat(options.distance);
  var split = parseFloat(options.duration) / 10.0;
  var oldStyle = {
    top: element.getStyle('top'),
    left: element.getStyle('left') };
    return new Effect.Move(element,
      { x:  distance, y: 0, duration: split, afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x:  distance*2, y: 0, duration: split*2,  afterFinishInternal: function(effect) {
    new Effect.Move(effect.element,
      { x: -distance, y: 0, duration: split, afterFinishInternal: function(effect) {
        effect.element.undoPositioned().setStyle(oldStyle);
  }}) }}) }}) }}) }}) }});
};

Effect.SlideDown = function(element) {
  element = $(element).cleanWhitespace();
  // SlideDown need to have the content of the element wrapped in a container element with fixed height!
  var oldInnerBottom = element.down().getStyle('bottom');
  var elementDimensions = element.getDimensions();
  return new Effect.Scale(element, 100, Object.extend({ 
    scaleContent: false, 
    scaleX: false, 
    scaleFrom: window.opera ? 0 : 1,
    scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},
    restoreAfterFinish: true,
    afterSetup: function(effect) {
      effect.element.makePositioned();
      effect.element.down().makePositioned();
      if (window.opera) effect.element.setStyle({top: ''});
      effect.element.makeClipping().setStyle({height: '0px'}).show(); 
    },
    afterUpdateInternal: function(effect) {
      effect.element.down().setStyle({bottom:
        (effect.dims[0] - effect.element.clientHeight) + 'px' }); 
    },
    afterFinishInternal: function(effect) {
      effect.element.undoClipping().undoPositioned();
      effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); }
    }, arguments[1] || { })
  );
};

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

// Bug in opera makes the TD containing this element expand for a instance after finish 
Effect.Squish = function(element) {
  return new Effect.Scale(element, window.opera ? 1 : 0, { 
    restoreAfterFinish: true,
    beforeSetup: function(effect) {
      effect.element.makeClipping(); 
    },  
    afterFinishInternal: function(effect) {
      effect.element.hide().undoClipping(); 
    }
  });
};

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

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

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

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

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

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

Effect.Morph = Class.create(Effect.Base, {
  initialize: function(element) {
    this.element = $(element);
    if (!this.element) throw(Effect._elementDoesNotExistError);
    var options = Object.extend({
      style: { }
    }, arguments[1] || { });
    
    if (!Object.isString(options.style)) this.style = $H(options.style);
    else {
      if (options.style.include(':'))
        this.style = options.style.parseStyle();
      else {
        this.element.addClassName(options.style);
        this.style = $H(this.element.getStyles());
        this.element.removeClassName(options.style);
        var css = this.element.getStyles();
        this.style = this.style.reject(function(style) {
          return style.value == css[style.key];
        });
        options.afterFinishInternal = function(effect) {
          effect.element.addClassName(effect.options.style);
          effect.transforms.each(function(transform) {
            effect.element.style[transform.style] = '';
          });
        }
      }
    }
    this.start(options);
  },
  
  setup: function(){
    function parseColor(color){
      if (!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
      color = color.parseColor();
      return $R(0,2).map(function(i){
        return parseInt( color.slice(i*2+1,i*2+3), 16 ) 
      });
    }
    this.transforms = this.style.map(function(pair){
      var property = pair[0], value = pair[1], unit = null;

      if (value.parseColor('#zzzzzz') != '#zzzzzz') {
        value = value.parseColor();
        unit  = 'color';
      } else if (property == 'opacity') {
        value = parseFloat(value);
        if (Prototype.Browser.IE && (!this.element.currentStyle.hasLayout))
          this.element.setStyle({zoom: 1});
      } else if (Element.CSS_LENGTH.test(value)) {
          var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/);
          value = parseFloat(components[1]);
          unit = (components.length == 3) ? components[2] : null;
      }

      var originalValue = this.element.getStyle(property);
      return { 
        style: property.camelize(), 
        originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0), 
        targetValue: unit=='color' ? parseColor(value) : value,
        unit: unit
      };
    }.bind(this)).reject(function(transform){
      return (
        (transform.originalValue == transform.targetValue) ||
        (
          transform.unit != 'color' &&
          (isNaN(transform.originalValue) || isNaN(transform.targetValue))
        )
      )
    });
  },
  update: function(position) {
    var style = { }, transform, i = this.transforms.length;
    while(i--)
      style[(transform = this.transforms[i]).style] = 
        transform.unit=='color' ? '#'+
          (Math.round(transform.originalValue[0]+
            (transform.targetValue[0]-transform.originalValue[0])*position)).toColorPart() +
          (Math.round(transform.originalValue[1]+
            (transform.targetValue[1]-transform.originalValue[1])*position)).toColorPart() +
          (Math.round(transform.originalValue[2]+
            (transform.targetValue[2]-transform.originalValue[2])*position)).toColorPart() :
        (transform.originalValue +
          (transform.targetValue - transform.originalValue) * position).toFixed(3) + 
            (transform.unit === null ? '' : transform.unit);
    this.element.setStyle(style, true);
  }
});

Effect.Transform = Class.create({
  initialize: function(tracks){
    this.tracks  = [];
    this.options = arguments[1] || { };
    this.addTracks(tracks);
  },
  addTracks: function(tracks){
    tracks.each(function(track){
      track = $H(track);
      var data = track.values().first();
      this.tracks.push($H({
        ids:     track.keys().first(),
        effect:  Effect.Morph,
        options: { style: data }
      }));
    }.bind(this));
    return this;
  },
  play: function(){
    return new Effect.Parallel(
      this.tracks.map(function(track){
        var ids = track.get('ids'), effect = track.get('effect'), options = track.get('options');
        var elements = [$(ids) || $$(ids)].flatten();
        return elements.map(function(e){ return new effect(e, Object.extend({ sync:true }, options)) });
      }).flatten(),
      this.options
    );
  }
});

Element.CSS_PROPERTIES = $w(
  'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' + 
  'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
  'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
  'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
  'fontSize fontWeight height left letterSpacing lineHeight ' +
  'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
  'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
  'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
  'right textIndent top width wordSpacing zIndex');
  
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.__parseStyleElement = document.createElement('div');
String.prototype.parseStyle = function(){
  var style, styleRules = $H();
  if (Prototype.Browser.WebKit)
    style = new Element('div',{style:this}).style;
  else {
    String.__parseStyleElement.innerHTML = '<div style="' + this + '"></div>';
    style = String.__parseStyleElement.childNodes[0].style;
  }
  
  Element.CSS_PROPERTIES.each(function(property){
    if (style[property]) styleRules.set(property, style[property]); 
  });
  
  if (Prototype.Browser.IE && this.include('opacity'))
    styleRules.set('opacity', this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1]);

  return styleRules;
};

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

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

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

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

Element.addMethods(Effect.Methods);
/*--------------------------------------------------------------------------*/
///shared/client_scripts/ajax/scriptaculous/src/scriptaculous.js
/*--------------------------------------------------------------------------*/
// script.aculo.us scriptaculous.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// 
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Scriptaculous = {
  Version: '1.8.1',
  require: function(libraryName) {
    // inserting via DOM fails in Safari 2.0, so brute force approach
    document.write('<script type="text/javascript" src="'+libraryName+'"><\/script>');
  },
  REQUIRED_PROTOTYPE: '1.6.0',
  load: function() {
    function convertVersionString(versionString){
      var r = versionString.split('.');
      return parseInt(r[0])*100000 + parseInt(r[1])*1000 + parseInt(r[2]);
    }
 
    if((typeof Prototype=='undefined') || 
       (typeof Element == 'undefined') || 
       (typeof Element.Methods=='undefined') ||
       (convertVersionString(Prototype.Version) < 
        convertVersionString(Scriptaculous.REQUIRED_PROTOTYPE)))
       throw("script.aculo.us requires the Prototype JavaScript framework >= " +
        Scriptaculous.REQUIRED_PROTOTYPE);
    
    $A(document.getElementsByTagName("script")).findAll( function(s) {
      return (s.src && s.src.match(/scriptaculous\.js(\?.*)?$/))
    }).each( function(s) {
      var path = s.src.replace(/scriptaculous\.js(\?.*)?$/,'');
      var includes = s.src.match(/\?.*load=([a-z,]*)/);
      (includes ? includes[1] : 'builder,effects,dragdrop,controls,slider,sound').split(',').each(
       function(include) { Scriptaculous.require(path+include+'.js') });
    });
  }
}

Scriptaculous.load();
/*--------------------------------------------------------------------------*/
///shared/client_scripts/utils.js
/*--------------------------------------------------------------------------*/
var slert = alert;

function debug(obj) {
   var x = 'Dump of ' + obj + '\r\n';
   for (i in obj) {
      x += i + ' = ' + obj[i] + '\r\n';
   }

   prompt('Object dump - copy & paste into text editor', x);
}   

/*
 ==============================================================================================
	 Javascript Inheritance, see http://javascript.crockford.com/inheritance.html
	 Also read :
		http://www.webreference.com/js/column79/
			(Object-Oriented Programming with JavaScript, Part I: Inheritance)
		http://www.webreference.com/js/column80/
			(Object-Oriented Programming with JavaScript, Part II: Methods)
		http://w3future.com/html/stories/
*/
// The following from http://www.u.arizona.edu/~jscully/javafication.html
var inherits = "extends";
var br = "<br>";
//This method was deviously invented by Douglas Crockford.
Function.prototype.method = function (name, func)
{
   this.prototype[name] = func;
   return this;
};

// And this one was deviously invented by me, after finding out how cool javascript
// really was from Douglas Crockford's website.
Function.prototype['extends'] = function (Parent)
{
   var prototypeExists = false;
   var isOpera = (navigator.userAgent.toLowerCase().indexOf("opera") != -1);
   var self = this;
   self.prototype.base = function()
   {
      var s = "";
      var parentClass;

      for (var i = 0; i < arguments.length - 1; i++)
      {
         if (typeof(arguments[i]) == 'string')
            s += "'" + arguments[i] + "'";

         else s += arguments[i];

         s += ",";
      }

      if (typeof(arguments[arguments.length - 1]) == 'string')
         s += "'" + arguments[arguments.length - 1] + "'";

      else s += arguments[arguments.length - 1];

      parentClass = eval("new Parent(" + s + ")");


      for (var i in parentClass)
      {
         prototypeExists = false;
         if (isOpera == true && i.indexOf('toString') != -1) /*Then do nothing*/ ;
         else
         {
            for (var ii in self.prototype)
            {
               if (i.indexOf(ii) != -1) prototypeExists = true;
            }
            if (!prototypeExists) self.prototype[i] = parentClass[i];
         }
      }

      if ((self.prototype.toString).toString().indexOf("[native code]") != -1)
         self.prototype['toString'] = parentClass.toString;

      return parentClass;
   };

};

// "swiss" function for multiple inheritance
// copies parent member variables and methods into the function
Function.method('swiss', function (parent) {
   for (var i = 1; i < arguments.length; i += 1) {
      var name = arguments[i];
      this.prototype[name] = parent.prototype[name];
   }
   return this;
});


// from http://www.webreference.com/js/column79/7.html
function instanceOf(object, constructorFunction) {
   while (object != null) {
      if (object == constructorFunction.prototype)
      {
         return true
      }
      object = object.__proto__;
   }
   return false;
}
// ==============================================================================================

/*
Internet Explorer holds references to objects which are not JavaScript objects, and
which produce errors if they are treated as JavaScript objects. This is a problem because
typeof identifies them as JavaScript objects. The isAlien() function will return true if a
is one of those alien objects.
*/
function isAlien(a) {
   return isObject(a) && typeof a.constructor != 'function';
}

/*
isArray() returns true if a is an array, meaning that it was produced by the Array constructor
or by using the [ ] array literal notation.
*/
function isArray(a) {
   return isObject(a) && a.constructor == Array;
}

/*
isBoolean(a) returns true if a is one of the boolean values, true or false.
*/
function isBoolean(a) {
   return typeof a == 'boolean';
}

/*
isEmpty(a) returns true if a is an object or array or function containing no enumerable members.
*/
function isEmpty(o) {
   var i, v;
   if (isObject(o)) {
      for (i in o) {
         v = o[i];
         if (isUndefined(v) && isFunction(v)) {
            return false;
         }
      }
   }
   return true;
}

/*
TK: changed this as it doesn't seem to work in IE
isFunction(a) returns true if a is a function. Beware that some native functions in IE were
made to look like objects instead of functions. This function does not detect that.
*/
function isFunction(a) {
   if (!a) return false;
   //return typeof a == 'function';
   return a.call ? true : false;
}

/*
isNull(a) returns true if a is the null value.
*/
function isNull(a) {
   return typeof a == 'object' && !a;
}

/*
sNumber(a) returns true if a is a finite number. It returns false if a is NaN or Infinite.
It also returns false if a is a string that could be converted to a number.
*/
function isNumber(a) {
   return typeof a == 'number' && isFinite(a);
}

/*
isObject(a) returns true if a is an object, and array, or a function. It returns false if
 a is a string, a number, a boolean, or null, or undefined.
*/
function isObject(a) {
   return (a && typeof a == 'object') || isFunction(a);
}

/*
isString(a) returns true if a is a string.
*/
function isString(a) {
   return typeof a == 'string';
}

/*
isUndefined(a) returns true if a is the undefined value. You can get the undefined value
from an uninitialized variable or from a missing member of an object.
*/
function isUndefined(a) {
   return typeof a == 'undefined';
}

with (String) {

   /*
   entityify() produces a string in which '<', '>', and '&' are replaced with their HTML entity equivalents.
   This is essential for placing arbitrary strings into HTML texts. So,

       "if (a < b && b > c) {".entityify()

   produces

       "if (a &lt; b &amp;&amp; b &gt; c) {"

   */
   method('entityify', function () {
      return this.replace(/&/g, "&amp;").replace(/</g,
            "&lt;").replace(/>/g, "&gt;");
   });

   /*
   quote() produces a quoted string. This method returns a string which is like the original string except
   that it is wrapped in quotes and all quote and backslash characters are preceded with backslash.
   */
   method('quote', function () {
      var c, i, l = this.length, o = '"';
      for (i = 0; i < l; i += 1) {
         c = this.charAt(i);
         if (c >= ' ') {
            if (c == '\\' || c == '"') {
               o += '\\';
            }
            o += c;
         } else {
            switch (c) {
               case '\b':
                  o += '\\b';
                  break;
               case '\f':
                  o += '\\f';
                  break;
               case '\n':
                  o += '\\n';
                  break;
               case '\r':
                  o += '\\r';
                  break;
               case '\t':
                  o += '\\t';
                  break;
               default:
                  c = c.charCodeAt();
                  o += '\\u00' + Math.floor(c / 16).toString(16) +
                       (c % 16).toString(16);
            }
         }
      }
      return o + '"';
   });

   /*
   supplant() does variable substitution on the string. It scans through the string looking for expressions
   enclosed in { } braces. If an expression is found, use it as a key on the object, and if the key has a
   string value or number value, it is substituted for the bracket expression and it repeats. This is useful
   for automatically fixing URLs. So

   param = {domain: 'valvion.com', media: 'http://media.{domain}/'};
   url = "{media}logo.gif".supplant(param);

   produces a url containing "http://media.valvion.com/logo.gif".
   */
   method('supplant', function (o) {
      var i, j, s = this, v;
      for (; ;) {
         i = s.lastIndexOf('{');
         if (i < 0) {
            break;
         }
         j = s.indexOf('}', i);
         if (i + 1 >= j) {
            break;
         }
         v = o[s.substring(i + 1, j)];
         if (!isString(v) && !isNumber(v)) {
            break;
         }
         s = s.substring(0, i) + v + s.substring(j + 1);
      }
      return s;
   });

   /*
   The trim() method removes whitespace characters from the beginning and end of the string.
   */
   method('trim', function () {
      return this.replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1");
   });
}

/*
apply() is a method of a function which calls the function as though it is a method of the
object. The this variable will be bound to the object. args is an optional array of values
which will be used as the function's arguments.
*/
if (!isFunction(Function.apply)) {
   Function.method('apply', function (o, a) {
      var r, x = '____apply';
      if (!isObject(o)) {
         o = {};
      }
      o[x] = this;
      switch ((a && a.length) || 0) {
         case 0:
            r = o[x]();
            break;
         case 1:
            r = o[x](a[0]);
            break;
         case 2:
            r = o[x](a[0], a[1]);
            break;
         case 3:
            r = o[x](a[0], a[1], a[2]);
            break;
         case 4:
            r = o[x](a[0], a[1], a[2], a[3]);
            break;
         case 5:
            r = o[x](a[0], a[1], a[2], a[3], a[4]);
            break;
         case 6:
            r = o[x](a[0], a[1], a[2], a[3], a[4], a[5]);
            break;
         default:
            alert('Too many arguments to apply.');
      }
      delete o[x];
      return r;
   });
}

/*
These array methods are required by the ECMAScript Specification, but they did not make it
into IE 5.0, so we will add them ourselves. The push and pop methods allow use to use an array
as a stack. The shift and unshift methods allow us to use an array as a double-ended queue.
The splice method allows us to use an array as a string of values.All of these methods modify the array.

JavaScript arrays are implemented as hashtables, but when using these methods, it is easier to
think about traditional arrays, which are a contiguous series of numbered slots.
*/

/*
The pop() method removes the last item from an array and returns it.
*/
if (!isFunction(Array.prototype.pop)) {
   Array.method('pop', function () {
      return this.splice(this.length - 1, 1)[0];
   });
}

/*
The push() method appends one or more elements to the end of an array. The new length of the array is returned.
*/
if (!isFunction(Array.prototype.push)) {
   Array.method('push', function () {
      this.splice.apply(this,
            [this.length, 0].concat(Array.prototype.slice.apply(arguments)));
      return this.length;
   });
}

/*
The shift() method removes the [0] element from the array and returns it. It also reduces the subscripts of all
of the remaining elements in the array by one.
*/
if (!isFunction(Array.prototype.shift)) {
   Array.method('shift', function () {
      return this.splice(0, 1)[0];
   });
}

/*
The splice() method deletes elements starting at the start  index, and inserts new elements at the same point.
It returns an array containing the deleted values. Do not confuse the splice() method with the slice()  method
or the split() method.
*/
if (!isFunction(Array.prototype.splice)) {
   Array.method('splice', function (s, d) {
      var max = Math.max,
            min = Math.min,
            a = [], // The return value array
            e,  // element
            i = max(arguments.length - 2, 0),   // insert count
            k = 0,
            l = this.length,
            n,  // new length
            v,  // delta
            x;
      // shift count

      s = s || 0;
      if (s < 0) {
         s += l;
      }
      s = max(min(s, l), 0);
      // start point
      d = max(min(isNumber(d) ? d : l, l - s), 0);
      // delete count
      v = i - d;
      n = l + v;
      while (k < d) {
         e = this[s + k];
         if (!isUndefined(e)) {
            a[k] = e;
         }
         k += 1;
      }
      x = l - s - d;
      if (v < 0) {
         k = s + i;
         while (x) {
            this[k] = this[k - v];
            k += 1;
            x -= 1;
         }
         this.length = n;
      } else if (v > 0) {
         k = 1;
         while (x) {
            this[n - k] = this[l - k];
            k += 1;
            x -= 1;
         }
      }
      for (k = 0; k < i; ++k) {
         this[s + k] = arguments[k + 2];
      }
      return a;
   });
}

/*
The unshift() method inserts new elements to the beginning of an array. The new length of the array is returned.
*/
if (!isFunction(Array.prototype.unshift)) {
   Array.method('unshift', function () {
      this.splice.apply(this,
            [0, 0].concat(Array.prototype.slice.apply(arguments)));
      return this.length;
   });
}

/*
   The each() method iterates over each element in the array and executes the closure passed to it
   by Toby Kurien
*/
if (!isFunction(Array.prototype.each)) {
   Array.method('each', function (f) {
      if (!isFunction(f)) return;
      if (this.length == 0) return;

      for (var i = 0; i < this.length; i++) {
         f(this[i], i, i == (this.length - 1));
      }
   });
}

/*
   The collect() method iterates over each element in the array and executes the closure passed to it and returns
   a new array with the function applied
   by Toby Kurien
*/
if (!isFunction(Array.prototype.collect)) {
   Array.method('collect', function (f) {
      var newArray = new Array(this.length);
      if (!isFunction(f)) return newArray;
      if (this.length == 0) return newArray;

      for (var i = 0; i < this.length; i++) {
         newArray[i] = f(this[i], i, i == (this.length - 1));
      }
      return newArray;
   });
}

/*
   The indexOf() method iterates over each element in the array and returns the index of where the 
   item occurs in the array, or -1 if it doesn't
   by Toby Kurien
*/
if (!isFunction(Array.prototype.indexOf)) {
   Array.method('indexOf', function (obj) {
      if (this.length == 0) return -1;

      for (var i = 0; i < this.length; i++) {
         if (this[i] == obj) return i;
      }

      return -1;
   });
}

/*
   The find() method iterates over each element in the array and returns the index of where the 
   supplied function returns true, or -1 if it doesn't
   by Toby Kurien
*/
if (!isFunction(Array.prototype.find)) {
   Array.method('find', function (func) {
      if (this.length == 0) return -1;

      for (var i = 0; i < this.length; i++) {
         if (func(this[i])) return i;
      }

      return -1;
   });
}


/*
	From http://www.crockford.com/javascript/memory/leak.html
	To avoid memory leaks in IE when deleting DOM objects

   The purge function takes a reference to a DOM element as an argument. It loops through the element's
   attributes. If it finds any functions, it nulls them out. This breaks the cycle, allowing memory to be reclaimed.
   It will also look at all of the element's descendent elements, and clear out all of their cycles as well. The
   purge function is harmless on Mozilla and Opera. It is essential on IE. The purge function should be called before
   removing any element, either by the removeChild method, or by setting the innerHTML property.
*/
function purge(d) {
   var a = d.attributes, i, l, n;
   if (a) {
      l = a.length;
      for (i = 0; i < l; i += 1) {
         n = a[i].name;
         if (typeof d[n] === 'function') {
            d[n] = null;
         }
      }
   }
   a = d.childNodes;
   if (a) {
      l = a.length;
      for (i = 0; i < l; i += 1) {
         purge(d.childNodes[i]);
      }
   }
}

// ***********************************************************************************
// The following functions return the top, left, height and width of an html element
function getTop(element) {
   var top = element.offsetTop;
   if (element.offsetParent != null) {
      return top + getTop(element.offsetParent);
   }
   return top;
}

function getLeft(element) {
   var left = element.offsetLeft;
   if (element.offsetParent != null) {
      return left + getLeft(element.offsetParent);
   }
   return left;
}

// ***********************************************************************************
// expandCode() - replaces templates containing [$variable$] with values of the variable 
function expandCode(str, hash) {
   var start = str.indexOf('[$');
   if (start >= 0) {
      end = str.indexOf('$]', start);
      if (end > 0) {
         var prefix = str.substring(0, start);
         var code = str.substring(start + 2, end);
         var suffix = str.substring(end + 2);
         var codeOutput = "";
         try {
            if (hash != null) {
               codeOutput = hash.eval(code);
            } else {
               codeOutput = eval(code);
            }
         } catch (ex) {
            codeOutput = "Error: " + ex;
         }
         str = prefix + codeOutput + suffix;
      } else {
         var prefix = str.substring(0, start);
         var suffix = str.substring(start + 2);
         str = prefix + suffix;
      }
   }

   var start = str.indexOf('[$');
   if (start >= 0) {
      return expandCode(str, hash);
   } else {
      return str;
   }
}

/**
 * From http://peter.michaux.ca/article/3556
 * This method uses the "lazy definition" technique to redefine itself after it's been called once.
 * It returns the amount that the web page has scrolled by, with cross-browser support
 */
var getScrollY = function() {
   if (typeof window.pageYOffset == 'number') {

      getScrollY = function() {
         return window.pageYOffset;
      };

   } else if ((typeof document.compatMode == 'string') &&
              (document.compatMode.indexOf('CSS') >= 0) &&
              (document.documentElement) &&
              (typeof document.documentElement.scrollTop == 'number')) {

      getScrollY = function() {
         return document.documentElement.scrollTop;
      };

   } else if ((document.body) &&
              (typeof document.body.scrollTop == 'number')) {

      getScrollY = function() {
         return document.body.scrollTop;
      }

   } else {

      getScrollY = function() {
         return NaN;
      };

   }

   return getScrollY();
}

/**
 *
 * URL encode / decode
 * http://www.webtoolkit.info/
 *
 **/

var Url = {

// public method for url encoding
   encode : function (string) {
      return escape(this._utf8_encode(string));
   },

// public method for url decoding
   decode : function (string) {
      return this._utf8_decode(unescape(string));
   },

// private method for UTF-8 encoding
   _utf8_encode : function (string) {
      string = string.replace(/\r\n/g, "\n");
      var utftext = "";

      for (var n = 0; n < string.length; n++) {

         var c = string.charCodeAt(n);

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

      }

      return utftext;
   },

// private method for UTF-8 decoding
   _utf8_decode : function (utftext) {
      var string = "";
      var i = 0;
      var c = c1 = c2 = 0;

      while (i < utftext.length) {

         c = utftext.charCodeAt(i);

         if (c < 128) {
            string += String.fromCharCode(c);
            i++;
         }
         else if ((c > 191) && (c < 224)) {
            c2 = utftext.charCodeAt(i + 1);
            string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
            i += 2;
         }
         else {
            c2 = utftext.charCodeAt(i + 1);
            c3 = utftext.charCodeAt(i + 2);
            string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
            i += 3;
         }

      }

      return string;
   }

}

// Alternative to window.onload - this one runs the script before all images have been loaded (but HTML is ready). 
// Call domPageReady() at the end of the page so that other scripts don't overwrite the window.onload method. 
// @see http://www.hunlock.com/blogs/Are_you_ready_for_this 
// To register on load listeners, use registerOnLoad(function)
if (!window.registerOnLoad) {
   var ranOnload = false;
   // Flag to determine if we've ran the starting stack already.
   startStack = function() {
   };
   // A stack of functions to run onload/domready

   window.registerOnLoad = function(func) {
      var orgOnLoad = startStack;
      startStack = function () {
         orgOnLoad();
         func();
         return;
      }
   }

   if (window.Event && isFunction(Event.observe)) {
      // the cross browser way to do it, if prototype is loaded
      Event.observe(window, "load", function() {
         if (!ranOnload) {
            ranOnload = true;
            startStack();
         }
      });
   } else if (document.addEventListener) {
      // Mozilla actually has a DOM READY event.
      document.addEventListener("DOMContentLoaded", function() {
         if (!ranOnload) {
            ranOnload = true;
            startStack();
         }
      }, false);
   } else if (document.all && !window.opera) {
      // This is the IE style which exploits a property of the (standards defined) defer attribute
      document.write("<scr" + "ipt id='DOMReady' defer=true " + "src=//:><\/scr" + "ipt>");
      document.getElementById("DOMReady").onreadystatechange = function() {
         if (this.readyState == "complete" && (!ranOnload)) {
            ranOnload = true;
            startStack();
         }
      }
   }
}

function domPageReady() {
   var orgOnLoad = window.onload;
   registerOnLoad(orgOnLoad);
   window.onload = function() {
      if (!ranOnload) {
         ranOnload = true;
         startStack();
      }
   }
}

/**
 * Sets a Cookie with the given name and value.
 * <p/>
 * name       Name of the cookie
 * value      Value of the cookie
 * [expires]  Expiration date of the cookie (default: end of current session)
 * [path]     Path where the cookie is valid (default: path of calling document)
 * [domain]   Domain where the cookie is valid
 * (default: domain of calling document)
 * [secure]   Boolean value indicating if the cookie transmission requires a
 * secure transmission
 */
function setCookie(name, value, expires, path, domain, secure) {
   document.cookie = name + "=" + escape(value) +
                     ((expires) ? "; expires=" + expires.toGMTString() : "") +
                     ((path) ? "; path=" + path : "") +
                     ((domain) ? "; domain=" + domain : "") +
                     ((secure) ? "; secure" : "");
}

/**
 * Gets the value of the specified cookie.
 * <p/>
 * name  Name of the desired cookie.
 * <p/>
 * Returns a string containing value of specified cookie,
 * or null if cookie does not exist.
 */
function getCookie(name) {
   var dc = document.cookie;
   var prefix = name + "=";
   var begin = dc.indexOf("; " + prefix);
   if (begin == -1) {
      begin = dc.indexOf(prefix);
      if (begin != 0) return null;
   } else {
      begin += 2;
   }
   var end = document.cookie.indexOf(";", begin);
   if (end == -1) {
      end = dc.length;
   }
   return unescape(dc.substring(begin + prefix.length, end));
}

/**
 * Deletes the specified cookie.
 * <p/>
 * name      name of the cookie
 * [path]    path of the cookie (must be same as path used to create cookie)
 * [domain]  domain of the cookie (must be same as domain used to create cookie)
 */
function deleteCookie(name, path, domain) {
   if (getCookie(name)) {
      document.cookie = name + "=" +
                        ((path) ? "; path=" + path : "") +
                        ((domain) ? "; domain=" + domain : "") +
                        "; expires=Thu, 01-Jan-70 00:00:01 GMT";
   }
}

function loadScript(scriptUrl) {
   // Load the plugin script asynchronously
   var head = document.getElementsByTagName("head")[0];
   script = document.createElement('script');
   script.type = 'text/javascript';
   script.src = (scriptUrl.startsWith("http://") || scriptUrl.startsWith("https://") ? scriptUrl : ccs.contextPath + scriptUrl);
   head.appendChild(script);
}


function stretch(el, extra, leaveHorizontal) {
   if (!extra) extra = 0;
   try {
      if (el.style.display != '') el.style.display = '';
      if (el.style.height != '') el.style.height = '';
      document.getElementById(el.id).height = null;
      document.getElementById(el.id).height = window.frames[el.name].document.body.scrollHeight + extra;
      if (leaveHorizontal == null || leaveHorizontal != true) {
         document.getElementById(el.id).width = el.parentNode.offsetWidth - 4;
      }
   } catch(err) {
   }
}


/**
 * Create a console object for browsers that don't have one
 */
if (!window.console) {
   window.console = {};
   window.console.log = function(message) {
   }
   window.console.trace = function(params) {
   }
}

// TK - creates the package namespace
function declarePackage(dasPackage) {
   var items = dasPackage.split('.');
   var parent = window;
   for (var i = 0; i < items.length; i++) {
      if (parent[items[i]] == null) {
         parent[items[i]] = {};
      }
      parent = parent[items[i]];
   }
}

//Useful for repositioning elements. Gets the number of pixels you're scrolled down from the top.
function getScrollTop() {
   var ScrollTop = document.body.scrollTop;
   if (ScrollTop == 0) {
      if (window.pageYOffset)
         ScrollTop = window.pageYOffset;
      else
         ScrollTop = (document.body.parentElement) ? document.body.parentElement.scrollTop : 0;
   }
   return ScrollTop;
}


//EXAMPLE: <input type="password"  onKeyPress="if (checkEnter(event)) $('loginLink').onclick()"/>
function checkEnter(e) { //e is event object passed from function invocation
   var characterCode;

   if (e && e.which) { //if which property of event object is supported (NN4)
      e = e;
      characterCode = e.which;
      //character code is contained in NN4's which property
   } else {
      e = event;
      characterCode = e.keyCode;
      //character code is contained in IE's keyCode property
   }

   if (characterCode == 13) { //if generated character code is equal to ascii 13 (if enter key)
      return true;
   } else {
      return false;
   }
}


function getTextAreaHTML(areaName) {
   var html = document.getElementById(areaName).innerHTML;
   if (navigator.userAgent.toLowerCase().indexOf("chrome") == -1 && navigator.userAgent.toLowerCase().indexOf("safari") == -1) {
      var htmlNode = document.createElement("DIV");
      htmlNode.innerHTML = html;
      if (htmlNode.innerText) return htmlNode.innerText; // IE
      return htmlNode.textContent;
      // FF
   } else {
      return html;
      //Chrome
   }
}


   function doHover(elm, action) {
      var src = elm.src;
      var splitSrc = src.split("/");
      var imageName = splitSrc[splitSrc.length-1];
      var ext = imageName.split(".")[1];

      if (action=="on") {
         var re = new RegExp('\.' + ext);
         if (elm.src.indexOf("_active") == -1) { //Fix IE Bug.
            elm.src = src.replace(re, "_active." + ext);
         }
      } else {
         var re = new RegExp('_active\.' + ext);
         elm.src = src.replace(re, "." + ext);
      }
   }
/*--------------------------------------------------------------------------*/
///shared/client_scripts/ajax/behaviour.js
/*--------------------------------------------------------------------------*/
/*
   Behaviour v1.1 by Ben Nolan, June 2005. Based largely on the work
   of Simon Willison (see comments by Simon below).

   Description:
   	
   	Uses css selectors to apply javascript behaviours to enable
   	unobtrusive javascript in html documents.
   	
   Usage:   
   
	var myrules = {
		'b.someclass' : function(element){
			element.onclick = function(){
				alert(this.innerHTML);
			}
		},
		'#someid u' : function(element){
			element.onmouseover = function(){
				this.innerHTML = "BLAH!";
			}
		}
	};
	
	Behaviour.register(myrules);
	
	// Call Behaviour.apply() to re-apply the rules (if you
	// update the dom, etc).

   License:
   
   	This file is entirely BSD licensed.
   	
   More information:
   	
   	http://bennolan.com/behaviour/
   
*/   

var Behaviour = {
	list : new Array,
	
	register : function(sheet){
		Behaviour.list.push(sheet);
	},
	
	start : function(){
		Behaviour.addLoadEvent(function(){
			Behaviour.apply();
		});
	},
	
	apply : function(){
		for (h=0;sheet=Behaviour.list[h];h++){
			for (selector in sheet){
				list = document.getElementsBySelector(selector);
				
				if (!list){
					continue;
				}

				for (i=0;element=list[i];i++){
					sheet[selector](element);
				}
			}
		}
	},
	
	addLoadEvent : function(func){
		var oldonload = window.onload;
		
		if (typeof window.onload != 'function') {
			window.onload = func;
		} else {
			window.onload = function() {
				oldonload();
				func();
			}
		}
	}
}

Behaviour.start();

/*
   The following code is Copyright (C) Simon Willison 2004.

   document.getElementsBySelector(selector)
   - returns an array of element objects from the current document
     matching the CSS selector. Selectors can contain element names, 
     class names and ids and can be nested. For example:
     
       elements = document.getElementsBySelect('div#main p a.external')
     
     Will return an array of all 'a' elements with 'external' in their 
     class attribute that are contained inside 'p' elements that are 
     contained inside the 'div' element which has id="main"

   New in version 0.4: Support for CSS2 and CSS3 attribute selectors:
   See http://www.w3.org/TR/css3-selectors/#attribute-selectors

   Version 0.4 - Simon Willison, March 25th 2003
   -- Works in Phoenix 0.5, Mozilla 1.3, Opera 7, Internet Explorer 6, Internet Explorer 5 on Windows
   -- Opera 7 fails 
*/

function getAllChildren(e) {
  // Returns all children of element. Workaround required for IE5/Windows. Ugh.
  return e.all ? e.all : e.getElementsByTagName('*');
}

document.getElementsBySelector = function(selector) {
  // Attempt to fail gracefully in lesser browsers
  if (!document.getElementsByTagName) {
    return new Array();
  }
  // Split selector in to tokens
  var tokens = selector.split(' ');
  var currentContext = new Array(document);
  for (var i = 0; i < tokens.length; i++) {
    token = tokens[i].replace(/^\s+/,'').replace(/\s+$/,'');;
    if (token.indexOf('#') > -1) {
      // Token is an ID selector
      var bits = token.split('#');
      var tagName = bits[0];
      var id = bits[1];
      var element = document.getElementById(id);
      if (tagName && element.nodeName.toLowerCase() != tagName) {
        // tag with that ID not found, return false
        return new Array();
      }
      // Set currentContext to contain just this element
      currentContext = new Array(element);
      continue; // Skip to next token
    }
    if (token.indexOf('.') > -1) {
      // Token contains a class selector
      var bits = token.split('.');
      var tagName = bits[0];
      var className = bits[1];
      if (!tagName) {
        tagName = '*';
      }
      // Get elements matching tag, filter them for class selector
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (found[k].className && found[k].className.match(new RegExp('\\b'+className+'\\b'))) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      continue; // Skip to next token
    }
    // Code to deal with attribute selectors
    if (token.match(/^(\w*)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/)) {
      var tagName = RegExp.$1;
      var attrName = RegExp.$2;
      var attrOperator = RegExp.$3;
      var attrValue = RegExp.$4;
      if (!tagName) {
        tagName = '*';
      }
      // Grab all of the tagName elements within current context
      var found = new Array;
      var foundCount = 0;
      for (var h = 0; h < currentContext.length; h++) {
        var elements;
        if (tagName == '*') {
            elements = getAllChildren(currentContext[h]);
        } else {
            elements = currentContext[h].getElementsByTagName(tagName);
        }
        for (var j = 0; j < elements.length; j++) {
          found[foundCount++] = elements[j];
        }
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      var checkFunction; // This function will be used to filter the elements
      switch (attrOperator) {
        case '=': // Equality
          checkFunction = function(e) { return (e.getAttribute(attrName) == attrValue); };
          break;
        case '~': // Match one of space seperated words 
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('\\b'+attrValue+'\\b'))); };
          break;
        case '|': // Match start with value followed by optional hyphen
          checkFunction = function(e) { return (e.getAttribute(attrName).match(new RegExp('^'+attrValue+'-?'))); };
          break;
        case '^': // Match starts with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) == 0); };
          break;
        case '$': // Match ends with value - fails with "Warning" in Opera 7
          checkFunction = function(e) { return (e.getAttribute(attrName).lastIndexOf(attrValue) == e.getAttribute(attrName).length - attrValue.length); };
          break;
        case '*': // Match ends with value
          checkFunction = function(e) { return (e.getAttribute(attrName).indexOf(attrValue) > -1); };
          break;
        default :
          // Just test for existence of attribute
          checkFunction = function(e) { return e.getAttribute(attrName); };
      }
      currentContext = new Array;
      var currentContextIndex = 0;
      for (var k = 0; k < found.length; k++) {
        if (checkFunction(found[k])) {
          currentContext[currentContextIndex++] = found[k];
        }
      }
      // alert('Attribute Selector: '+tagName+' '+attrName+' '+attrOperator+' '+attrValue);
      continue; // Skip to next token
    }
    
    if (!currentContext[0]){
    	return;
    }
    
    // If we get here, token is JUST an element (not a class or ID selector)
    tagName = token;
    var found = new Array;
    var foundCount = 0;
    for (var h = 0; h < currentContext.length; h++) {
      var elements = currentContext[h].getElementsByTagName(tagName);
      for (var j = 0; j < elements.length; j++) {
        found[foundCount++] = elements[j];
      }
    }
    currentContext = found;
  }
  return currentContext;
}

/* That revolting regular expression explained 
/^(\w+)\[(\w+)([=~\|\^\$\*]?)=?"?([^\]"]*)"?\]$/
  \---/  \---/\-------------/    \-------/
    |      |         |               |
    |      |         |           The value
    |      |    ~,|,^,$,* or =
    |   Attribute 
   Tag
*/
/*--------------------------------------------------------------------------*/
///shared/client_scripts/trimpath/template.js
/*--------------------------------------------------------------------------*/

if(typeof(TrimPath)=='undefined')
TrimPath={};(function(){if(TrimPath.evalEx==null)
TrimPath.evalEx=function(src){return eval(src);};var UNDEFINED;if(Array.prototype.pop==null)
Array.prototype.pop=function(){if(this.length===0){return UNDEFINED;}
return this[--this.length];};if(Array.prototype.push==null)
Array.prototype.push=function(){for(var i=0;i<arguments.length;++i){this[this.length]=arguments[i];}
return this.length;};TrimPath.parseTemplate=function(tmplContent,optTmplName,optEtc){if(optEtc==null)
optEtc=TrimPath.parseTemplate_etc;var funcSrc=parse(tmplContent,optTmplName,optEtc);var func=TrimPath.evalEx(funcSrc,optTmplName,1);if(func!=null)
return new optEtc.Template(optTmplName,tmplContent,funcSrc,func,optEtc);return null;}
var exceptionDetails=function(e){return(e.toString())+";\n "+
(e.message)+";\n "+
(e.name)+";\n "+
(e.stack||'no stack trace')+";\n "+
(e.description||'no further description')+";\n "+
(e.fileName||'no file name')+";\n "+
(e.lineNumber||'no line number');}
try{String.prototype.process=function(context,optFlags){var template=TrimPath.parseTemplate(this,null);if(template!=null)
return template.process(context,optFlags);return this;}}catch(e){}
TrimPath.parseTemplate_etc={};TrimPath.parseTemplate_etc.statementTag="forelse|for|if|elseif|else|var|macro";TrimPath.parseTemplate_etc.statementDef={"if":{delta:1,prefix:"if (",suffix:") {",paramMin:1},"else":{delta:0,prefix:"} else {"},"elseif":{delta:0,prefix:"} else if (",suffix:") {",paramDefault:"true"},"/if":{delta:-1,prefix:"}"},"for":{delta:1,paramMin:3,prefixFunc:function(stmtParts,state,tmplName,etc){if(stmtParts[2]!="in")
throw new etc.ParseError(tmplName,state.line,"bad for loop statement: "+stmtParts.join(' '));var iterVar=stmtParts[1];var listVar="__LIST__"+iterVar;return["var ",listVar," = ",stmtParts[3],";","var __LENGTH_STACK__;","if (typeof(__LENGTH_STACK__) == 'undefined' || !__LENGTH_STACK__.length) __LENGTH_STACK__ = new Array();","__LENGTH_STACK__[__LENGTH_STACK__.length] = 0;","if ((",listVar,") != null) { ","var ",iterVar,"_ct = 0;","for (var ",iterVar,"_index in ",listVar,") { ",iterVar,"_ct++;","if (typeof(",listVar,"[",iterVar,"_index]) == 'function') {continue;}","__LENGTH_STACK__[__LENGTH_STACK__.length - 1]++;","var ",iterVar," = ",listVar,"[",iterVar,"_index];"].join("");}},"forelse":{delta:0,prefix:"} } if (__LENGTH_STACK__[__LENGTH_STACK__.length - 1] == 0) { if (",suffix:") {",paramDefault:"true"},"/for":{delta:-1,prefix:"} }; delete __LENGTH_STACK__[__LENGTH_STACK__.length - 1];"},"var":{delta:0,prefix:"var ",suffix:";"},"macro":{delta:1,prefixFunc:function(stmtParts,state,tmplName,etc){var macroName=stmtParts[1].split('(')[0];return["var ",macroName," = function",stmtParts.slice(1).join(' ').substring(macroName.length),"{ var _OUT_arr = []; var _OUT = { write: function(m) { if (m) _OUT_arr.push(m); } }; "].join('');}},"/macro":{delta:-1,prefix:" return _OUT_arr.join(''); };"}}
TrimPath.parseTemplate_etc.modifierDef={"eat":function(v){return"";},"escape":function(s){return String(s).replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;");},"capitalize":function(s){return String(s).toUpperCase();},"default":function(s,d){return s!=null?s:d;}}
TrimPath.parseTemplate_etc.modifierDef.h=TrimPath.parseTemplate_etc.modifierDef.escape;TrimPath.parseTemplate_etc.Template=function(tmplName,tmplContent,funcSrc,func,etc){this.process=function(context,flags){if(context==null)
context={};if(context._MODIFIERS==null)
context._MODIFIERS={};if(context.defined==null)
context.defined=function(str){return(context[str]!=undefined);};for(var k in etc.modifierDef){if(context._MODIFIERS[k]==null)
context._MODIFIERS[k]=etc.modifierDef[k];}
if(flags==null)
flags={};var resultArr=[];var resultOut={write:function(m){resultArr.push(m);}};try{func(resultOut,context,flags);}catch(e){if(flags.throwExceptions==true)
throw e;var result=new String(resultArr.join("")+"[ERROR: template: <pre>"+exceptionDetails(e)+"</pre>]");result["exception"]=e;return result;}
return resultArr.join("");}
this.name=tmplName;this.source=tmplContent;this.sourceFunc=funcSrc;this.toString=function(){return"TrimPath.Template ["+tmplName+"]";}}
TrimPath.parseTemplate_etc.ParseError=function(name,line,message){this.name=name;this.line=line;this.message=message;}
TrimPath.parseTemplate_etc.ParseError.prototype.toString=function(){return("TrimPath template ParseError in "+this.name+": line "+this.line+", "+this.message);}
var parse=function(body,tmplName,etc){body=cleanWhiteSpace(body);var funcText=["var TrimPath_Template_TEMP = function(_OUT, _CONTEXT, _FLAGS) { with (_CONTEXT) {"];var state={stack:[],line:1};var endStmtPrev=-1;while(endStmtPrev+1<body.length){var begStmt=endStmtPrev;begStmt=body.indexOf("{",begStmt+1);while(begStmt>=0){var endStmt=body.indexOf('}',begStmt+1);var stmt=body.substring(begStmt,endStmt);var blockrx=stmt.match(/^\{(cdata|minify|eval)/);if(blockrx){var blockType=blockrx[1];var blockMarkerBeg=begStmt+blockType.length+1;var blockMarkerEnd=body.indexOf('}',blockMarkerBeg);if(blockMarkerEnd>=0){var blockMarker;if(blockMarkerEnd-blockMarkerBeg<=0){blockMarker="{/"+blockType+"}";}else{blockMarker=body.substring(blockMarkerBeg+1,blockMarkerEnd);}
var blockEnd=body.indexOf(blockMarker,blockMarkerEnd+1);if(blockEnd>=0){emitSectionText(body.substring(endStmtPrev+1,begStmt),funcText);var blockText=body.substring(blockMarkerEnd+1,blockEnd);if(blockType=='cdata'){emitText(blockText,funcText);}else if(blockType=='minify'){emitText(scrubWhiteSpace(blockText),funcText);}else if(blockType=='eval'){if(blockText!=null&&blockText.length>0)
funcText.push('_OUT.write( (function() { '+blockText+' })() );');}
begStmt=endStmtPrev=blockEnd+blockMarker.length-1;}}}else if(body.charAt(begStmt-1)!='$'&&body.charAt(begStmt-1)!='\\'){var offset=(body.charAt(begStmt+1)=='/'?2:1);if(body.substring(begStmt+offset,begStmt+10+offset).search(TrimPath.parseTemplate_etc.statementTag)==0)
break;}
begStmt=body.indexOf("{",begStmt+1);}
if(begStmt<0)
break;var endStmt=body.indexOf("}",begStmt+1);if(endStmt<0)
break;emitSectionText(body.substring(endStmtPrev+1,begStmt),funcText);emitStatement(body.substring(begStmt,endStmt+1),state,funcText,tmplName,etc);endStmtPrev=endStmt;}
emitSectionText(body.substring(endStmtPrev+1),funcText);if(state.stack.length!=0)
throw new etc.ParseError(tmplName,state.line,"unclosed, unmatched statement(s): "+state.stack.join(","));funcText.push("}}; TrimPath_Template_TEMP");return funcText.join("");}
var emitStatement=function(stmtStr,state,funcText,tmplName,etc){var parts=stmtStr.slice(1,-1).split(' ');var stmt=etc.statementDef[parts[0]];if(stmt==null){emitSectionText(stmtStr,funcText);return;}
if(stmt.delta<0){if(state.stack.length<=0)
throw new etc.ParseError(tmplName,state.line,"close tag does not match any previous statement: "+stmtStr);state.stack.pop();}
if(stmt.delta>0)
state.stack.push(stmtStr);if(stmt.paramMin!=null&&stmt.paramMin>=parts.length)
throw new etc.ParseError(tmplName,state.line,"statement needs more parameters: "+stmtStr);if(stmt.prefixFunc!=null)
funcText.push(stmt.prefixFunc(parts,state,tmplName,etc));else
funcText.push(stmt.prefix);if(stmt.suffix!=null){if(parts.length<=1){if(stmt.paramDefault!=null)
funcText.push(stmt.paramDefault);}else{for(var i=1;i<parts.length;i++){if(i>1)
funcText.push(' ');funcText.push(parts[i]);}}
funcText.push(stmt.suffix);}}
var emitSectionText=function(text,funcText){if(text.length<=0)
return;var nlPrefix=0;var nlSuffix=text.length-1;while(nlPrefix<text.length&&(text.charAt(nlPrefix)=='\n'))
nlPrefix++;while(nlSuffix>=0&&(text.charAt(nlSuffix)==' '||text.charAt(nlSuffix)=='\t'))
nlSuffix--;if(nlSuffix<nlPrefix)
nlSuffix=nlPrefix;if(nlPrefix>0){funcText.push('if (_FLAGS.keepWhitespace == true) _OUT.write("');var s=text.substring(0,nlPrefix).replace('\n','\\n');if(s.charAt(s.length-1)=='\n')
s=s.substring(0,s.length-1);funcText.push(s);funcText.push('");');}
var lines=text.substring(nlPrefix,nlSuffix+1).split('\n');for(var i=0;i<lines.length;i++){emitSectionTextLine(lines[i],funcText);if(i<lines.length-1)
funcText.push('_OUT.write("\\n");\n');}
if(nlSuffix+1<text.length){funcText.push('if (_FLAGS.keepWhitespace == true) _OUT.write("');var s=text.substring(nlSuffix+1).replace('\n','\\n');if(s.charAt(s.length-1)=='\n')
s=s.substring(0,s.length-1);funcText.push(s);funcText.push('");');}}
var emitSectionTextLine=function(line,funcText){var endMarkPrev='}';var endExprPrev=-1;while(endExprPrev+endMarkPrev.length<line.length){var begMark="${",endMark="}";var begExpr=line.indexOf(begMark,endExprPrev+endMarkPrev.length);if(begExpr<0)
break;if(line.charAt(begExpr+2)=='%'){begMark="${%";endMark="%}";}
var endExpr=line.indexOf(endMark,begExpr+begMark.length);if(endExpr<0)
break;emitText(line.substring(endExprPrev+endMarkPrev.length,begExpr),funcText);var exprArr=line.substring(begExpr+begMark.length,endExpr).replace(/\|\|/g,"#@@#").split('|');for(var k in exprArr){if(exprArr[k].replace)
exprArr[k]=exprArr[k].replace(/#@@#/g,'||');}
funcText.push('_OUT.write(');emitExpression(exprArr,exprArr.length-1,funcText);funcText.push(');');endExprPrev=endExpr;endMarkPrev=endMark;}
emitText(line.substring(endExprPrev+endMarkPrev.length),funcText);}
var emitText=function(text,funcText){if(text==null||text.length<=0)
return;text=text.replace(/\\/g,'\\\\');text=text.replace(/\n/g,'\\n');text=text.replace(/"/g,'\\"');funcText.push('_OUT.write("');funcText.push(text);funcText.push('");');}
var emitExpression=function(exprArr,index,funcText){var expr=exprArr[index];if(index<=0){funcText.push(expr);return;}
var parts=expr.split(':');funcText.push('_MODIFIERS["');funcText.push(parts[0]);funcText.push('"](');emitExpression(exprArr,index-1,funcText);if(parts.length>1){funcText.push(',');funcText.push(parts[1]);}
funcText.push(')');}
var cleanWhiteSpace=function(result){result=result.replace(/\t/g,"    ");result=result.replace(/\r\n/g,"\n");result=result.replace(/\r/g,"\n");result=result.replace(/^(\s*\S*(\s+\S+)*)\s*$/,'$1');return result;}
var scrubWhiteSpace=function(result){result=result.replace(/^\s+/g,"");result=result.replace(/\s+$/g,"");result=result.replace(/\s+/g," ");result=result.replace(/^(\s*\S*(\s+\S+)*)\s*$/,'$1');return result;}
TrimPath.parseDOMTemplate=function(elementId,optDocument,optEtc){if(optDocument==null)
optDocument=document;var element=optDocument.getElementById(elementId);var content=element.value;if(content==null)
content=element.innerHTML;content=content.replace(/&lt;/g,"<").replace(/&gt;/g,">");return TrimPath.parseTemplate(content,elementId,optEtc);}
TrimPath.processDOMTemplate=function(elementId,context,optFlags,optDocument,optEtc){return TrimPath.parseDOMTemplate(elementId,optDocument,optEtc).process(context,optFlags);}})();
/*--------------------------------------------------------------------------*/
///shared/client_scripts/jstween/Tween.js
/*--------------------------------------------------------------------------*/
/**********************************************************************
TERMS OF USE - EASING EQUATIONS
Open source under the BSD License.
Copyright (c) 2001 Robert Penner
JavaScript version copyright (C) 2006 by Philippe Maegerman
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

   * Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
   * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
   * Neither the name of the author nor the names of contributors may
be used to endorse or promote products derived from this software
without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*****************************************/
function Delegate() {}
Delegate.create = function (o, f) {
	var a = new Array() ;
	var l = arguments.length ;
	for(var i = 2 ; i < l ; i++) a[i - 2] = arguments[i] ;
	return function() {
		var aP = [].concat(arguments, a) ;
		f.apply(o, aP);
	}
}

Tween = function(obj, prop, func, begin, finish, duration, suffixe){
	this.init(obj, prop, func, begin, finish, duration, suffixe)
}
var t = Tween.prototype;

t.obj = new Object();
t.prop='';
t.func = function (t, b, c, d) { return c*t/d + b; };
t.begin = 0;
t.change = 0;
t.prevTime = 0;
t.prevPos = 0;
t.looping = false;
t._duration = 0;
t._time = 0;
t._pos = 0;
t._position = 0;
t._startTime = 0;
t._finish = 0;
t.name = '';
t.suffixe = '';
t._listeners = new Array();	
t.setTime = function(t){
	this.prevTime = this._time;
	if (t > this.getDuration()) {
		if (this.looping) {
			this.rewind (t - this._duration);
			this.update();
			this.broadcastMessage('onMotionLooped',{target:this,type:'onMotionLooped'});
		} else {
			this._time = this._duration;
			this.update();
			this.stop();
			this.broadcastMessage('onMotionFinished',{target:this,type:'onMotionFinished'});
		}
	} else if (t < 0) {
		this.rewind();
		this.update();
	} else {
		this._time = t;
		this.update();
	}
}
t.getTime = function(){
	return this._time;
}
t.setDuration = function(d){
	this._duration = (d == null || d <= 0) ? 100000 : d;
}
t.getDuration = function(){
	return this._duration;
}
t.setPosition = function(p){
	this.prevPos = this._pos;
	var a = this.suffixe != '' ? this.suffixe : '';
	this.obj[this.prop] = Math.round(p) + a;
	this._pos = p;
	this.broadcastMessage('onMotionChanged',{target:this,type:'onMotionChanged'});
}
t.getPosition = function(t){
	if (t == undefined) t = this._time;
	return this.func(t, this.begin, this.change, this._duration);
};
t.setFinish = function(f){
	this.change = f - this.begin;
};
t.geFinish = function(){
	return this.begin + this.change;
};
t.init = function(obj, prop, func, begin, finish, duration, suffixe){
	if (!arguments.length) return;
	this._listeners = new Array();
	this.addListener(this);
	if(suffixe) this.suffixe = suffixe;
	this.obj = obj;
	this.prop = prop;
	this.begin = begin;
	this._pos = begin;
	this.setDuration(duration);
	if (func!=null && func!='') {
		this.func = func;
	}
	this.setFinish(finish);
}
t.start = function(){
	this.rewind();
	this.startEnterFrame();
	this.broadcastMessage('onMotionStarted',{target:this,type:'onMotionStarted'});
	//alert('in');
}
t.rewind = function(t){
	this.stop();
	this._time = (t == undefined) ? 0 : t;
	this.fixTime();
	this.update();
}
t.fforward = function(){
	this._time = this._duration;
	this.fixTime();
	this.update();
}
t.update = function(){
	this.setPosition(this.getPosition(this._time));
	}
t.startEnterFrame = function(){
	this.stopEnterFrame();
	this.isPlaying = true;
	this.onEnterFrame();
}
t.onEnterFrame = function(){
	if(this.isPlaying) {
		this.nextFrame();
		setTimeout(Delegate.create(this, this.onEnterFrame), 0);
	}
}
t.nextFrame = function(){
	this.setTime((this.getTimer() - this._startTime) / 1000);
	}
t.stop = function(){
	this.stopEnterFrame();
	this.broadcastMessage('onMotionStopped',{target:this,type:'onMotionStopped'});
}
t.stopEnterFrame = function(){
	this.isPlaying = false;
}

t.continueTo = function(finish, duration){
	this.begin = this._pos;
	this.setFinish(finish);
	if (this._duration != undefined)
		this.setDuration(duration);
	this.start();
}
t.resume = function(){
	this.fixTime();
	this.startEnterFrame();
	this.broadcastMessage('onMotionResumed',{target:this,type:'onMotionResumed'});
}
t.yoyo = function (){
	this.continueTo(this.begin,this._time);
}

t.addListener = function(o){
	this.removeListener (o);
	return this._listeners.push(o);
}
t.removeListener = function(o){
	var a = this._listeners;	
	var i = a.length;
	while (i--) {
		if (a[i] == o) {
			a.splice (i, 1);
			return true;
		}
	}
	return false;
}
t.broadcastMessage = function(){
	var arr = new Array();
	for(var i = 0; i < arguments.length; i++){
		arr.push(arguments[i])
	}
	var e = arr.shift();
	var a = this._listeners;
	var l = a.length;
	for (var i=0; i<l; i++){
		if(a[i][e])
		a[i][e].apply(a[i], arr);
	}
}
t.fixTime = function(){
	this._startTime = this.getTimer() - this._time * 1000;
}
t.getTimer = function(){
	return new Date().getTime() - this._time;
}
Tween.backEaseIn = function(t,b,c,d,a,p){
	if (s == undefined) var s = 1.70158;
	return c*(t/=d)*t*((s+1)*t - s) + b;
}
Tween.backEaseOut = function(t,b,c,d,a,p){
	if (s == undefined) var s = 1.70158;
	return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
}
Tween.backEaseInOut = function(t,b,c,d,a,p){
	if (s == undefined) var s = 1.70158; 
	if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b;
	return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
}
Tween.elasticEaseIn = function(t,b,c,d,a,p){
		if (t==0) return b;  
		if ((t/=d)==1) return b+c;  
		if (!p) p=d*.3;
		if (!a || a < Math.abs(c)) {
			a=c; var s=p/4;
		}
		else 
			var s = p/(2*Math.PI) * Math.asin (c/a);
		
		return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
	
}
Tween.elasticEaseOut = function (t,b,c,d,a,p){
		if (t==0) return b;  if ((t/=d)==1) return b+c;  if (!p) p=d*.3;
		if (!a || a < Math.abs(c)) { a=c; var s=p/4; }
		else var s = p/(2*Math.PI) * Math.asin (c/a);
		return (a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b);
	}
Tween.elasticEaseInOut = function (t,b,c,d,a,p){
	if (t==0) return b;  if ((t/=d/2)==2) return b+c;  if (!p) var p=d*(.3*1.5);
	if (!a || a < Math.abs(c)) {var a=c; var s=p/4; }
	else var s = p/(2*Math.PI) * Math.asin (c/a);
	if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b;
	return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b;
}

Tween.bounceEaseOut = function(t,b,c,d){
	if ((t/=d) < (1/2.75)) {
		return c*(7.5625*t*t) + b;
	} else if (t < (2/2.75)) {
		return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
	} else if (t < (2.5/2.75)) {
		return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
	} else {
		return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
	}
}
Tween.bounceEaseIn = function(t,b,c,d){
	return c - Tween.bounceEaseOut (d-t, 0, c, d) + b;
	}
Tween.bounceEaseInOut = function(t,b,c,d){
	if (t < d/2) return Tween.bounceEaseIn (t*2, 0, c, d) * .5 + b;
	else return Tween.bounceEaseOut (t*2-d, 0, c, d) * .5 + c*.5 + b;
	}

Tween.strongEaseInOut = function(t,b,c,d){
	return c*(t/=d)*t*t*t*t + b;
	}

Tween.regularEaseIn = function(t,b,c,d){
	return c*(t/=d)*t + b;
	}
Tween.regularEaseOut = function(t,b,c,d){
	return -c *(t/=d)*(t-2) + b;
	}

Tween.regularEaseInOut = function(t,b,c,d){
	if ((t/=d/2) < 1) return c/2*t*t + b;
	return -c/2 * ((--t)*(t-2) - 1) + b;
	}
Tween.strongEaseIn = function(t,b,c,d){
	return c*(t/=d)*t*t*t*t + b;
	}
Tween.strongEaseOut = function(t,b,c,d){
	return c*((t=t/d-1)*t*t*t*t + 1) + b;
	}

Tween.strongEaseInOut = function(t,b,c,d){
	if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b;
	return c/2*((t-=2)*t*t*t*t + 2) + b;
	}
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cambrient/main.js
/*--------------------------------------------------------------------------*/
/**
  * CCS Javascript library 
 */
if (!window.cambrient) {
    var cambrient = {};
    cambrient.contextPath = "/";
}

// check for required libraries: prototype, Trimpath Template, Tween
if (!window.$ || !window.$$ || !window.Ajax) {
   if (!skip) {
    alert('Please load the prototype library');
   }
}

if (!window.Tween) {
    alert('Please load the JS Tween library');
}

if (!window.TrimPath || !window.TrimPath.parseTemplate) {
    alert('Please load the Trimpath Template library');
}

if (!window.loadScript) {
    // load the ccs utils javascript
   var head = document.getElementsByTagName("head")[0];
   script = document.createElement('script');
   script.type = 'text/javascript';
   script.src = ccs.contextPath + "/shared/client_scripts/utils.js";
   head.appendChild(script);                     
}


/*--------------------------------------------------------------------------*/
///shared/client_scripts/ccs/main.js
/*--------------------------------------------------------------------------*/
/**
 * This class will load the Cambrient javascript library and configure it for use with CCS
 */

cambrient.contextPath = ccs.contextPath;
//cambrient.sessionManager.setExtenderUrl('/shared/client_scripts/ccs/session_extender.json');
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cambrient/util.js
/*--------------------------------------------------------------------------*/
cambrient.fragments = {}; // cache for fragments

// private function to set fragments
cambrient._setFragment = function(element, fragment, chainFunction, appendFragment) {
    // unescape text areas
   fragment = fragment.replace(/text_area/gi, "textarea");

   if (element != null) {
      if (appendFragment) element.innerHTML += fragment;
      else element.innerHTML = fragment;
   }
   
   if (chainFunction != null && isFunction(chainFunction)) {
      if (element == null) chainFunction(fragment);
      else chainFunction(element, fragment); 
   }
}

/**
 * Load a fragment using Ajax. A chainFunction can be passed, which will get called after the fragment loads successfully.
 * The fragments must be stored in a "/fragments" sub-directory
 */
cambrient.loadFragment = function(elementId, fragment, chainFunction, appendFragment) {
   var element = null;
   if (!isObject(elementId)) {
      element = document.getElementById(elementId);
   }

   if (cambrient.fragments[fragment] == null) {
      cambrient.ajax.request(
         fragment + '.html',  
         function(reply) {
            cambrient.fragments[fragment] = reply.responseText;
            cambrient._setFragment(element, cambrient.fragments[fragment], chainFunction, appendFragment);
         }
      );
   } else {
      cambrient._setFragment(element, cambrient.fragments[fragment], chainFunction, appendFragment);
   }

}

// Loads a fragment into a variable rather than an element
cambrient.loadFragmentVar = function(fragment, chainFunction, appendFragment) {
    return cambrient.loadFragment(null, fragment, chainFunction, appendFragment);
}

/**
 * Append a fragment using Ajax. A chainFunction can be passed, which will get called after the fragment loads successfully.
 * The fragments must be stored in a "/fragments" sub-directory
 */
cambrient.appendFragment = function(elementId, fragment, chainFunction){
   cambrient.loadFragment(elementId, fragment, chainFunction, true);
}

/**
 * Takes a string template and processes it using the provided data, with the Trimpath Template engine.
 */
cambrient.processTemplate = function(templateString, data) {
   try {
      var tpl = TrimPath.parseTemplate(templateString);
      return tpl.process(data);
   } catch (e) {
      cambrient.userMessaging.error(e);
   }
}

/**
 * Converts the ajax reply to a data object, and checks for errors.
 * @param {Object} ajaxReply
 */
cambrient.getData = function(ajaxReply) {
   try {
      var data = ajaxReply.responseText.evalJSON() ;
      if (data.error) {
         throw data.message;
      }
      
      return data;
   } catch (e) {
      cambrient.userMessaging.error(e);
   }
   
   return null;
}

cambrient.unescapeHTML = function(html) {
    if (navigator.userAgent.toLowerCase().indexOf("chrome") == -1) {
        var htmlNode = document.createElement("DIV");
        htmlNode.innerHTML = html;
        if (htmlNode.innerText) return htmlNode.innerText; // IE
        return htmlNode.textContent;
        // FF
    } else {
        return html;
        //Chrome
    }
}
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cambrient/ajax.js
/*--------------------------------------------------------------------------*/
/**
 * Wrapper for Ajax calls. Provides flood control. 
 */
cambrient.Ajax = function() {
   var REQUEST_PERIOD_MS = 100;           // How often to make ajax requests
   var MAX_SIMULTANEOUS_REQUESTS = 5;     // Maximum simultaenous ajax requests (remember that comet uses up 1)
   
   var self;                              // pointer to instance of this class
   var recentRequests = new Array();
   var requestQueue = new Array();
   var simultaneousRequests = 0;

   function constructorFn() {
      self = this;
      self.processRequests();
   }

   // Make ajax request   
   constructorFn.prototype.processRequests = function() {
       setTimeout(self.processRequests, REQUEST_PERIOD_MS);
       
       if (simultaneousRequests >= MAX_SIMULTANEOUS_REQUESTS) return;
       if (requestQueue.length == 0) return;
       
       var requestObj = requestQueue.shift();
       if (requestObj.successFunction == null) {
          requestObj.successFunction = function(reply) {
               if (element != null) {
                  element.innerHTML = reply.responseText;
               } else {
                  cambrient[elementId] = reply.responseText;
               }
               
               if (requestObj.chainFunction != null && isFunction(requestObj.chainFunction)) {
                  requestObj.chainFunction.call(reply);
               }
            }
       }

       if (requestObj.errorFunction == null) {
         requestObj.errorFunction = function(reply) {
            cambrient.userMessaging.error('ERROR!! ' + reply);
         }
       }
   
       simultaneousRequests++; 
       if (requestObj.post) {
           new Ajax.Request(cambrient.contextPath + requestObj.url,  {
        	   method: "post",
        	   parameters: requestObj.dataObj,        	   
               onSuccess: function(reply) {
                  cambrient.sessionManager.serverPing(); // reset the session manager
                  simultaneousRequests--;
                  requestObj.successFunction(reply);
               },
               onFailure: function(reply) {
                  simultaneousRequests--;
                  requestObj.errorFunction(reply);
               }
          });
       } else {
           new Ajax.Request(cambrient.contextPath + requestObj.url,  {
               onSuccess: function(reply) {
                  cambrient.sessionManager.serverPing(); // reset the session manager
                  simultaneousRequests--;
                  requestObj.successFunction(reply);
               },
               onFailure: function(reply) {
                  simultaneousRequests--;
                  requestObj.errorFunction(reply);
               }
          });
       }
   }

   // provides flood control by checking if the url was recently requested
   constructorFn.prototype.recentlyRequested = function(url) {
      var idx = requestQueue.find(function(item) {
         if (item.url == url) return true;
         else return false;
      });
      
      if (idx >= 0) {
         return true;
      }
      
      return false;
   } 
   
   // Make ajax request using the POST method   
   constructorFn.prototype.requestPost = function(url, dataObj, successFunction, errorFunction, chainFunction) {
      if (!self.recentlyRequested(url)) {
         requestQueue.push({
            "url": url,
            "post": true,
            "dataObj": dataObj,
            "successFunction": successFunction,
            "errorFunction": errorFunction,
            "chainFunction": chainFunction
         });
      }
   }   
   
   // Make ajax request   
   constructorFn.prototype.request = function(url, successFunction, errorFunction, chainFunction) {
      if (!self.recentlyRequested(url)) {
         requestQueue.push({
            "url": url,
            "successFunction" : successFunction,
            "errorFunction" : errorFunction,
            "chainFunction" : chainFunction
         });
      }
   }
   
   return new constructorFn();
}

cambrient.ajax = new cambrient.Ajax();
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cambrient/user_messaging.js
/*--------------------------------------------------------------------------*/
/**
 * Class to manage a queue of messages to show the user in a message bar
 */
cambrient.UserMessaging = function() {
   var MESSAGE_BAR_HEIGHT = 40;
   var MESSAGE_BAR_BGCOLOR = 'ffff00';

   var self;                              // pointer to instance of this class
   var mb;                                // the message bar div
   var messageQueue = new Array();
   var messageBarOpen = false;
   var tOpen, tClose;                     // tweening animations for open and close

   function constructorFn() {
      self = this;
      registerOnLoad(self.init);      
   }

   // initialize
   constructorFn.prototype.init = function() {
      mb = $('message_bar');

      if (mb) {
         mb.style.display = 'none';
         mb.style.visibility = 'hidden';
         mb.style.zIndex = 1000;
         
         mb.onclick = function(evt) {
            self.closeBar();
         }
   
         // define opening animation
         tOpen = new Tween(mb.style, 'height', Tween.strongEaseOut, 0, 40, 1, 'px');
         tOpen.onMotionFinished = function() {
            var tFade = new ColorTween(mb.style, 'backgroundColor', Tween.bounceEaseOut, 'ffffff', MESSAGE_BAR_BGCOLOR, 3);
            tFade.start();
         }
   
         // define closing animation
         tClose = new Tween(mb.style, 'height', Tween.strongEaseOut, MESSAGE_BAR_HEIGHT, 0, 1, 'px');
         tClose.onMotionFinished = function() {
            mb.style.display = 'none';
            mb.style.visibility = 'hidden';
         }
      }
      
      self.processMessageQueue();
   }

   // Routinely checks for messages in the message queue and displays them
   constructorFn.prototype.processMessageQueue = function() {
      if (!messageBarOpen) {
         if (messageQueue.length > 0) {
            var msg = messageQueue.shift();
            
            if (mb) {
               if (msg.type == 'error') {
                  MESSAGE_BAR_BGCOLOR = 'ff0000';
               } else {
                  MESSAGE_BAR_BGCOLOR = 'ffff00';
               }
   
               // redefine the color tween in case the background color changed
               tOpen.onMotionFinished = function() {
                  var tFade = new ColorTween(mb.style, 'backgroundColor', Tween.bounceEaseOut, 'ffffff', MESSAGE_BAR_BGCOLOR, 3);
                  tFade.start();
               }
               
               mb.innerHTML = msg.message;
               self.openBar();            
            } else {
               alert("UNHANDLED MESSAGING" + msg.message);
            }
         }
      }
      
      setTimeout(self.processMessageQueue, 1000);
   }
   
   // Close the message bar
   constructorFn.prototype.closeBar = function() {
      tOpen.stop(); // if it's still running
      messageBarOpen = false;
      tClose.start();
   }

   // Open the message bar
   constructorFn.prototype.openBar = function() {
      tClose.stop();
      messageBarOpen = true;
      mb.style.backgroundColor = MESSAGE_BAR_BGCOLOR;            
      mb.style.height = 0; //MESSAGE_BAR_HEIGHT;
      mb.style.display = 'block';
      mb.style.visibility = 'visible';
      tOpen.start();
   }

   // adds a message to the message queue
   constructorFn.prototype.addMessage = function(msg) {
      var hasMsg = false;
      
      messageQueue.each(function(item) {
         if (item.message != null && item.message == msg.message) {
            hasMsg = true;
         }
      });
            
      if (!hasMsg) {
         messageQueue.push(msg);
      }
   }

   // Display informational message to user
   constructorFn.prototype.info = function(msg) {
      self.addMessage({
         "message": msg,
         "type": "info"
      });
   }

   // Display error message to user
   constructorFn.prototype.error = function(msg) {
      self.addMessage({
         "message": msg,
         "type": "error"
      });
   }

   // Display error message to user
   constructorFn.prototype.warning = function(msg) {
      self.addMessage({
         "message": msg,
         "type": "warning"
      });
   }

   // Display error message to user
   constructorFn.prototype.confirm = function(msg) {
      console.log('ERROR: ' + msg);
      self.addMessage({
         "message": msg,
         "type": "confirm"
      });
   }

   // Display debug message to developer
   constructorFn.prototype.debug = function(msg) {
      self.addMessage({
         "message": msg,
         "type": "debug"
      });
   }

   constructorFn.prototype.test = function() {
      cambrient.userMessaging.info("Hello world!");
      cambrient.userMessaging.info("Hello world!");
      cambrient.userMessaging.info("Hello world!");
      cambrient.userMessaging.error("ERROR: There was an unknown error trying to parse the error for display. Just kidding!");
      cambrient.userMessaging.info("Hello world 2!");
      cambrient.userMessaging.info("Hello world 2!");
      cambrient.userMessaging.info("Hello world 2!");
   }

   return new constructorFn();
}

cambrient.userMessaging = new cambrient.UserMessaging();
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cambrient/session_manager.js
/*--------------------------------------------------------------------------*/
/**
 * SessionManager class to maintain the session on the client side and monitor if the network goes down
 * To activate the session manager with session extender, you need to call setExtenderUrl() with the path
 * to the JSON server that will handle the session extension. The JSON server must just return the following JSON:
 *  {
 *      "session_extended": "true"
 *  }
 *  Optionally, it can also return the current date and time in a field called "time".
 */
cambrient.SessionManager = function() {
   var session_extender_url = null;
   
   var self;                              // pointer to instance of this class
   var KEEP_ALIVE_PERIOD_MS = 1000*60*15; // keep session alive every fifteen minutes
   var SERVER_TIMEOUT_MS = 1000*60*29;    // How long before the server communication is pronounced dead 
   var lastServerSighting = 0;            // last time we heard from the server

   function constructorFn() {
      self = this;
   }
   
   // Set the URL to the session extender JSON server (see module documentation above)
   constructorFn.prototype.setExtenderUrl = function(url) {
      session_extender_url = cambrient.contextPath + url;
      if (session_extender_url != null) setTimeout(self.keepAlive, KEEP_ALIVE_PERIOD_MS);
   }
   
   // Keep the session alive by making periodic requests to the server
   constructorFn.prototype.keepAlive = function() {
      if (session_extender_url == null) return; // the application needs to set this in order to activate the session manager
   
      var now = new Date();
      if (lastServerSighting == 0) {
         lastServerSighting = new Date().getTime();
      }
      
      if (now.getTime() - lastServerSighting > SERVER_TIMEOUT_MS) {
         // the connection to the server seems to have died. Warn the user
         cambrient.userMessaging.info('Have not heard from the server in ' + (SERVER_TIMEOUT_MS / (1000*60)) + ' minutes.');
      } 

      if (isFunction(session_extender_url.each)) {
        // array of session extender urls
        session_extender_url.each(function(url) {
            self.ajaxCall(url);
        })
      } else {
        self.ajaxCall(session_extender_url);
      }
      
      setTimeout(self.keepAlive, KEEP_ALIVE_PERIOD_MS);
   }

   // The Ajax call to keep the session alive
   constructorFn.prototype.ajaxCall = function(url) {
      // We do not use the ajax module here because we do not want to use up a connection in it's pool
      new Ajax.Request(
            session_extender_url,  {
            onSuccess: function(reply) {
               self.serverPing(reply);
            },
            onFailure: function(reply) {
               cambrient.userMessaging.error('ERROR!! ' + reply);
            }
         }
      );      
   }

   // Callback for when the server replies
   constructorFn.prototype.serverPing = function(reply) {
      lastServerSighting = new Date().getTime();
   }
      
   return new constructorFn();
}

cambrient.sessionManager = new cambrient.SessionManager();
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cambrient/client_data/main.js
/*--------------------------------------------------------------------------*/
/**
 * Main file to load all client-side data caches
 */
cambrient.client_data = {};

cambrient.client_data.Main = function() {
    var self;

   function constructorFn() {
        self = this;
   }

   // load up all the client data scripts. Provide an array of client data names and a path (excluding contextPath), e.g.
   // cambrient.client_data.initClientData('/shared/templates/js/modules/client_data', ['user_details', 'schemes']);
   constructorFn.prototype.initClientData = function(path, arrayClientDataNames) {
      arrayClientDataNames.each(function(scriptName) {   
         // Load the plugin script asynchronously
         loadScript(path + scriptName + ".js");
      });
   }

   // initialize the client data store module with queuing and callback chaining
   constructorFn.prototype.clearCache = function(){
      clientDataNames.each(function(cdName) {
         cambrient.client_data[cdName].clearCache();
      });
   }
   
   // initialize the client data store module with queuing and callback chaining
   constructorFn.prototype.init = function(cd) {
      if (cd) {
         cd.queue = {}; // buffer for requests to this client data
         cd.cache = {}; // cache so that requests are not repeated
         cd.callbacks = {}; // buffer of callbacks for thie client data
         
         // function to clear the cached data
         cd.clearCache = function(url, args) {
            if (!url) {
               cd.cache = {};
               return;
            }

            if (!args) args = [];
            var ajaxUrl = url + '?';
            args.each(function(arg){
               url += '&' + arg;
            });

            if (cd.cache[ajaxUrl] != null) {
               cd.cache[ajaxUrl] == null;
            }
         }

         
         cd.logData = function(data) {
            alert('text');
         }

         // function to handle getting data from the server with callback chaining and request queueing
         cd.getDataFromServer = function(url, args, callBack) {
            var ajaxUrl = url;
            if (args.length > 0) url += '?';
            args.each(function(arg){
               url += '&' + arg;
            });

            if (cd.callbacks[ajaxUrl] == null) cd.callbacks[ajaxUrl] = [];

            if (isFunction(callBack)) cd.callbacks[ajaxUrl].push(callBack);
            if (!args) args = [];


            if (cd.cache[ajaxUrl] != null) {
               // we have a cache of this data
               cd.callbacks[ajaxUrl].each(function(callBack) { callBack(cd.cache[ajaxUrl]); });
               cd.callbacks[ajaxUrl] = [];
               return;
            }
                  
            // check queue to see if current params are being processed to avoid duplicate calls
            if (cd.queue[ajaxUrl] != null) {
               // this request is being processed
               return;
            }
            cd.queue[ajaxUrl] = true;
            
            cambrient.ajax.request(
               ajaxUrl,
               function(reply) {
                  try {
                     // clear queue
                     cd.queue[ajaxUrl] = null;
                     
                     var data = cambrient.getData(reply);
                     cd.cache[ajaxUrl] = data;
                     
                     // call back each interested party
                     var actions = cambrient.getData(reply);
                     if (data) cd.callbacks[ajaxUrl].each(function(callBack) { callBack(data); });
                     cd.callbacks[ajaxUrl] = [];
                  } catch (e) {
                     cambrient.userMessaging.error(e);
                  }
               }
            );            
         }
      }
   }
   
   return new constructorFn();   
}

cambrient.client_data.main = new cambrient.client_data.Main();
/*--------------------------------------------------------------------------*/
///shared/content/user/js/user.js
/*--------------------------------------------------------------------------*/
declarePackage("ccs");

ccs.User = function() {
	var self;
	var called = false;
	var calling = false;
	var callbackFunctions = new Array();
	
	// constructor function
	function constructorFn() {
		self = this;
	}
	
	constructorFn.prototype.loadUserData = function(callbackFunction) {
		var originalArguments = arguments
				
		if (called) {
			callbackFunction.apply(this, originalArguments);
			return;
		}
		
		if (calling) {
			callbackFunctions.push({functionName: callbackFunction, arguments : originalArguments});
			return;
		}
		
		calling = true;
		
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/user/load_user_data.json",
		{
			method:'post',

			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
				
				ccs.user.isAnonymous = res.isAnonymous;
				ccs.user.userId = res.userId;
				ccs.user.isLoggedIn = res.loggedIntoCCS;
				ccs.user.emailAddress = res.emailAddress;
								
				callbackFunction.apply(this, originalArguments);
				called = true;
				calling = false;
				//loop through callblack function..and call them
				for (var i=0; i<callbackFunctions.length; i++) {
					callbackFunctions[i].functionName.apply(this, callbackFunctions[i].arguments);
				}
			},
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});
	}
	
	return new constructorFn();
}

ccs.user = new ccs.User();
/*--------------------------------------------------------------------------*/
///shared/client_scripts/ajax/scriptaculous/src/builder.js
/*--------------------------------------------------------------------------*/
// script.aculo.us builder.js v1.8.1, Thu Jan 03 22:07:12 -0500 2008

// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
//
// script.aculo.us is freely distributable under the terms of an MIT-style license.
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Builder = {
  NODEMAP: {
    AREA: 'map',
    CAPTION: 'table',
    COL: 'table',
    COLGROUP: 'table',
    LEGEND: 'fieldset',
    OPTGROUP: 'select',
    OPTION: 'select',
    PARAM: 'object',
    TBODY: 'table',
    TD: 'table',
    TFOOT: 'table',
    TH: 'table',
    THEAD: 'table',
    TR: 'table'
  },
  // note: For Firefox < 1.5, OPTION and OPTGROUP tags are currently broken,
  //       due to a Firefox bug
  node: function(elementName) {
    elementName = elementName.toUpperCase();
    
    // try innerHTML approach
    var parentTag = this.NODEMAP[elementName] || 'div';
    var parentElement = document.createElement(parentTag);
    try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
      parentElement.innerHTML = "<" + elementName + "></" + elementName + ">";
    } catch(e) {}
    var element = parentElement.firstChild || null;
      
    // see if browser added wrapping tags
    if(element && (element.tagName.toUpperCase() != elementName))
      element = element.getElementsByTagName(elementName)[0];
    
    // fallback to createElement approach
    if(!element) element = document.createElement(elementName);
    
    // abort if nothing could be created
    if(!element) return;

    // attributes (or text)
    if(arguments[1])
      if(this._isStringOrNumber(arguments[1]) ||
        (arguments[1] instanceof Array) ||
        arguments[1].tagName) {
          this._children(element, arguments[1]);
        } else {
          var attrs = this._attributes(arguments[1]);
          if(attrs.length) {
            try { // prevent IE "feature": http://dev.rubyonrails.org/ticket/2707
              parentElement.innerHTML = "<" +elementName + " " +
                attrs + "></" + elementName + ">";
            } catch(e) {}
            element = parentElement.firstChild || null;
            // workaround firefox 1.0.X bug
            if(!element) {
              element = document.createElement(elementName);
              for(attr in arguments[1]) 
                element[attr == 'class' ? 'className' : attr] = arguments[1][attr];
            }
            if(element.tagName.toUpperCase() != elementName)
              element = parentElement.getElementsByTagName(elementName)[0];
          }
        } 

    // text, or array of children
    if(arguments[2])
      this._children(element, arguments[2]);

     return element;
  },
  _text: function(text) {
     return document.createTextNode(text);
  },

  ATTR_MAP: {
    'className': 'class',
    'htmlFor': 'for'
  },

  _attributes: function(attributes) {
    var attrs = [];
    for(attribute in attributes)
      attrs.push((attribute in this.ATTR_MAP ? this.ATTR_MAP[attribute] : attribute) +
          '="' + attributes[attribute].toString().escapeHTML().gsub(/"/,'&quot;') + '"');
    return attrs.join(" ");
  },
  _children: function(element, children) {
    if(children.tagName) {
      element.appendChild(children);
      return;
    }
    if(typeof children=='object') { // array can hold nodes and text
      children.flatten().each( function(e) {
        if(typeof e=='object')
          element.appendChild(e)
        else
          if(Builder._isStringOrNumber(e))
            element.appendChild(Builder._text(e));
      });
    } else
      if(Builder._isStringOrNumber(children))
        element.appendChild(Builder._text(children));
  },
  _isStringOrNumber: function(param) {
    return(typeof param=='string' || typeof param=='number');
  },
  build: function(html) {
    var element = this.node('div');
    $(element).update(html.strip());
    return element.down();
  },
  dump: function(scope) { 
    if(typeof scope != 'object' && typeof scope != 'function') scope = window; //global scope 
  
    var tags = ("A ABBR ACRONYM ADDRESS APPLET AREA B BASE BASEFONT BDO BIG BLOCKQUOTE BODY " +
      "BR BUTTON CAPTION CENTER CITE CODE COL COLGROUP DD DEL DFN DIR DIV DL DT EM FIELDSET " +
      "FONT FORM FRAME FRAMESET H1 H2 H3 H4 H5 H6 HEAD HR HTML I IFRAME IMG INPUT INS ISINDEX "+
      "KBD LABEL LEGEND LI LINK MAP MENU META NOFRAMES NOSCRIPT OBJECT OL OPTGROUP OPTION P "+
      "PARAM PRE Q S SAMP SCRIPT SELECT SMALL SPAN STRIKE STRONG STYLE SUB SUP TABLE TBODY TD "+
      "TEXTAREA TFOOT TH THEAD TITLE TR TT U UL VAR").split(/\s+/);
  
    tags.each( function(tag){ 
      scope[tag] = function() { 
        return Builder.node.apply(Builder, [tag].concat($A(arguments)));  
      } 
    });
  }
}
/*--------------------------------------------------------------------------*/
///applications/picknpay/templates/js/sifr.js
/*--------------------------------------------------------------------------*/
/*	sIFR v2.0.7
	Copyright 2004 - 2008 Mark Wubben and Mike Davidson. Prior contributions by Shaun Inman and Tomas Jogin.
	
	This software is licensed under the CC-GNU LGPL <http://creativecommons.org/licenses/LGPL/2.1/>
*/

var hasFlash=function(){var a=6;if(navigator.appVersion.indexOf("MSIE")!=-1&&navigator.appVersion.indexOf("Windows")>-1){document.write('<script language="VBScript"\> \non error resume next \nhasFlash = (IsObject(CreateObject("ShockwaveFlash.ShockwaveFlash." & '+a+'))) \n</script\> \n');if(window.hasFlash!=null)return window.hasFlash}if(navigator.mimeTypes&&navigator.mimeTypes["application/x-shockwave-flash"]&&navigator.mimeTypes["application/x-shockwave-flash"].enabledPlugin){var b=(navigator.plugins["Shockwave Flash 2.0"]||navigator.plugins["Shockwave Flash"]).description;return parseInt(b.substr(b.indexOf(".")-2,2),10)>=a}return false}();String.prototype.normalize=function(){return this.replace(/\s+/g," ")};if(Array.prototype.push==null){Array.prototype.push=function(){var i=0,a=this.length,b=arguments.length;while(i<b){this[a++]=arguments[i++]}return this.length}}if(!Function.prototype.apply){Function.prototype.apply=function(a,b){var c=[];var d,e;if(!a)a=window;if(!b)b=[];for(var i=0;i<b.length;i++){c[i]="b["+i+"]"}e="a.__applyTemp__("+c.join(",")+");";a.__applyTemp__=this;d=eval(e);a.__applyTemp__=null;return d}}function named(a){return new named.Arguments(a)}named.Arguments=function(a){this.oArgs=a};named.Arguments.prototype.constructor=named.Arguments;named.extract=function(a,b){var c,d;var i=a.length;while(i--){d=a[i];if(d!=null&&d.constructor!=null&&d.constructor==named.Arguments){c=a[i].oArgs;break}}if(c==null)return;for(e in c)if(b[e]!=null)b[e](c[e]);return};var parseSelector=function(){var a=/^([^#.>`]*)(#|\.|\>|\`)(.+)$/;function r(s,t){var u=s.split(/\s*\,\s*/);var v=[];for(var i=0;i<u.length;i++)v=v.concat(b(u[i],t));return v}function b(c,d,e){c=c.normalize().replace(" ","`");var f=c.match(a);var g,h,i,j,k,n;var l=[];if(f==null)f=[c,c];if(f[1]=="")f[1]="*";if(e==null)e="`";if(d==null)d=document;switch(f[2]){case "#":k=f[3].match(a);if(k==null)k=[null,f[3]];g=document.getElementById(k[1]);if(g==null||(f[1]!="*"&&!o(g,f[1])))return l;if(k.length==2){l.push(g);return l}return b(k[3],g,k[2]);case ".":if(e!=">")h=m(d,f[1]);else h=d.childNodes;for(i=0,n=h.length;i<n;i++){g=h[i];if(g.nodeType!=1)continue;k=f[3].match(a);if(k!=null){if(g.className==null||g.className.match("(\\s|^)"+k[1]+"(\\s|$)")==null)continue;j=b(k[3],g,k[2]);l=l.concat(j)}else if(g.className!=null&&g.className.match("(\\s|^)"+f[3]+"(\\s|$)")!=null)l.push(g)}return l;case ">":if(e!=">")h=m(d,f[1]);else h=d.childNodes;for(i=0,n=h.length;i<n;i++){g=h[i];if(g.nodeType!=1)continue;if(!o(g,f[1]))continue;j=b(f[3],g,">");l=l.concat(j)}return l;case "`":h=m(d,f[1]);for(i=0,n=h.length;i<n;i++){g=h[i];j=b(f[3],g,"`");l=l.concat(j)}return l;default:if(e!=">")h=m(d,f[1]);else h=d.childNodes;for(i=0,n=h.length;i<n;i++){g=h[i];if(g.nodeType!=1)continue;if(!o(g,f[1]))continue;l.push(g)}return l}}function m(d,o){if(o=="*"&&d.all!=null)return d.all;return d.getElementsByTagName(o)}function o(p,q){return q=="*"?true:p.nodeName.toLowerCase().replace("html:", "")==q.toLowerCase()}return r}();var sIFR=function(){var a="http://www.w3.org/1999/xhtml";var b=false;var c=false;var d;var ah=[];var al=document;var ak=al.documentElement;var am=window;var au=al.addEventListener;var av=am.addEventListener;var f=function(){var g=navigator.userAgent.toLowerCase();var f={a:g.indexOf("applewebkit")>-1,b:g.indexOf("safari")>-1,c:navigator.product!=null&&navigator.product.toLowerCase().indexOf("konqueror")>-1,d:g.indexOf("opera")>-1,e:al.contentType!=null&&al.contentType.indexOf("xml")>-1,f:true,g:true,h:null,i:null,j:null,k:null};f.l=f.a||f.c;f.m=!f.a&&navigator.product!=null&&navigator.product.toLowerCase()=="gecko";if(f.m&&g.match(/.*gecko\/(\d{8}).*/))f.j=new Number(g.match(/.*gecko\/(\d{8}).*/)[1]);f.n=g.indexOf("msie")>-1&&!f.d&&!f.l&&!f.m;f.o=f.n&&g.match(/.*mac.*/)!=null;if(f.d&&g.match(/.*opera(\s|\/)(\d+\.\d+)/))f.i=new Number(g.match(/.*opera(\s|\/)(\d+\.\d+)/)[2]);if(f.n||(f.d&&f.i<7.6))f.g=false;if(f.a&&g.match(/.*applewebkit\/(\d+).*/))f.k=new Number(g.match(/.*applewebkit\/(\d+).*/)[1]);if(am.hasFlash&&(!f.n||f.o)){var aj=(navigator.plugins["Shockwave Flash 2.0"]||navigator.plugins["Shockwave Flash"]).description;f.h=parseInt(aj.substr(aj.indexOf(".")-2,2),10)}if(g.match(/.*(windows|mac).*/)==null||f.o||f.c||(f.d&&(g.match(/.*mac.*/)!=null||f.i<7.6))||(f.b&&f.h<7)||(!f.b&&f.a&&f.k<312)||(f.m&&f.j<20020523))f.f=false;if(!f.o&&!f.m&&al.createElementNS)try{al.createElementNS(a,"i").innerHTML=""}catch(e){f.e=true}f.p=f.c||(f.a&&f.k<312);return f}();function at(){return{bIsWebKit:f.a,bIsSafari:f.b,bIsKonq:f.c,bIsOpera:f.d,bIsXML:f.e,bHasTransparencySupport:f.f,bUseDOM:f.g,nFlashVersion:f.h,nOperaVersion:f.i,nGeckoBuildDate:f.j,nWebKitVersion:f.k,bIsKHTML:f.l,bIsGecko:f.m,bIsIE:f.n,bIsIEMac:f.o,bUseInnerHTMLHack:f.p}}if(am.hasFlash==false||!al.getElementsByTagName||!al.getElementById||(f.e&&(f.p||f.n)))return{UA:at()};function af(e){if((!k.bAutoInit&&(am.event||e)!=null)||!l(e))return;b=true;for(var i=0,h=ah.length;i<h;i++)j.apply(null,ah[i]);ah=[]}var k=af;function l(e){if(c==false||k.bIsDisabled==true||((f.e&&f.m||f.l)&&e==null&&b==false)||al.getElementsByTagName("body").length==0)return false;return true}function m(n){if(f.n)return n.replace(new RegExp("%\d{0}","g"),"%25");return n.replace(new RegExp("%(?!\d)","g"),"%25")}function as(p,q){return q=="*"?true:p.nodeName.toLowerCase().replace("html:", "")==q.toLowerCase()}function o(p,q,r,s,t){var u="";var v=p.firstChild;var w,x,y,z;if(s==null)s=0;if(t==null)t="";while(v){if(v.nodeType==3){z=v.nodeValue.replace("<","&lt;");switch(r){case "lower":u+=z.toLowerCase();break;case "upper":u+=z.toUpperCase();break;default:u+=z}}else if(v.nodeType==1){if(as(v,"a")&&!v.getAttribute("href")==false){if(v.getAttribute("target"))t+="&sifr_url_"+s+"_target="+v.getAttribute("target");t+="&sifr_url_"+s+"="+m(v.getAttribute("href")).replace(/&/g,"%26");u+='<a href="asfunction:_root.launchURL,'+s+'">';s++}else if(as(v,"br"))u+="<br/>";if(v.hasChildNodes()){y=o(v,null,r,s,t);u+=y.u;s=y.s;t=y.t}if(as(v,"a"))u+="</a>"}w=v;v=v.nextSibling;if(q!=null){x=w.parentNode.removeChild(w);q.appendChild(x)}}return{"u":u,"s":s,"t":t}}function A(B){if(al.createElementNS&&f.g)return al.createElementNS(a,B);return al.createElement(B)}function C(D,E,z){var p=A("param");p.setAttribute("name",E);p.setAttribute("value",z);D.appendChild(p)}function F(p,G){var H=p.className;if(H==null)H=G;else H=H.normalize()+(H==""?"":" ")+G;p.className=H}function aq(ar){var a=ak;if(k.bHideBrowserText==false)a=al.getElementsByTagName("body")[0];if((k.bHideBrowserText==false||ar)&&a)if(a.className==null||a.className.match(/\bsIFR\-hasFlash\b/)==null)F(a, "sIFR-hasFlash")}function j(I,J,K,L,M,N,O,P,Q,R,S,r,T){if(!l())return ah.push(arguments);aq();named.extract(arguments,{sSelector:function(ap){I=ap},sFlashSrc:function(ap){J=ap},sColor:function(ap){K=ap},sLinkColor:function(ap){L=ap},sHoverColor:function(ap){M=ap},sBgColor:function(ap){N=ap},nPaddingTop:function(ap){O=ap},nPaddingRight:function(ap){P=ap},nPaddingBottom:function(ap){Q=ap},nPaddingLeft:function(ap){R=ap},sFlashVars:function(ap){S=ap},sCase:function(ap){r=ap},sWmode:function(ap){T=ap}});var U=parseSelector(I);if(U.length==0)return false;if(S!=null)S="&"+S.normalize();else S="";if(K!=null)S+="&textcolor="+K;if(M!=null)S+="&hovercolor="+M;if(M!=null||L!=null)S+="&linkcolor="+(L||K);if(O==null)O=0;if(P==null)P=0;if(Q==null)Q=0;if(R==null)R=0;if(N==null)N="#FFFFFF";if(T=="transparent")if(!f.f)T="opaque";else N="transparent";if(T==null)T="";var p,V,W,X,Y,Z,aa,ab,ac;var ad=null;for(var i=0,h=U.length;i<h;i++){p=U[i];if(p.className!=null&&p.className.match(/\bsIFR\-replaced\b/)!=null)continue;V=p.offsetWidth-R-P;W=p.offsetHeight-O-Q;aa=A("span");aa.className="sIFR-alternate";ac=o(p,aa,r);Z="txt="+m(ac.u).replace(/\+/g,"%2B").replace(/&/g,"%26").replace(/\"/g, "%22").normalize() + S + "&w=" + V + "&h=" + W + ac.t;F(p,"sIFR-replaced");if(ad==null||!f.g){if(!f.g){if(!f.n)p.innerHTML=['<embed class="sIFR-flash" type="application/x-shockwave-flash" src="',J,'" quality="best" wmode="',T,'" bgcolor="',N,'" flashvars="',Z,'" width="',V,'" height="',W,'" sifr="true"></embed>'].join("");else p.innerHTML=['<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" sifr="true" width="',V,'" height="',W,'" class="sIFR-flash"><param name="movie" value="',J,'"></param><param name="flashvars" value="',Z,'"></param><param name="quality" value="best"></param><param name="wmode" value="',T,'"></param><param name="bgcolor" value="',N,'"></param> </object>'].join('')}else{if(f.d){ab=A("object");ab.setAttribute("data",J);C(ab,"quality","best");C(ab,"wmode",T);C(ab,"bgcolor",N)}else{ab=A("embed");ab.setAttribute("src",J);ab.setAttribute("quality","best");ab.setAttribute("flashvars",Z);ab.setAttribute("wmode",T);ab.setAttribute("bgcolor",N)}ab.setAttribute("sifr","true");ab.setAttribute("type","application/x-shockwave-flash");ab.className="sIFR-flash";if(!f.l||!f.e)ad=ab.cloneNode(true)}}else ab=ad.cloneNode(true);if(f.g){if(f.d)C(ab,"flashvars",Z);else ab.setAttribute("flashvars",Z);ab.setAttribute("width",V);ab.setAttribute("height",W);ab.style.width=V+"px";ab.style.height=W+"px";p.appendChild(ab)}p.appendChild(aa);if(f.p)p.innerHTML+=""}if(f.n&&k.bFixFragIdBug)setTimeout(function(){al.title=d},0)}function ai(){d=al.title}function ae(){if(k.bIsDisabled==true)return;c=true;if(k.bHideBrowserText)aq(true);if(am.attachEvent)am.attachEvent("onload",af);else if(!f.c&&(al.addEventListener||am.addEventListener)){if(f.a&&f.k>=132&&am.addEventListener)am.addEventListener("load",function(){setTimeout("sIFR({})",1)},false);else{if(al.addEventListener)al.addEventListener("load",af,false);if(am.addEventListener)am.addEventListener("load",af,false)}}else if(typeof am.onload=="function"){var ag=am.onload;am.onload=function(){ag();af()}}else am.onload=af;if(!f.n||am.location.hash=="")k.bFixFragIdBug=false;else ai()}k.UA=at();k.bAutoInit=true;k.bFixFragIdBug=true;k.replaceElement=j;k.updateDocumentTitle=ai;k.appendToClassName=F;k.setup=ae;k.debug=function(){aq(true)};k.debug.replaceNow=function(){ae();k()};k.bIsDisabled=false;k.bHideBrowserText=true;return k}();

if(typeof sIFR == "function" && !sIFR.UA.bIsIEMac && (!sIFR.UA.bIsWebKit || sIFR.UA.nWebKitVersion >= 100)){
	sIFR.replaceElement("h1.cachet_blue", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachet.swf", sWmode: "transparent", sColor: "#003767"}));
	sIFR.replaceElement("h1.cachet_bold_blue", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachetBold.swf", sWmode: "transparent", sColor: "#003767"}));
	sIFR.replaceElement("h1.cachet_orange", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachet.swf", sWmode: "transparent", sColor: "#F18E00"}));
	sIFR.replaceElement("h1.cachet_green", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachet.swf", sWmode: "transparent", sColor: "#91AF01"}));
	sIFR.replaceElement("h1.cachet_pink", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachet.swf", sWmode: "transparent", sColor: "#C60651"}));
	sIFR.replaceElement("h1.cachet_bold_pink", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachetBold.swf", sWmode: "transparent", sColor: "#C60651"}));
	sIFR.replaceElement("h1.cachet_white", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachet.swf", sWmode: "transparent", sColor: "#FFFFFF"}));
	sIFR.replaceElement("div.cachet_white", named({sFlashSrc: ccs.contextPath + "/applications/picknpay/templates/flash/sifr/cachet.swf", sWmode: "transparent", sColor: "#FFFFFF"}));
	sIFR.setup();
};
/*--------------------------------------------------------------------------*/
///applications/picknpay/templates/js/sifr-addons.js
/*--------------------------------------------------------------------------*/
/*	sIFR 2.0.1 Official Add-ons 1.2
	Copyright 2005 Mark Wubben

	This software is licensed under the CC-GNU LGPL <http://creativecommons.org/licenses/LGPL/2.1/>
*/

if(typeof sIFR=="function")(function(){var j=document;var h=j.documentElement;sIFR.removeDecoyClasses=function(){function a(b){if(b&&b.className!=null)b.className=b.className.replace(/\bsIFR-hasFlash\b/,"")}return function(){a(h);a(j.getElementsByTagName("body")[0])}}();sIFR.preferenceManager={storage:{sCookieId:"sifr",set:function(a){var b=new Date();b.setFullYear(b.getFullYear()+3);j.cookie=[this.sCookieId,"=",a,";expires=",b.toGMTString(),";path=/"].join("")},get:function(){var a=j.cookie.match(new RegExp(";?"+this.sCookieId+"=([^;]+);?"));if(a!=null&&a[1]=="false")return false;else return true},reset:function(){var a=new Date();a.setFullYear(a.getFullYear()-1);j.cookie=[this.sCookieId,"=true;expires=",a.toGMTString(),";path=/"].join("")}},disable:function(){this.storage.set(false)},enable:function(){this.storage.set(true)},test:function(){return this.storage.get()}};if(sIFR.preferenceManager.test()==false){sIFR.bIsDisabled=true;sIFR.removeDecoyClasses()}sIFR.rollback=function(){function a(b){var c,d,e,f,g,h;var l=parseSelector(b);var i=l.length-1;var m=false;while(i>=0){c=l[i];l.length--;d=c.parentNode;if(c.getAttribute("sifr")=="true"){h=0;while(h<d.childNodes.length){c=d.childNodes[h];if(c.className=="sIFR-alternate"){e=c;h++;continue}d.removeChild(c)}if(e!=null){f=e.firstChild;while(f!=null){g=f.nextSibling;d.appendChild(e.removeChild(f));f=g}d.removeChild(e)}if(!sIFR.UA.bIsXML&&sIFR.UA.bUseInnerHTMLHack)d.innerHTML+="";d.className=d.className.replace(/\bsIFR\-replaced\b/,"")};m=true;i--}return m}return function(k){named.extract(arguments,{sSelector:function(a){k=a}});if(k==null)k="";else k+=">";sIFR.removeDecoyClasses();sIFR.bHideBrowserText=false;if(a(k+"embed")==false)a(k+"object")}}()})()
/*--------------------------------------------------------------------------*/
///shared/client_scripts/form-style.js
/*--------------------------------------------------------------------------*/
/* 
 * Created by Johan Nilsson <http://markupartist.com>, <http://johan.galaxen.net>
 *
 * Philip Howards formstyle.js <http://www.gamingheadlines.co.uk/wod/formstyle>
 * inpired me to do this work, so a big thanks goes to him. 
 *
 * This work is licensed by a Creative Commons License. 
 * <http://creativecommons.org/licenses/by-sa/2.0/>
 * 
 * ## Changelog
 * 0.2
 * Todd Tyree fixed bugs with multiple radiobutton groups.
 * 0.1
 * First release.
 */

registerOnLoad(function() {styleCheckboxesAndRadiobuttons();});

function styleCheckboxesAndRadiobuttons() {
	var elements = document.getElementsByTagName('input');
	for (i = 0; i < elements.length; i++) {
		if (elements[i].type == 'checkbox' || elements[i].type == 'radio') {	
			switch (elements[i].className) {
				// Add other cases here for other symbols. Just remember 
				// to change in your css too.
				// The case is the same as the class you use when calling on the
				// input.
				case 'splash':
					createAlternateCheckboxOrRadiobutton(elements[i], i);
				break;
				case 'heart':
					createAlternateCheckboxOrRadiobutton(elements[i], i);
				break;
				case 'pnp-checkbox':
					createAlternateCheckboxOrRadiobutton(elements[i], i);
				break;
			}
		}
	}
}

function createAlternateCheckboxOrRadiobutton(element, num) {
	var defaultClass = element.className + '-default';
	// Hide the original checkbox.
	element.style.display='none';
	// creates the new alternate checkbox
	var altElement = document.createElement('div');
	if (element.checked == true) {
		altElement.className = element.className;
	} else {
		altElement.className = defaultClass;
	}
	altElement.id = 'alt-' + element.id;
	element.parentNode.appendChild(altElement);

	// Handles onclick event.
	altElement.onclick = function(){
		if (element.checked != true) {
			if (element.type == 'radio') {
			  handleOnClickForRadiobuttons(element.name);
			}
			altElement.className = element.className;
			element.checked = true
		} else {
			if (element.type == 'radio') {
				handleOnClickForRadiobuttons(element.name);
			}
			altElement.className = defaultClass;
			element.checked = false;
		}
	}
}

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

if (!window.ccs.ugc) {
   ccs.ugc = {}; // package declaration
}
ccs.ugc.path = '/shared/content/ugc_content/';
ccs.ugc.jsonpath = ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/ugc_content/";
ccs.ugc.capturejsonpath = ccs.ugc.jsonpath + "capture/";



ccs.ugc.Capture = function() {
   var self;
   var umessages;    //store custom user messages per instance
   var formValidationErrors; //store custom validation messages per instance, object Hash where oid is the key and an array of errors the value
   var preValidationState; //object to store the state of the input form before it was validated and styles were changed. This is so that it can reset the form
   var multiSubs;
   var sectionId;
   var divToShowOnCapture;

   // constructor function
   function constructorFn() {
      self = this;
      umessages = new Object();
      //registerOnLoad(self.init);
      formValidationErrors = new Object();
      preValidationState = new Object();

   }

   // init function called once document is loaded
   constructorFn.prototype.init = function(_multiSubs, _sectionId) {
      self.multiSubs = _multiSubs;
      self.sectionId = _sectionId;
   }

   //clear any previous validation highlights/states etc
   constructorFn.prototype.clearValidationState = function(oid) {
      var preValidationStateArr = preValidationState[oid+""];
      if (preValidationStateArr != null) {
         for (var i = 0; i < preValidationStateArr.length; i++) {
            var preObj = preValidationStateArr[i];
            //$("ugcAttrRow_" + preObj.formFieldId).style.backgroundColor =  preObj.bgcolor;
            $("ugcValidationMsg_" + preObj.formFieldId).innerHTML = "";
         }
         preValidationState[oid+""] = new Array();
      }
   }
                   
   //validate input, return true if no errors else false
   //for now we just simply highlight the error and display an inline message
   //we can make it more dunamic and configurable per app if need be
   constructorFn.prototype.validate = function(oid) {
      self.clearValidationState(oid);
      var noErrors = true;
      var arrErrors = formValidationErrors[oid + ""];
      if (arrErrors != null && arrErrors.length > 0) {

         //highlight errors etc
         alert("Please check the form for errors.");
         var errs = "";

         var preValidationStateArr = preValidationState[oid+""];
         if (preValidationStateArr == null) {
            preValidationStateArr = new Array();
            preValidationState[oid+""] = preValidationStateArr;
         }

         for (i = 0; i < arrErrors.length; i++) {
            errs += "\n" + arrErrors[i].fieldName;
            var preObj = new Object();
            preObj.bgcolor = $("ugcAttrRow_" + arrErrors[i].formFieldId).style.backgroundColor;
            preObj.formFieldId = arrErrors[i].formFieldId;
            //$("ugcAttrRow_" + arrErrors[i].formFieldId).style.backgroundColor = "yellow";
            if (arrErrors[i].errorSuffix) {
               $("ugcValidationMsg_" + arrErrors[i].formFieldId).innerHTML = "* " + arrErrors[i].errorSuffix;
            }

            preValidationStateArr.push(preObj);
         }
         formValidationErrors[oid + ""] = new Array();
         noErrors = false;
      }
      return noErrors;
   }
   //makes an ajax request to check if the user us authenitcated or not
   constructorFn.prototype.checkAuth = function (oid, jsonUpMapping) {
         new Ajax.Request(ccs.ugc.jsonpath + "isauth.json",
         {
            method:'post',

            onSuccess: function(transport) {
               var res = transport.responseText.evalJSON();
               if (res.authed) {
                  $("ugcCaptureFormAuthed_" + oid).style.display = "block";
                  //now we fetch the additional user info we may need
                  self.userInfo(oid, jsonUpMapping);
               } else {
                  if ($("ugcCaptureFormNotAuthed_" + oid)) {
                     $("ugcCaptureFormNotAuthed_" + oid).style.display = "block";
                  }
               }
            },
            onFailure: function(transport) {
               var err = transport.responseText.evalJSON();
               if (err != null && err.error) {
                  alert(err.message);
               } else {
                  alert("Error speaking to server:" + transport.responseText);
               }
            }
         });
   }

   //makes an ajax request to fetch the session user's info and prepopulated the capture fields
   constructorFn.prototype.userInfo = function (oid, jsonUpMapping) {
         new Ajax.Request(ccs.ugc.jsonpath + "user_info.json",
         {
            method:'post',

            onSuccess: function(transport) {
               var res = transport.responseText.evalJSON();
               if (res.error) {
                  alert("Error:" + res.message);
               }
               //now we fetch the additional user info we may need
               //atempt to popuplate the fields
               
               fields = res.fields;
               for (var i=0; i<fields.length; i++) {            	   
            	   try { $(jsonUpMapping[fields[i].label] + "").value = fields[i].value; } catch (e) {}
            	   
            	   if (fields[i].value == null || fields[i].value.length < 1 && $("ugcAttrRow_" + jsonUpMapping[fields[i].label])) {
            		   $("ugcAttrRow_" + jsonUpMapping[fields[i].label]).style.display = "";
            	   } else if (fields[i].label != "email" && $("ugcAttrRow_" + jsonUpMapping[fields[i].label])) {
            		   // if the profile data is populated, remove the field so that we don't worry about populating and re-saving it
            		   var parent = $("ugcAttrRow_" + jsonUpMapping[fields[i].label]).parentNode;
            		   parent.removeChild($("ugcAttrRow_" + jsonUpMapping[fields[i].label]));            		   
            	   }
               }
               
            },
            onFailure: function(transport) {
               var err = transport.responseText.evalJSON();
               if (err != null && err.error) {
                  alert(err.message);
               } else {
                  alert("Error speaking to server:" + transport.responseText);
               }
            }
         });
   }

   //makes an ajax request to load the html for setting up the UGC
   constructorFn.prototype.submitUGC = function (theForm, oid, hideForm, publishImmediately) {
      var validation =  $("ugcValidation_" + oid).value;
      if (validation.length > 0) {
         eval(validation);
      }

      if (self.validate(oid)) {
         self.showLoader(oid);
         var pars = new Object();
         pars = Form.serializeElements(Form.getElements(theForm), true);

         if (isCookiesEnabled()) {
            var rec = getCookie("ugc_" + oid);
            pars["ugc_rec"] = rec;
            pars["section_id"] = self.sectionId;
            new Ajax.Request(ccs.ugc.capturejsonpath + "capture.json",
            {
               method:'post',
               parameters: pars,

               onSuccess: function(transport) {
                  self.showSubmit(oid);
                  var ret = transport.responseText.evalJSON();
                  self.captured(pars, oid, theForm, hideForm, publishImmediately);

                  if (ret.msg.length > 0) { //non live site debug msg
                     alert(ret.msg);
                  }

               },
               onFailure: function(transport) {
                  self.showSubmit(oid);
                  var err = transport.responseText.evalJSON();
                  if (err != null && err.error) {
                     alert(err.message);
                  } else {
                     alert("Error speaking to server:" + transport.responseText);
                  }
               }
            });
         } else {
            $("ugcMessage_" + oid).innerHTML = "Sorry, Your browser does not support cookies. " +
                                               "We use cookies as part of a mechanism to control certain spam bots";
         }

      }
   }
   //called after the form is submitted.
   // We need to now either
   constructorFn.prototype.captured = function (pars, oid, theForm, hideForm, publishImmediately) {
      if (hideForm) {
         //we replace the form contents with the thankyou message contents
         $("ugcCaptureForm_" + oid).innerHTML =  self.getMessageThanks(oid);
      } else {
         $("ugcMessage_" + oid).innerHTML = self.getMessageThanks(oid);
      }


      var period;
      if (self.multiSubs=="always") {
           period = -10000;
      } else if (self.multiSubs=="never") {
            period = 300 * 24 * 60 * 60 * 1000;
      } else if (self.multiSubs=="session") {
      } else if (self.multiSubs=="day") {
            period = 1 * 24 * 60 * 60 * 1000;
      } else if (self.multiSubs=="week") {
            period = 7 * 24 * 60 * 60 * 1000;
      }
      var expire = null;

      if (self.multiSubs!="session") {
         expire = new Date();
         var dateBuffy = expire.getTime() + period;
         expire.setTime(dateBuffy);
      }
      setCookie("ugc_" + oid, "ugc", expire);





      //if we have an add template we display the item
      if ($("ugcAddTemplate_" + oid)) {
         var d = new Date();
         var curr_hour = d.getHours();
         var curr_min = d.getMinutes();
         pars["added_at"] = curr_hour + " : " + curr_min;
         t = cambrient.processTemplate($("ugcAddTemplate_" + oid).value , pars);
         //add a div to the placeholder - we can't simply replace as they may add multiple
         newDiv = document.createElement("DIV");
         newDiv.innerHTML = t;
         $("ugcContentAdd_" + oid).appendChild(newDiv);         
      }
      //call backs to refresh data on either graph or listing
      //this could be done in a more oo way, this aint too pretty
      //but the problem here is that the capture tag could have appeared before the ugc tag and vice versa
      //which means I can't assume one exists to hook into... but this could be fixed with a third "callback manager" type class
      // we only bother to refresh the list IF it is a moderated list

      if ($("ugcGraphData_" + oid)) {
         eval("ccs.ugc.graph" + oid + ".loadGraphData()");
      }
      if (publishImmediately) {
         if ($("ugcList_" + oid)) {
            eval("ccs.ugc.list" + oid + ".refreshList()");
         }
      }
      if (divToShowOnCapture != null && divToShowOnCapture.length > 0) {
         $(divToShowOnCapture).style.display = "block";
         $(divToShowOnCapture).style.visibility = "visible";
      }

      theForm.reset();

   }
   constructorFn.prototype.showSubmit = function (oid) {
      //hide loader
      $("ugcLoader_" + oid).style.visibility = "hidden";
      $("ugcLoader_" + oid).style.display = "none";
      //show submit again
      $("ugcSubmit_" + oid).style.display = "block";
      $("ugcSubmit_" + oid).style.visibility = "visible";
   }

   constructorFn.prototype.addMessageThanks = function (oid, msg) {
      umessages["instance_" + oid] = msg;
   }
   constructorFn.prototype.showDivOnCapture = function (divId) {
      divToShowOnCapture = divId;
   }

   constructorFn.prototype.getMessageThanks = function (oid) {
      return umessages["instance_" + oid];
   }

   constructorFn.prototype.showLoader = function (oid) {
      //hide loader
      $("ugcLoader_" + oid).style.visibility = "visible";
      $("ugcLoader_" + oid).style.display = "block";
      //show submit again
      $("ugcSubmit_" + oid).style.display = "none";
      $("ugcSubmit_" + oid).style.visibility = "hidden";
   }

   constructorFn.prototype.addValidationError = function (oid, formFieldName, formFieldId, errorSuffix) {
      //hide loader
      var myErr = new Object();
      myErr.fieldName = formFieldName;
      myErr.formFieldId = formFieldId;
      myErr.errorSuffix = errorSuffix; //is mandatory / is not a valid email address etc

      var arrErrors =  formValidationErrors[oid+""];
      if (arrErrors == null) {
         arrErrors = new Array();
      }
      arrErrors.push(myErr);
      formValidationErrors[oid+""] = arrErrors;
   }   



   return new constructorFn();
}
/*--------------------------------------------------------------------------*/
///shared/client_scripts/validation.js
/*--------------------------------------------------------------------------*/
if (!window.ccs) {
   window.ccs = {};
}


if (!ccs.validation) {
   ccs.validation = {};
}
ccs.Validation = function() {
	var self;



   function constructorFn() {
		self=this;
   }


   constructorFn.prototype.isPhoneNumber = function(input) {
      var ValidChars = "0123456789.-() ";
      var IsNumber=true;
      var Char;


      for (i = 0; i < input.length && IsNumber == true; i++){
         Char = input.charAt(i);
         if (ValidChars.indexOf(Char) == -1){
            IsNumber = false;
         }
      }
      return IsNumber;
   }

   constructorFn.prototype.isNumeric = function(input) {
      var ValidChars = ".0123456789";
      var IsNumber=true;
      var Char;


      for (i = 0; i < input.length && IsNumber == true; i++){
         Char = input.charAt(i);
         if (ValidChars.indexOf(Char) == -1){
            IsNumber = false;
         }
      }
      return IsNumber;
   }
   constructorFn.prototype.isInteger = function(input) {
      var ValidChars = "0123456789";
      var IsNumber=true;
      var Char;


      for (i = 0; i < input.length && IsNumber == true; i++){
         Char = input.charAt(i);
         if (ValidChars.indexOf(Char) == -1){
            IsNumber = false;
         }
      }
      return IsNumber;
   }

   constructorFn.prototype.testValidChars = function(input, ValidChars) {
      var IsValid=true;
      var Char;
      for (i = 0; i < input.length && IsValid == true; i++){
         Char = input.charAt(i);
         if (ValidChars.indexOf(Char) == -1){
            IsValid = false;
         }
      }
      return IsValid;
   }

   constructorFn.prototype.isPhoneNumber = function(input) {
	      var ValidChars = "+0123456789";
	      var IsNumber=true;
	      var Char;

	      for (i = 0; i < input.length && IsNumber == true; i++){
	         Char = input.charAt(i);
	         if (ValidChars.indexOf(Char) == -1){
	            IsNumber = false;
	         }
	      }
	      return IsNumber;
	   }

   constructorFn.prototype.isEmail = function(input) {
      var filter=/^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i
      if (filter.test(input))
         return true;
      else{
         return false;
      }
   }
   
   constructorFn.prototype.isCheckBoxTicked = function(input) {
   	if(input.checked){
			return true; 
		} else {
			return false;
		}
   }

   constructorFn.prototype.isNotBlank = function(input) {
        input = input.replace(/ /g, "");
		if (input == "") {
			return false;
		} else {
			return true;
		}
   }

   constructorFn.prototype.exceedsOccurenceLimit = function(input, substring, limit) {
       var items = input.split(substring);

       if (items.length -1 <= limit) {
           return false;
       } else {
           return true;
       }
   }

   constructorFn.prototype.occursAtExtremes = function(input, character) {
       if (input.charAt(0)==character || input.charAt(input.length-1)==character) {
           return true;
       } else {
           return false;
       }      
   }

   constructorFn.prototype.limitText = function(limitField, limitCount, limitNum) {
		if (limitField.value.length > limitNum) {
			limitField.value = limitField.value.substring(0, limitNum);
		} else {
			if (limitCount != null) {
				limitCount.value = limitNum - limitField.value.length;
			}
		}
	}


   return new constructorFn();
}


ccs.validation = new ccs.Validation();





/*--------------------------------------------------------------------------*/
///shared/client_scripts/cookies.js
/*--------------------------------------------------------------------------*/
	function getexpirydate( nodays){
		var UTCstring;
		Today = new Date();
		nomilli=Date.parse(Today);
		Today.setTime(nomilli+nodays*24*60*60*1000);
		UTCstring = Today.toUTCString();
		return UTCstring;
	}


   function isCookiesEnabled() {
      var cookieEnabled=(navigator.cookieEnabled)? true : false;
      //if navigator,cookieEnabled is not supported
      if (typeof navigator.cookieEnabled=="undefined" && !cookieEnabled){
          document.cookie="testcookie";
          cookieEnabled=(document.cookie.indexOf("testcookie")!=-1)? true : false;
      }
      return cookieEnabled;      
   }

   function setPersistendCookie(name, value) {
      var expire = new Date();
      //add 50 years - kind of making it persistend
      var dateBuffy = expire.getTime() + (50 * 365 * 24 * 60 * 60 * 1000);
      expire.setTime(dateBuffy);
      setCookie(name, value, expire);
   }

   //Made especially for Remember Me    - It needs the PATH
   function setFixedCookie(name, value, path) {
      var expire = new Date();
      //add 50 years - kind of making it persistend
      var dateBuffy = expire.getTime() + (50 * 365 * 24 * 60 * 60 * 1000);
      expire.setTime(dateBuffy);
      setCookie(name, value, expire, path);  
   }

   var setPersistentCookie=setPersistendCookie;

   function getCookie(name) {
    var dasCookie = document.cookie;
    var index = dasCookie.indexOf(name + "=");
    if (index == -1) return null;
    index = dasCookie.indexOf("=", index) + 1; // first character
    var endstr = dasCookie.indexOf(";", index);
    if (endstr == -1) endstr = dasCookie.length; // last character
    return unescape(dasCookie.substring(index, endstr));
   }


   function setCookie (name, value) {  
      var argv = setCookie.arguments;  
      var argc = setCookie.arguments.length;  
      var expires = (argc > 2) ? argv[2] : null;  
      var path = (argc > 3) ? argv[3] : null;  
      var domain = (argc > 4) ? argv[4] : null;  
      var secure = (argc > 5) ? argv[5] : false;  
      document.cookie = name + "=" + escape (value) + 
      ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) + 
      ((path == null) ? "" : ("; path=" + path)) +  
      ((domain == null) ? "" : ("; domain=" + domain)) +    
      ((secure == true) ? "; secure" : "");
   }

   
   function deleteCookie (name) { 
      var exp = new Date();  
      exp.setTime (exp.getTime() - 100000);  

      var argv = deleteCookie.arguments;  
      var argc = deleteCookie.arguments.length;  
      var path = (argc > 1) ? argv[1] : null;  
      var domain = (argc > 2) ? argv[2] : null;  
      var secure = (argc > 3) ? argv[3] : false;  

      var cval = getCookie (name);
      document.cookie = name + "=" + cval + ";expires=" + exp.toGMTString() +
	      ((path == null) ? "" : ("; path=" + path)) +  
	      ((domain == null) ? "" : ("; domain=" + domain)) +    
	      ((secure == true) ? "; secure" : "");
   } 
/*--------------------------------------------------------------------------*/
///modletInclude/login_form/js/loginForm.js
/*--------------------------------------------------------------------------*/
if (!window.ccs) {
   window.ccs = {};
}

ccs.Login = function(whoToGreet) {
   var self;
   var sessionId;
   var userDisplay;
   var loginLink = "loginUrl";
   var logoutLink;
   var editLink;
   var showForm;
   var showForgottenPassword;
   var registrationLink;
   var isLoggedIn = false;
   var lastUsername;
   var userUUIDCookie;
   var emailDomain;
   var fromAddress;
   var loginModulePage;
   var requestURI;
   var resetMessage;
   var sectionId;
   var mustRememberMe;
   var goToGroupHomepage;
   var postLoginPage;
   var postLogoutPage;
   var canLoad; //Set my the loginFormFooter, to notify js that the lightbox has loaded.
   var whoToGreet;
   var greetingSuffix;
   var isActive;
   var loginStatusEstablished = false;
   var goToUrl = ""; //If user clicks on a link, it can either take them there, or popup the login form.
   var postLoginFunction;

   function constructorFn(whoToGreet) {
      self = this;
      sessionId = getCookie("JSESSIONID");
      self.canLoad = false;
      self.getLoggedInUser();
      self.whoToGreet = whoToGreet;
      self.isActive = false;
   }

   constructorFn.prototype.setVar = function(name, value) {
      val = value + ""; //convert to string (may be boolean)
      if (val == "true" || val == "false") {
         eval("self." + name + " = " + value + "");
      } else {
         value = value.replace(/'/g, "\\'");
         eval("self." + name + " = '" + value + "'");
      }

   }

   constructorFn.prototype.hasLoginStatusBeenEstablished = function() {
      return loginStatusEstablished;
   }

   constructorFn.prototype.isUserLoggedIn = function() {
      return isLoggedIn;
   }

   constructorFn.prototype.setCanLoad = function() {
      canLoad = true;
   }
   constructorFn.prototype.showThrobber = function() {
      $('loginWait').style.display = "inline";
   }
   constructorFn.prototype.hideThrobber = function() {
      $('loginWait').style.display = "none";
   }

   constructorFn.prototype.showForgotPassword = function() {
      self.setMsg('forgottenPassword');
   }

   constructorFn.prototype.register = function() {
      location.href = self.registrationLink;
   }

   constructorFn.prototype.authClick = function(callback) {
      if (self.hasLoginStatusBeenEstablished()) {
         if (self.isUserLoggedIn()) {
            callback();
         } else {
            postLoginFunction = callback;
            loginTop();
         }
      } else {
         setTimeout(function() {
            self.authClick(callback);
         }, 500);
      }     
   }

   constructorFn.prototype.logout = function() {
      deleteCookie(self.userUUIDCookie, ccs.contextPath);
      new Ajax.Request(ccs.contextPath + '/json/' + ccs.appName + '/' + ccs.languageCode + '/modules/login_form/logout.json', {
         method:'get',
         onSuccess: function(transport) {
            if (self.postLogoutPage != "" && self.postLogoutPage != null) {
               location.href = self.postLogoutPage;
            } else {
               location.href = ccs.contextPath;
            }
         },
         onFailure: function() {
            // alert('Something went wrong...')
         }
      });
   }


   constructorFn.prototype.getLoggedInUser = function() { //alert(self.showUsername);
      var url = ccs.contextPath + '/json/' + ccs.appName + '/' + ccs.languageCode + '/modules/login_form/checkStatus.json?whoToGreet=' + whoToGreet + '&rnd=' + Math.random();
      new Ajax.Request(url, {
         method:'get',
         onSuccess: function(transport) {

            var response = transport.responseText || "no response text";
            var json = eval('(' + response + ')');
            if (json.status == "") {
               isLoggedIn = false;
            } else {
               isLoggedIn = true;
            }
            loginStatusEstablished = true;
            self.displayForm(json);

         },
         onFailure: function() {
            // alert('Something went wrong...')
         }
      });
   }


   constructorFn.prototype.goToUrl = function(url) {
      goToUrl = url;
      if (loginStatusEstablished) {
         if (isLoggedIn) {
            location.href = url;
         } else {
            loginTop();
         }
      } else {
         setTimeout(function() {
            self.goToUrl(url)
         }, 500);
      }

   }

   constructorFn.prototype.displayForm = function(json) {
      if (canLoad) {
         if (json.status == "") {
            $('statusCheck').style.display = "none";
            $('notLoggedIn').style.display = "inline";
         } else {
            $('statusCheck').style.display = "none";
            $('logged_in_fullname').innerHTML = json.status + self.greetingSuffix;
            $('loggedIn').style.display = "inline";
         }
      } else {
         setTimeout(function() {
            self.displayForm(json)
         }, 500);

      }
   }


   constructorFn.prototype.setForgotCredentialsEmail = function(emailAddress) {
      $('forgottenPasswordEmail').value = emailAddress;
   }

   constructorFn.prototype.changeRememberMe = function() {
      self.mustRememberMe = $('mustRememberMe').checked;
   }

   constructorFn.prototype.showMsgBox = function() {
      if (!isActive) {
         Modalbox.show($('loginMsgBox'), {title: "none", width: 420});
         isActive = true;
      }

      /*
       var elm = $('loginMsgBox');
       elm.style.display = "block";
       var top = Math.round((document.documentElement.clientHeight / 2) - (elm.style.height / 2) + document.documentElement.scrollTop);
       if (top < 100) top = 100;
       elm.style.top = top + "px";
       */
   }

   constructorFn.prototype.closeMsgBox = function() {
      Modalbox.hide();
      isActive = false;
      //msgBox.deactivate();
      //$('loginMsgBox').style.display = "none";
   }

   constructorFn.prototype.setMsg = function(srcDiv) {
      window.scroll(0, 0);
      var src = $(srcDiv).innerHTML;
      if (srcDiv == 'forgottenPassword') {
         src = src.replace(/forgottenPasswordUsername/g, "forgottenPasswordUsername2");
         src = src.replace(/forgottenPasswordEmail/g, "forgottenPasswordEmail2");
         src = src.replace(/forgottenPasswordMsg/g, "forgottenPasswordMsg2");
      }
      if (srcDiv == 'altLoginForm') {
         src = src.replace(/login_username_alt/g, "login_username_alt2");
         src = src.replace(/login_password_alt/g, "login_password_alt2");
      }
      // Modalbox.hide();
      //Modalbox.show($(srcDiv), {title: "none", width: 420});
      $('loginMsg').innerHTML = src;
      //alert($('loginMsg').innerHTML);
      self.showMsgBox();
   }


   constructorFn.prototype.getParams = function(alt) {
      if (alt != "_alt2") alt = "";
      var username = $('login_username' + alt).value;
      var password = $('login_password' + alt).value;
      var parameters = new Object();
      parameters['password'] = password;
      parameters['username'] = username;
      parameters['emailDomain'] = self.emailDomain;
      parameters['fromAddress'] = self.fromAddress;
      parameters['loginModulePage'] = self.loginModulePage;
      parameters['remember_me'] = self.mustRememberMe;
      parameters['sectionId'] = self.sectionId;
      parameters['requestURI'] = self.requestURI;
      return parameters;
   }

   constructorFn.prototype.resetPassword = function() {
      self.showThrobber();
      var parameters = self.getParams();
      parameters['username'] = self.lastUsername;

      new Ajax.Request(ccs.contextPath + '/json/' + ccs.appName + '/' + ccs.languageCode + '/modules/login_form/resetPassword.json', {
         method:'post',
         parameters: parameters,
         onSuccess: function(transport) {
            var response = transport.responseText || "no response text";
            var json = eval('(' + response + ')');
            var status = json.status;
            self.hideThrobber();
            $('resetPasswordDone').innerHTML = $('resetPasswordDone').innerHTML.replace(/EMAIL/, json.email);
            self.setMsg('resetPasswordDone');

         },
         onFailure: function() {
            // alert('Something went wrong...')
         }
      });
   }

   constructorFn.prototype.logMeIn = function(alt) {
      var parameters = self.getParams(alt);
      if (parameters['username'] == "" || parameters['password'] == "") return;
      if (self.goToGroupHomepage) {
         parameters['goToGroupHomepage'] = "true";
      }
      new Ajax.Request(ccs.contextPath + '/json/' + ccs.appName + '/' + ccs.languageCode + '/modules/login_form/checkUser.json', {
         method:'post',
         parameters: parameters,
         onSuccess: function(transport) {

            var response = transport.responseText || "no response text";
            var json = eval('(' + response + ')');
            var status = json.status;

            if (status == 'success') {
               var uuid = json.uuid;
               if (self.mustRememberMe) {
                  setFixedCookie(self.userUUIDCookie, uuid, ccs.contextPath);
               } else {
                  deleteCookie(self.userUUIDCookie, ccs.contextPath);
               }

               if (postLoginFunction !=null) {
                  postLoginFunction();
               }
               setTimeout(function() {    //Slight delay to ensure postLoginFunction is called.
                  if (goToUrl != "") {
                     location.href = goToUrl;
                  } else if (self.postLoginPage != "" && self.postLoginPage != null) {
                     location.href = self.postLoginPage;
                  } else if (self.goToGroupHomepage) {
                     location.href = json.groupHomepage;
                  } else {
                     location.reload();
                  }
               }, 500);
            } else if (status == "incorrect_password" && (self.resetMessage != "null" && !self.resetMessage == "" && !self.resetMessage.toLowerCase() == "not set")) {

               self.lastUsername = parameters['username'];  //Used for forgotten password, so they don't change it in the login form and set to the wrong user.

               $('loginMsg').innerHTML = self.resetMessage;
               self.showMsgBox();
            } else if (status == "incorrect_username") {

               self.setMsg("wrongCredentials_username");
            } else if (status == "incorrect_password") {
               self.setMsg("wrongCredentials_password")
            } else if (status == "not_opted_in") {

               $('optIn').innerHTML = $('optIn').innerHTML.replace(/EMAIL/, json.email);
               self.setMsg("optIn")
            }


         },
         onFailure: function() {
            // alert('Something went wrong...')
         }
      });

   }

   constructorFn.prototype.showResetPassword = function() {
      self.setMsg("resetPassword");
   }

   constructorFn.prototype.forgottenPasswordSubmit = function(type) {
      var value = '';
      if (type == 'username') {
         value = $('forgottenPasswordUsername2').value;
      } else {
         value = $('forgottenPasswordEmail2').value;
      }


      var parameters = self.getParams();
      parameters['type'] = type;
      parameters['value'] = value;

      self.showThrobber();
      new Ajax.Request(ccs.contextPath + '/json/' + ccs.appName + '/' + ccs.languageCode + '/modules/login_form/forgotten.json', {
         method:'post',
         parameters: parameters,
         onSuccess: function(transport) {
            var response = transport.responseText || "no response text";
            var json = eval('(' + response + ')');
            var status = json.status;
            if (status == 'true') {
               $('forgottenPasswordMsg2').innerHTML = $('successfulNotification').innerHTML;
            } else {
               $('forgottenPasswordMsg2').innerHTML = json.info;
            }
            self.hideThrobber();
         },
         onFailure: function() {
            self.hideThrobber();
         }
      });
   }
   return new constructorFn(whoToGreet);
}
/*--------------------------------------------------------------------------*/
///shared/client_scripts/cookies.js
/*--------------------------------------------------------------------------*/
	function getexpirydate( nodays){
		var UTCstring;
		Today = new Date();
		nomilli=Date.parse(Today);
		Today.setTime(nomilli+nodays*24*60*60*1000);
		UTCstring = Today.toUTCString();
		return UTCstring;
	}


   function isCookiesEnabled() {
      var cookieEnabled=(navigator.cookieEnabled)? true : false;
      //if navigator,cookieEnabled is not supported
      if (typeof navigator.cookieEnabled=="undefined" && !cookieEnabled){
          document.cookie="testcookie";
          cookieEnabled=(document.cookie.indexOf("testcookie")!=-1)? true : false;
      }
      return cookieEnabled;      
   }

   function setPersistendCookie(name, value) {
      var expire = new Date();
      //add 50 years - kind of making it persistend
      var dateBuffy = expire.getTime() + (50 * 365 * 24 * 60 * 60 * 1000);
      expire.setTime(dateBuffy);
      setCookie(name, value, expire);
   }

   //Made especially for Remember Me    - It needs the PATH
   function setFixedCookie(name, value, path) {
      var expire = new Date();
      //add 50 years - kind of making it persistend
      var dateBuffy = expire.getTime() + (50 * 365 * 24 * 60 * 60 * 1000);
      expire.setTime(dateBuffy);
      setCookie(name, value, expire, path);  
   }

   var setPersistentCookie=setPersistendCookie;

   function getCookie(name) {
    var dasCookie = document.cookie;
    var index = dasCookie.indexOf(name + "=");
    if (index == -1) return null;
    index = dasCookie.indexOf("=", index) + 1; // first character
    var endstr = dasCookie.indexOf(";", index);
    if (endstr == -1) endstr = dasCookie.length; // last character
    return unescape(dasCookie.substring(index, endstr));
   }


   function setCookie (name, value) {  
      var argv = setCookie.arguments;  
      var argc = setCookie.arguments.length;  
      var expires = (argc > 2) ? argv[2] : null;  
      var path = (argc > 3) ? argv[3] : null;  
      var domain = (argc > 4) ? argv[4] : null;  
      var secure = (argc > 5) ? argv[5] : false;  
      document.cookie = name + "=" + escape (value) + 
      ((expires == null) ? "" : ("; expires=" + expires.toGMTString())) + 
      ((path == null) ? "" : ("; path=" + path)) +  
      ((domain == null) ? "" : ("; domain=" + domain)) +    
      ((secure == true) ? "; secure" : "");
   }

   
   function deleteCookie (name) { 
      var exp = new Date();  
      exp.setTime (exp.getTime() - 100000);  

      var argv = deleteCookie.arguments;  
      var argc = deleteCookie.arguments.length;  
      var path = (argc > 1) ? argv[1] : null;  
      var domain = (argc > 2) ? argv[2] : null;  
      var secure = (argc > 3) ? argv[3] : false;  

      var cval = getCookie (name);
      document.cookie = name + "=" + cval + ";expires=" + exp.toGMTString() +
	      ((path == null) ? "" : ("; path=" + path)) +  
	      ((domain == null) ? "" : ("; domain=" + domain)) +    
	      ((secure == true) ? "; secure" : "");
   } 
/*--------------------------------------------------------------------------*/
///shared/client_scripts/div_functions.js
/*--------------------------------------------------------------------------*/
function toggleDiv(divId) {
   var oDiv = document.getElementById(divId);
   if (oDiv == null ) {
      alert("Could not toggle div with id " + divId + " as the div does not exist");
      return;
   }

   if (oDiv.style.display=='none' || oDiv.style.visibility=='hidden' || oDiv.style.display=='') {
      showDiv(divId);
   } else {
      hideDiv(divId);
   }
}

function hideDiv(divId) {
   var oDiv = document.getElementById(divId);
   if (oDiv == null ) {
      alert("Could not hide div with id " + divId + " as the div does not exist");
      return;
   }
   oDiv.style.visibility = 'hidden';
   oDiv.style.display = 'none';
}

function showDiv(divId) {
   var oDiv = document.getElementById(divId);
   if (oDiv == null ) {
      alert("Could not show div with id " + divId + " as the div does not exist");
      return;
   }
   oDiv.style.visibility = 'visible';
   oDiv.style.display = 'block';
}

function loadIframeIntoDiv(iframeObject, divId) {
	// load the HTML contents
	var theBody = iframeObject.contentWindow.document.body;
	document.getElementById(divId).innerHTML = theBody.innerHTML;

	// load the javascript blocks
	var scriptBlocks = iframeObject.contentWindow.document.getElementsByTagName('script');
	if (scriptBlocks.length != null && scriptBlocks.length > 0) {
		for (var i=0; i < scriptBlocks.length; i++) {
			if (scriptBlocks[i].text != null) {
				var scriptCode = scriptBlocks[i].text;
				eval(scriptCode);
			}
		}
	}
}

if (!window.ccs) {
    window.ccs = {};
}    

// class to handle div sliders (in a crousel, for example)
ccs.DivSlider = function(divId, effect, effectDuration, step) {
    var self;
    var tween;
    var divId;
    var effect;
    var effectDuration;
    var step;
    
    // constructor
    function c(d, e, eDuration, s) {
        if (!window.Tween) {
            // load the Tween library
            loadScript('/shared/client_scripts/jstween/Tween.js');            
        }
    
        self = this;
        tween = null;
        divId = d;
        effectDuration = eDuration;
        step = s;
        
        if (e == null) effect = "strongEaseOut";
        else effect = e;
        
        if (effectDuration == null || effectDuration <= 0) {
            effectDuration = 1.2; // seconds
        } 
        
        if (step == null || step <= 0) {
            step = 200;
        }
    }

    // tween div left
    c.prototype.left = function(pos) {
      if (pos == null) pos = $(divId).scrollLeft - step;
      if (tween != null) tween.stop();
      tween = new Tween($(divId), 
                        'scrollLeft', 
                        eval("Tween." + effect), 
                        $(divId).scrollLeft, 
                        $(divId).scrollLeft < step ? 0 : pos,
                        effectDuration);
      tween.start();
    }
    
    // tween div right
    c.prototype.right = function(pos) {
      if (pos == null) pos = $(divId).scrollLeft + step;
      if ((pos + $(divId).clientWidth) > $(divId).scrollWidth) pos = $(divId).scrollWidth - $(divId).clientWidth;
      if (tween != null) tween.stop();
      tween = new Tween($(divId), 
                        'scrollLeft', 
                        eval("Tween." + effect), 
                        $(divId).scrollLeft, 
                        pos,
                        effectDuration);
      tween.start();
    }
    
    return new c(divId, effect, effectDuration, step);
};
/*--------------------------------------------------------------------------*/
///shared/client_scripts/popup_windows.js
/*--------------------------------------------------------------------------*/
// Contains functions for popping up windows
function new_popup(url, width, height) {
   // this function call is made by CCS when the page is set to open in a new window
   popup(url, '', width, height);
}

function popup(url, target, width, height, params) {
   popupReturn(url, target, width, height, params);
}

function fullScreen(theURL) {
   return window.open(theURL, '', 'fullscreen=yes, scrollbars=auto');
}

function popupReturn(url, target, width, height, params) {
   if (target == null) target="_new";
   if (width == null) width = 800;
   if (height == null) height = 600;
   if (params == null) params = "resizable=yes,menubar=no,status=yes,personalbar=no,scrollbars=yes";

   return openAWindow(url, target, width, height, params);
}

function openAWindow(url, target, width, height, params) {
  target = ""; // <<<<----- remove this when not needed. For now all windows open in new

  var winl = (screen.availWidth - width) / 2;
  var wint = (screen.availHeight - height) / 2;

  return window.open(url, target, "top=" + wint + ",left=" + winl +
  	",width=" + width + ",height=" + height + "," + params);
}

function popupFullscreen(url, target) {
	window.open(url, target, 'fullscreen=yes');
}

function popupMaximised(url, target, params) {
	var win = popupReturn(url, target, screen.availWidth, screen.availHeight, params);
}
var popupMaximized=popupMaximised;

function maximiseWindow(theWindow) {
   theWindow.moveTo(0,0);
   theWindow.outerHeight = screen.availHeight;
   theWindow.outerWidth = screen.availWidth;

}
var maximizeWindow=maximiseWindow;
/*--------------------------------------------------------------------------*/
///shared/client_scripts/modalbox/modalbox.js
/*--------------------------------------------------------------------------*/
/*
ModalBox - The pop-up window thingie with AJAX, based on prototype and script.aculo.us.

Copyright Andrey Okonetchnikov (andrej.okonetschnikow@gmail.com), 2006-2007
All rights reserved.
 
VERSION 1.5.5
Last Modified: 09/06/2007
*/

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

Modalbox.Methods = {
	overrideAlert: false, // Override standard browser alert message with ModalBox
	focusableElements: new Array,
	options: {
		title: "ModalBox Window", // Title of the ModalBox window
		overlayClose: false, // Close modal box by clicking on overlay
		width: 500, // Default width in px
		height: 90, // Default height in px
		overlayOpacity: .75, // Default overlay opacity
		overlayDuration: .25, // Default overlay fade in/out duration in seconds
		slideDownDuration: 0, // Default Modalbox appear slide down effect in seconds
		slideUpDuration: 0, // Default Modalbox hiding slide up effect in seconds
		resizeDuration: 0, // Default resize duration seconds
		inactiveFade: true, // Fades MB window on inactive state
		transitions: true, // Toggles transition effects. Transitions are enabled by default
		loadingString: "Please wait. Loading...", // Default loading string message
		closeString: "Close window", // Default title attribute for close window link
		params: {},
		method: 'get' // Default Ajax request method
	},
	_options: new Object,
	
	setOptions: function(options) {
		Object.extend(this.options, options || {});
	},
	
	_init: function(options) {
		// Setting up original options with default options
		Object.extend(this._options, this.options);
		this.setOptions(options);
		//Create the overlay
		this.MBoverlay = Builder.node("div", { id: "MB_overlay", opacity: "0" });
		//Create the window
		this.MBwindow = Builder.node("div", {id: "MB_window", style: "display: none"}, [
			this.MBframe = Builder.node("div", {id: "MB_frame"}, [
				this.MBheader = Builder.node("div", {id: "MB_header"}, [
					this.MBcaption = Builder.node("div", {id: "MB_caption"}),
					this.MBclose = Builder.node("a", {id: "MB_close", title: this.options.closeString, href: "#"}, [
						Builder.build("<span>&times;</span>"),
					]),
				]),
				this.MBcontent = Builder.node("div", {id: "MB_content"}, [
					this.MBloading = Builder.node("div", {id: "MB_loading"}, this.options.loadingString),
				]),
			]),
		]);
		// Inserting into DOM
		document.body.insertBefore(this.MBwindow, document.body.childNodes[0]);
		document.body.insertBefore(this.MBoverlay, document.body.childNodes[0]);
		
		// Initial scrolling position of the window. To be used for remove scrolling effect during ModalBox appearing
		this.initScrollX = window.pageXOffset || document.body.scrollLeft || document.documentElement.scrollLeft;
		this.initScrollY = window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop;
		
		//Adding event observers
		this.hide = this.hide.bindAsEventListener(this);
		this.close = this._hide.bindAsEventListener(this);
		this.kbdHandler = this.kbdHandler.bindAsEventListener(this);
		this._initObservers();

		this.initialized = true; // Mark as initialized
		this.active = true; // Mark as active
		this.currFocused = 0;
	},
	
	show: function(content, options) {
		if(!this.initialized) this._init(options); // Check for is already initialized
		
		this.content = content;
		this.setOptions(options);
		
		Element.update(this.MBcaption, this.options.title); // Updating title of the MB
		
		if(this.MBwindow.style.display == "none") { // First modal box appearing
			this._appear();
			this.event("onShow"); // Passing onShow callback
		}
		else { // If MB already on the screen, update it
			this._update();
			this.event("onUpdate"); // Passing onUpdate callback
		} 
	},
	
	hide: function(options) { // External hide method to use from external HTML and JS
		if(this.initialized) {
			if(options) Object.extend(this.options, options); // Passing callbacks
			if(this.options.transitions)
				Effect.SlideUp(this.MBwindow, { duration: this.options.slideUpDuration, afterFinish: this._deinit.bind(this) } );
			else {
				Element.hide(this.MBwindow);
				this._deinit();
			}
		} else throw("Modalbox isn't initialized");
	},
	
	alert: function(message){
		var html = '<div class="MB_alert"><p>' + message + '</p><input type="button" onclick="Modalbox.hide()" value="OK" /></div>';
		Modalbox.show(html, {title: 'Alert: ' + document.title, width: 300});
	},
		
	_hide: function(event) { // Internal hide method to use inside MB class
		if(event) Event.stop(event);
		this.hide();
	},
	
	_appear: function() { // First appearing of MB
		if (navigator.appVersion.match(/\bMSIE\b/))
			this._toggleSelects();
		this._setOverlay();
		this._setWidth();
		this._setPosition();
		if(this.options.transitions) {
			Element.setStyle(this.MBoverlay, {opacity: 0});
			new Effect.Fade(this.MBoverlay, {
					from: 0, 
					to: this.options.overlayOpacity, 
					duration: this.options.overlayDuration, 
					afterFinish: function() {
						new Effect.SlideDown(this.MBwindow, {
							duration: this.options.slideDownDuration, 
							afterFinish: function(){ 
								this._setPosition(); 
								this.loadContent();
							}.bind(this)
						});
					}.bind(this)
			});
		} else {
			Element.setStyle(this.MBoverlay, {opacity: this.options.overlayOpacity});
			Element.show(this.MBwindow);
			this._setPosition(); 
			this.loadContent();
		}
		this._setWidthAndPosition = this._setWidthAndPosition.bindAsEventListener(this);
		Event.observe(window, "resize", this._setWidthAndPosition);
	},
	
	resize: function(byWidth, byHeight, options) { // Change size of MB without loading content
		var wHeight = Element.getHeight(this.MBwindow);
		var wWidth = Element.getWidth(this.MBwindow);
		var hHeight = Element.getHeight(this.MBheader);
		var cHeight = Element.getHeight(this.MBcontent);
		var newHeight = ((wHeight - hHeight + byHeight) < cHeight) ? (cHeight + hHeight - wHeight) : byHeight;
		this.setOptions(options); // Passing callbacks
		if(this.options.transitions) {
			new Effect.ScaleBy(this.MBwindow, byWidth, newHeight, {
					duration: this.options.resizeDuration, 
				  	afterFinish: function() { 
						this.event("_afterResize"); // Passing internal callback
						this.event("afterResize"); // Passing callback
					}.bind(this)
				});
		} else {
			this.MBwindow.setStyle({width: wWidth + byWidth + "px", height: wHeight + newHeight + "px"});
			setTimeout(function() {
				this.event("_afterResize"); // Passing internal callback
				this.event("afterResize"); // Passing callback
			}.bind(this), 1);
			
		}
		
	},
	
	_update: function() { // Updating MB in case of wizards
		Element.update(this.MBcontent, "");
		this.MBcontent.appendChild(this.MBloading);
		Element.update(this.MBloading, this.options.loadingString);
		this.currentDims = [this.MBwindow.offsetWidth, this.MBwindow.offsetHeight];
		Modalbox.resize((this.options.width - this.currentDims[0]), (this.options.height - this.currentDims[1]), {_afterResize: this._loadAfterResize.bind(this) });
	},
	
	loadContent: function () {
		if(this.event("beforeLoad") != false) { // If callback passed false, skip loading of the content
			if(typeof this.content == 'string') {
				
				var htmlRegExp = new RegExp(/<\/?[^>]+>/gi);
				if(htmlRegExp.test(this.content)) { // Plain HTML given as a parameter
					this._insertContent(this.content);
					this._putContent();
				} else 
					new Ajax.Request( this.content, { method: this.options.method.toLowerCase(), parameters: this.options.params, 
						onComplete: function(transport) {
							var response = new String(transport.responseText);
							this._insertContent(transport.responseText.stripScripts());
							response.extractScripts().map(function(script) { 
								return eval(script.replace("<!--", "").replace("// -->", ""));
							}.bind(window));
							this._putContent();
						}.bind(this)
					});
					
			} else if (typeof this.content == 'object') {// HTML Object is given
				this._insertContent(this.content);
				this._putContent();
			} else {
				Modalbox.hide();
				throw('Please specify correct URL or HTML element (plain HTML or object)');
			}
		}
	},
	
	_insertContent: function(content){
		Element.extend(this.MBcontent);
		this.MBcontent.update("");
		if(typeof content == 'string')
			this.MBcontent.hide().update(content);
		else if (typeof this.content == 'object') { // HTML Object is given
			var _htmlObj = content.cloneNode(true); // If node already a part of DOM we'll clone it
			// If clonable element has ID attribute defined, modifying it to prevent duplicates
			if(this.content.id) this.content.id = "MB_" + this.content.id;
			/* Add prefix for IDs on all elements inside the DOM node */
			this.content.getElementsBySelector('*[id]').each(function(el){ el.id = "MB_" + el.id });
			this.MBcontent.hide().appendChild(_htmlObj);
			this.MBcontent.down().show(); // Toggle visibility for hidden nodes
		}
	},
	
	_putContent: function(){
		// Prepare and resize modal box for content
		if(this.options.height == this._options.height)
			Modalbox.resize(0, this.MBcontent.getHeight() - Element.getHeight(this.MBwindow) + Element.getHeight(this.MBheader), {
				afterResize: function(){
					this.MBcontent.show();
					this.focusableElements = this._findFocusableElements();
					this._setFocus(); // Setting focus on first 'focusable' element in content (input, select, textarea, link or button)
					this.event("afterLoad"); // Passing callback
				}.bind(this)
			});
		else { // Height is defined. Creating a scrollable window
			this._setWidth();
			this.MBcontent.setStyle({overflow: 'auto', height: Element.getHeight(this.MBwindow) - Element.getHeight(this.MBheader) - 13 + 'px'});
			this.MBcontent.show();
			this.focusableElements = this._findFocusableElements();
			this._setFocus(); // Setting focus on first 'focusable' element in content (input, select, textarea, link or button)
			this.event("afterLoad"); // Passing callback
		}
	},
	
	activate: function(options){
		this.setOptions(options);
		this.active = true;
		Event.observe(this.MBclose, "click", this.close);
		if(this.options.overlayClose) Event.observe(this.MBoverlay, "click", this.hide);
		Element.show(this.MBclose);
		if(this.options.transitions && this.options.inactiveFade) new Effect.Appear(this.MBwindow, {duration: this.options.slideUpDuration});
	},
	
	deactivate: function(options) {
		this.setOptions(options);
		this.active = false;
		Event.stopObserving(this.MBclose, "click", this.close);
		if(this.options.overlayClose) Event.stopObserving(this.MBoverlay, "click", this.hide);
		Element.hide(this.MBclose);
		if(this.options.transitions && this.options.inactiveFade) new Effect.Fade(this.MBwindow, {duration: this.options.slideUpDuration, to: .75});
	},
	
	_initObservers: function(){
		Event.observe(this.MBclose, "click", this.close);
		if(this.options.overlayClose) Event.observe(this.MBoverlay, "click", this.hide);
		Event.observe(document, "keypress", Modalbox.kbdHandler );
	},
	
	_removeObservers: function(){
		Event.stopObserving(this.MBclose, "click", this.close);
		if(this.options.overlayClose) Event.stopObserving(this.MBoverlay, "click", this.hide);
		Event.stopObserving(document, "keypress", Modalbox.kbdHandler );
	},
	
	_loadAfterResize: function() {
		this._setWidth();
		this._setPosition();
		this.loadContent();
	},
	
	_setFocus: function() { // Setting focus to be looped inside current MB
      try {
         if(this.focusableElements.length > 0) {
            var i = 0;
            var firstEl = this.focusableElements.find(function findFirst(el){
               i++;
               return el.tabIndex == 1;
            }) || this.focusableElements.first();
            this.currFocused = (i == this.focusableElements.length - 1) ? (i-1) : 0;
            firstEl.focus(); // Focus on first focusable element except close button
         } else  {

               $("MB_close").focus(); // If no focusable elements exist focus on close button

         }
      } catch (err) {}
	},
	
	_findFocusableElements: function(){ // Collect form elements or links from MB content
		var els = this.MBcontent.getElementsBySelector('input:not([type~=hidden]), select, textarea, button, a[href]');
		els.invoke('addClassName', 'MB_focusable');
		return this.MBcontent.getElementsByClassName('MB_focusable');
	},
	
	kbdHandler: function(e) {
		var node = Event.element(e);
		switch(e.keyCode) {
			case Event.KEY_TAB:
				Event.stop(e);
				if(!e.shiftKey) { //Focusing in direct order
					if(this.currFocused == this.focusableElements.length - 1) {
						this.focusableElements.first().focus();
						this.currFocused = 0;
					} else {
						this.currFocused++;
						this.focusableElements[this.currFocused].focus();
					}
				} else { // Shift key is pressed. Focusing in reverse order
					if(this.currFocused == 0) {
						this.focusableElements.last().focus();
						this.currFocused = this.focusableElements.length - 1;
					} else {
						this.currFocused--;
						this.focusableElements[this.currFocused].focus();
					}
				}
				break;			
			case Event.KEY_ESC:
				if(this.active) this._hide(e);
				break;
			case 32:
				this._preventScroll(e);
				break;
			case 0: // For Gecko browsers compatibility
				if(e.which == 32) this._preventScroll(e);
				break;
			case Event.KEY_UP:
			case Event.KEY_DOWN:
			case Event.KEY_PAGEDOWN:
			case Event.KEY_PAGEUP:
			case Event.KEY_HOME:
			case Event.KEY_END:
				// Safari operates in slightly different way. This realization is still buggy in Safari.
				if(/Safari|KHTML/.test(navigator.userAgent) && !["textarea", "select"].include(node.tagName.toLowerCase()))
					Event.stop(e);
				else if( (node.tagName.toLowerCase() == "input" && ["submit", "button"].include(node.type)) || (node.tagName.toLowerCase() == "a") )
					Event.stop(e);
				break;
		}
	},
	
	_preventScroll: function(event) { // Disabling scrolling by "space" key
		if(!["input", "textarea", "select", "button"].include(Event.element(event).tagName.toLowerCase())) 
			Event.stop(event);
	},
	
	_deinit: function()
	{	
		this._removeObservers();
		Event.stopObserving(window, "resize", this._setWidthAndPosition );
		if(this.options.transitions) {
			Effect.toggle(this.MBoverlay, 'appear', {duration: this.options.overlayDuration, afterFinish: this._removeElements.bind(this) });
		} else {
			this.MBoverlay.hide();
			this._removeElements();
		}
		Element.setStyle(this.MBcontent, {overflow: '', height: ''});
	},
	
	_removeElements: function () {
		if (navigator.appVersion.match(/\bMSIE\b/)) {
			this._prepareIE("", ""); // If set to auto MSIE will show horizontal scrolling
			window.scrollTo(this.initScrollX, this.initScrollY);
		}
		Element.remove(this.MBoverlay);
		Element.remove(this.MBwindow);
		
		/* Replacing prefixes 'MB_' in IDs for the original content */
		if(typeof this.content == 'object' && this.content.id && this.content.id.match(/MB_/)) {
			this.content.getElementsBySelector('*[id]').each(function(el){ el.id = el.id.replace(/MB_/, ""); });
			this.content.id = this.content.id.replace(/MB_/, "");
		}
		/* Initialized will be set to false */
		this.initialized = false;
		
		if (navigator.appVersion.match(/\bMSIE\b/))
			this._toggleSelects(); // Toggle back 'select' elements in IE
		this.event("afterHide"); // Passing afterHide callback
		this.setOptions(this._options); //Settings options object into intial state
	},
	
	_setOverlay: function () {
		if (navigator.appVersion.match(/\bMSIE\b/)) {
			this._prepareIE("100%", "hidden");
			if (!navigator.appVersion.match(/\b7.0\b/)) window.scrollTo(0,0); // Disable scrolling on top for IE7
		}
	},
	
	_setWidth: function () { //Set size
		Element.setStyle(this.MBwindow, {width: this.options.width + "px", height: this.options.height + "px"});
	},
	
	_setPosition: function () {
		Element.setStyle(this.MBwindow, {left: Math.round((Element.getWidth(document.body) - Element.getWidth(this.MBwindow)) / 2 ) + "px"});
	},
	
	_setWidthAndPosition: function () {
		Element.setStyle(this.MBwindow, {width: this.options.width + "px"});
		this._setPosition();
	},
	
	_getScrollTop: function () { //From: http://www.quirksmode.org/js/doctypes.html
		var theTop;
		if (document.documentElement && document.documentElement.scrollTop)
			theTop = document.documentElement.scrollTop;
		else if (document.body)
			theTop = document.body.scrollTop;
		return theTop;
	},
	// For IE browsers -- IE requires height to 100% and overflow hidden (taken from lightbox)
	_prepareIE: function(height, overflow){
		var body = document.getElementsByTagName('body')[0];
		body.style.height = height;
		body.style.overflow = overflow;
  
		var html = document.getElementsByTagName('html')[0];
		html.style.height = height;
		html.style.overflow = overflow; 
	},
	// For IE browsers -- hiding all SELECT elements
	_toggleSelects: function() {
		var selects = $$("select");
		if(this.initialized) {
			selects.invoke('setStyle', {'visibility': 'hidden'});
		} else {
			selects.invoke('setStyle', {'visibility': ''});
		}
			
	},
	event: function(eventName) {
		if(this.options[eventName]) {
			var returnValue = this.options[eventName](); // Executing callback
			this.options[eventName] = null; // Removing callback after execution
			if(returnValue != undefined) 
				return returnValue;
			else 
				return true;
		}
		return true;
	}
}

Object.extend(Modalbox, Modalbox.Methods);

if(Modalbox.overrideAlert) window.alert = Modalbox.alert;

Effect.ScaleBy = Class.create();
Object.extend(Object.extend(Effect.ScaleBy.prototype, Effect.Base.prototype), {
  initialize: function(element, byWidth, byHeight, options) {
    this.element = $(element)
    var options = Object.extend({
	  scaleFromTop: true,
      scaleMode: 'box',        // 'box' or 'contents' or {} with provided values
      scaleByWidth: byWidth,
	  scaleByHeight: byHeight
    }, arguments[3] || {});
    this.start(options);
  },
  setup: function() {
    this.elementPositioning = this.element.getStyle('position');
      
    this.originalTop  = this.element.offsetTop;
    this.originalLeft = this.element.offsetLeft;
	
    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];
	  
	this.deltaY = this.options.scaleByHeight;
	this.deltaX = this.options.scaleByWidth;
  },
  update: function(position) {
    var currentHeight = this.dims[0] + (this.deltaY * position);
	var currentWidth = this.dims[1] + (this.deltaX * position);
	
	currentHeight = (currentHeight > 0) ? currentHeight : 0;
	currentWidth = (currentWidth > 0) ? currentWidth : 0;
	
    this.setDimensions(currentHeight, currentWidth);
  },

  setDimensions: function(height, width) {
    var d = {};
    d.width = width + 'px';
    d.height = height + 'px';
    
	var topd  = Math.round((height - this.dims[0])/2);
	var leftd = Math.round((width  - this.dims[1])/2);
	if(this.elementPositioning == 'absolute' || this.elementPositioning == 'fixed') {
		if(!this.options.scaleFromTop) d.top = this.originalTop-topd + 'px';
		d.left = this.originalLeft-leftd + 'px';
	} else {
		if(!this.options.scaleFromTop) d.top = -topd + 'px';
		d.left = -leftd + 'px';
	}
    this.element.setStyle(d);
  }
});
/*--------------------------------------------------------------------------*/
///applications/picknpay/custom/tags/loggedInUser/js/loggedInUser.js
/*--------------------------------------------------------------------------*/
declarePackage("picknpay");
declarePackage("picknpay.tags");

picknpay.tags.LoggedInUser = function() {
	var self;
	
	// constructor function
	function constructorFn() {
		self = this;
	}
	
	constructorFn.prototype.checkLoginState = function() {		
		var loggedInDivId = arguments[1];
		var loggedOutDivId = arguments[2];
		var uniqueId = arguments[3];
		
		$(loggedInDivId).style.display = "none";
		$(loggedOutDivId).style.display = "none";
		
		if (ccs.user.isLoggedIn) {
			$(uniqueId).style.display = "block";
			$(uniqueId).innerHTML = $(loggedInDivId).innerHTML;
		} else {
			$(loggedOutDivId).style.display = "block";
		}		
	}
	
	constructorFn.prototype.addItemToLoggedInUserProfile = function(fieldName, objectId, callbackFunction) {	
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/custom/tags/loggedInUser/add_item_to_profile.json?object_id=" + objectId + "&field_name=" + fieldName,
		{
			method:'post',

			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
				
				if (res.success = false) {
					alert("Error adding Related Item (id:" + objectId + ") to Logged In User Profile. " + res.message);
				} else {					
					callbackFunction();
				}
			},
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});	
	}
	
	constructorFn.prototype.addItemToLoggedInUserShoppingList = function(fieldName, objectId, selected, callbackFunction) {	
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/custom/tags/loggedInUser/add_item_to_shopping_list.json?object_id=" + objectId + "&field_name=" + fieldName + "&selected=" + selected,
		{
			method:'post',

			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
				
				if (res.success = false) {
					alert("Error adding Related Item (id:" + objectId + ") to Logged In User's Shopping Lost. " + res.message);
				} else {					
					callbackFunction();
				}
			},
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});	
	}
	
	return new constructorFn();
}

picknpay.tags.liu = new picknpay.tags.LoggedInUser();
/*--------------------------------------------------------------------------*/
///applications/picknpay/templates/js/helpful_scripts.js
/*--------------------------------------------------------------------------*/
function showDiv(id) {
	document.getElementById(id).style.display = "block";
}

function hideDiv(id) {
	document.getElementById(id).style.display = "none";
}


function sitePopup(url) {  
 lrgWindow=window.open(url,"pic","scrollbars=yes,menubar=no,width=500,height=500,resizable=no");  
}

function sitePopupLarge(url) {  
 lrgWindow=window.open(url,"pic","scrollbars=yes,menubar=no,width=960,height=620,resizable=no");  
}


function sitePopupSmall(url) {  
 lrgWindow=window.open(url,"pic","scrollbars=yes,menubar=no,width=535,height=350,resizable=no");  
}

function printWindow() {
bV = parseInt(navigator.appVersion);
if (bV >= 4) window.print();
}

function sitePopupPrint(url) {  
 lrgWindow=window.open(url,"pic","scrollbars=yes,menubar=no,width=630,height=480,resizable=yes");  
 lrgWindow.print();
}

function sitePopupPrintLandscape(url) {  
 lrgWindow=window.open(url,"pic","scrollbars=yes,menubar=no,width=800,height=600,resizable=yes");  
 lrgWindow.print();
}

function show(element) {
	document.getElementById(element).style.visibility="visible";
	document.getElementById(element).style.display = 'block';
}

function hide(element) {
	document.getElementById(element).style.visibility="hidden";
	document.getElementById(element).style.display = 'none';
}

function spawn_window(content,spawn,sizing)
{window.open(content,spawn,sizing);}

function startPopEvent(PopEvent)
  {
    var desktop=window.open(PopEvent,"_blank","toolbar=yes,location=yes,status=yes,menubar=yes,scrollbars=yes,width=600,height=350,resizable");
  }
function startPop(PopEvent)
  {
    var desktop=window.open(PopEvent,"_blank","toolbar=no,location=no,status=no,menubar=no,scrollbars=yes,width=600,height=350,resizable");
  }
function goClose(sURL) {
window.opener.location=sURL;
self.close();
}

var lastNav;
	
// Switching sub-nav
function step(screenName) {
	if (lastNav) {
		document.getElementById(lastNav).style.display = 'none';
		document.getElementById(lastNav).style.visibility = 'hidden';
	}

	document.getElementById(screenName).style.display = 'block';
	document.getElementById(screenName).style.visibility = 'visible';
	lastNav = screenName;
}
	
// Switching sub-nav off
function stepOff(screenName) {
	document.getElementById(screenName).style.display = 'none';
	document.getElementById(screenName).style.visibility = 'hidden';
	lastNav = screenName;
}
	
function MM_preloadImages() { //v3.0
		var a=MM_preloadImages.arguments;
  var d=document; 
  if (d.images) { 
  		if(!d.MM_p) d.MM_p=new Array();
  		var i;
		var j=d.MM_p.length;
  		for(i=0;i < a.length; i++) {
    		if (a[i].indexOf("#")!=0){ 
				d.MM_p[j]=new Image; 
				d.MM_p[j++].src=a[i];
			}
		}	
	}
}

function MM_findObj(n, d) { //v3.0
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&id.layers.length;i++) x=MM_findObj(n,d.layers[i].document); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}

function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

/*var urlAddress = "http://www.moneyweb.co.za"; 
var pageName = "Moneyweb"; 
	function addToFavorites() { 
		if (window.external) { 
			window.external.AddFavorite(urlAddress,pageName) 
		} else { 
			alert("Press CTRL-D (Netscape or FireFox) or CTRL-T (Opera) to bookmark"); 
		} 
	} 
*/


// function for passing urls to flash and tracking pop-ups
function flashURLcall(URL,trackingCode) {
	if (URL.indexOf('www') == 0) {
//		var win = window.open("http://" + URL);
		location.href="http://" + URL;
	} else {
		location.href=URL;
//		var win = window.open(URL);

	}
}
/*--------------------------------------------------------------------------*/
///modletInclude/shopping_list/js/shoppingList.js
/*--------------------------------------------------------------------------*/
/**
 * @author phillipa
 */

declarePackage("picknpay");
declarePackage("picknpay.modlets");
picknpay.modlets.ShoppingList = function() {
	var self;	
	var selected = [];	
	var saveStates = ["none", "saving", "saved"];
	var currentSaveState = saveStates[0];
	var timeOutId = -1;
	var timeOutTime = 5000;
	var currentlySaving = false;
	var calledMidSave = false;
	var generalItems = {};	
	var nextStepIntervalId = -1;
	var currentListing = "departmental_listing";	
	var recipeParametersForIndexSearch = "";
	
	function constructorFn(){
		self = this;
	}
	
	function addSelected(value, state) {
		var found = false;
		for (var i=0; i<selected.length && !found; i++) {
			if (selected[i] == value) {
				found = true;
				if (!state) {
					// remove value from array
					selected.splice(i, 1);
				} else {
					// do nothing, it's already in the array
				}
			}
		}
		
		// if it's selected and it wasn't found, add it to the array now
		if (!found && state) {
			selected.push(value);
		}
		
		// if the selected state of something changes while the save method is currently saving, set calledMidSave to true
		if (currentlySaving) {
			calledMidSave = true;
		}
	}
	
	// have added this in to ensure that the ajax method updating the shopping list doesn't overwrite itself
	// every time a user clicks a checkbox, it will move the shopping list into a "saving" state. 
	// every time this happens, it'll reset the timeout for the call to the save method.
	function setSaveState(state) {
		$(currentSaveState + "_top").style.display = "none";
		$(currentSaveState + "_bottom").style.display = "none";
		currentSaveState = state;
		$(currentSaveState + "_top").style.display = "block";
		$(currentSaveState + "_bottom").style.display = "block";
		if (state != saveStates[2]) {
			if (timeOutId == -1) {
				timeOutId = setTimeout(function() {self.saveSelection();}, timeOutTime);
			} else {
				clearTimeout(timeOutId);
				timeOutId = setTimeout(function() {self.saveSelection();}, timeOutTime);
			}
		}
	}
	
	constructorFn.prototype.switchRecipeState = function(divId, headerId) {
		var show = $(divId + "_display").style.display == "none" ;
		
		if (show) {
			// open clicked item
			$(divId + "_header").src = $(divId + "_header").src.replace("_closed", "_open");
			$(headerId).setAttribute("className", "shopping_list_recipe_open");
			$(headerId).setAttribute("class", "shopping_list_recipe_open");
			Effect.BlindDown(divId + "_display");
			
			// close other items
			/*for (var i=0; i < divIds.length; i++) {
				if (divIds[i] != divId) {
					$(divIds[i] + "_header").src = $(divIds[i] + "_header").src.replace("_open", "_closed");
					Effect.BlindUp(divIds[i] + "_display");
				}				
			}*/
		} else {
			$(divId + "_header").src = $(divId + "_header").src.replace("_open", "_closed");
			$(headerId).setAttribute("className", "shopping_list_recipe_closed");
			$(headerId).setAttribute("class", "shopping_list_recipe_closed");
			Effect.BlindUp(divId + "_display");
		}
	}
	
	constructorFn.prototype.loadSection = function(sectionName) {
		$(sectionName).innerHTML = "<div class='shoplist_spinner'><img src='" + ccs.templatePath + "images/ajax-loader.gif'/></div>";
		cambrient.loadFragmentVar('/modletInclude/shopping_list/fragments/' + sectionName, function(template) {		
			new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/get_" + sectionName + ".json",
			{
				method:'post',
				
				onSuccess: function(reply) {
					if (reply.responseText) {		
						response = reply.responseText.evalJSON();
						if (response.success) {
							if (sectionName == 'general_items') {
								generalItems = reply.responseText.evalJSON();
							}
							
							if (response.selected != null && response.selected.length > 0) {
								var selectedItems = response.selected.split(",");
								for (var i=0; i<selectedItems.length; i++) {
									addSelected(selectedItems[i], true);
								}
							}
							
							$(sectionName).innerHTML = cambrient.processTemplate(template, response);
							//styleCheckboxesAndRadiobuttons();

						} else {
							console(res.message);
						}
					}
				},
						
				onFailure: function(transport) {
					var err = transport.responseText.evalJSON();
					if (err != null && err.error) {
						alert(err.message);
					} else {
						alert("Error speaking to server:" + transport.responseText);
					}
				}
			});
		});
	}
	
	constructorFn.prototype.tickAll = function(checkAll, elementName, chainChangeEvents) {
		/*if (tick != null) {
			checkAll.checked = !checkAll.checked;
		}*/
		if (currentSaveState != saveStates[1]) {
			setSaveState(saveStates[1]);
		}
		
		var checkedState = false;
		if (checkAll.checked) {
			checkedState = true;
		}
		addSelected(checkAll.value, checkedState);
		if (elementName.startsWith('general')) {
			generalItems.checkAll = checkedState;
		}
		
		var elements = document.getElementsByName(elementName);
		for (var i=0; i < elements.length; i++) {
			elements[i].checked = checkedState;
			addSelected(elements[i].value, checkedState);
			if (elementName.startsWith('general')) {
				for (var j=0; j<generalItems.generalItems.length; j++) {
					if (generalItems.generalItems[j].name == elements[i].value) {
						generalItems.generalItems[j].selected = checkedState;
					}
				}
			}
			
			if (chainChangeEvents) {
				elements[i].onchange();
			}
		}
	}
	
	constructorFn.prototype.tickRecipe = function(me, parentName) {
		/*if (tick != null) {
			me.checked = !me.checked;
		}*/
		if (currentSaveState != saveStates[1]) {
			setSaveState(saveStates[1]);
		}
		// handle "check all recipes" tickbox
		if (!me.checked && document.getElementsByName(parentName)[0].checked) {
			document.getElementsByName(parentName)[0].checked = false;
			addSelected(document.getElementsByName(parentName)[0].value, false);
		} 
		// handle "check all ingredients" tickbox
		addSelected(me.value, me.checked);
	}
	
	constructorFn.prototype.tickMe = function(me, parentName, parentValue, tick) {
		if (tick != null) {
			me.checked = !me.checked;
		}
		if (currentSaveState != saveStates[1]) {
			setSaveState(saveStates[1]);
		}
		addSelected(me.value, me.checked);
		if (parentName != null && parentName.startsWith('general')) {
			for (var j=0; j<generalItems.generalItems.length; j++) {
				if (generalItems['generalItems'][j].name == me.value) {
					generalItems.generalItems[j].selected = me.checked;
				}
			}
		}
		
		if (parentName != null) {
			if (parentValue == null) {
				if (document.getElementsByName(parentName)[0].checked) {
					document.getElementsByName(parentName)[0].checked = false;
					addSelected(document.getElementsByName(parentName)[0].value, false);
					if (parentName.startsWith('general')) {
						generalItems.checkAll = false;
					}
				}
			} else {
				var parentItems = document.getElementsByName(parentName);
				for (var i=0; i < parentItems.length; i++) {
					if (parentItems[i].value == parentValue) {
						// this will check if the recipe has "check all ingredients" ticked
						if (parentItems[i].checked) {
							parentItems[i].checked = false;
							picknpay.modlets.shopList.tickRecipe(parentItems[i], 'recipes_check_all');
						}
					}
				}
			}
		}
	}
	
	constructorFn.prototype.saveBeforeNextStep = function(nextStepPage) {
		// check that the save method is not in the middle of saving when step 2 button is clicked. 
		// if it is currently saving, keep calling this method until it's finished saving
		// during this time, the cursor should be set to the wait icon.
		// Then save one last time before moving to the next page  
		if (!currentlySaving) {
			if (nextStepIntervalId > -1) {
				clearTimeout(nextStepIntervalId);
			}
			self.saveSelection(function() {window.location=nextStepPage});
		} else if (nextStepIntervalId == -1) {
			nextStepIntervalId = setInterval(function() {self.saveBeforeNextStep();}, 1000);
			document.body.style.cursor = "wait";
		}
	}
	
	constructorFn.prototype.saveSelection = function(callbackFunction) {
		if (!currentlySaving) {	
			currentlySaving = true;
			//var queryString = "";
			//for (var i=0; i<selected.length; i++) {
			//	queryString += "&select=" + selected[i]; 
			//}
			

			var parameters = new Object();
			parameters['general_items'] = Object.toJSON(generalItems);
			parameters['select'] = new Array();
			for (var i=0; i<selected.length; i++) {
				parameters['select'][i] = selected[i]; 
			}

			//new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/save_check_state.json?general_items=" + Object.toJSON(generalItems) + queryString,
			new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/save_check_state.json",
			{
				method:'post',
				parameters : parameters,
				
				onSuccess: function(reply) {
					if (reply.responseText) {		
						response = reply.responseText.evalJSON();
						if (!response.success) {
							console(res.message);
						} else {							
							if (calledMidSave) {
								clearTimeout(timeOutId);
								timeOutId = setTimeout(function() {self.saveSelection();}, timeOutTime);
								calledMidSave = false;
							} else {
								if (currentSaveState != saveStates[2]) {
									timeOutId = -1;
									setSaveState(saveStates[2]);
								}
								if (callbackFunction != null) {
									callbackFunction();
								}
							}
						}
						currentlySaving = false;
						
					}
				},
						
				onFailure: function(transport) {
					var err = transport.responseText.evalJSON();
					if (err != null && err.error) {
						alert(err.message);
					} else {
						alert("Error speaking to server:" + transport.responseText);
					}
					currentlySaving = false;
				}
			});
		}
	}
	
	constructorFn.prototype.deleteFromList = function(id, fieldName, sectionName) {
		setSaveState(saveStates[1]);
		
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/remove_from_list.json?oid=" + id + "&fieldName=" + fieldName,
		{
			method:'post',
			
			onSuccess: function(reply) {
				if (reply.responseText) {		
					response = reply.responseText.evalJSON();
					if (response.success) {
						self.loadSection(sectionName);
						if (sectionName == "recipes") {
							self.loadSection("recipe_book");
						}
					} else {
						// ??
					}
				}
			},
					
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});						
	}
	
	function loadGeneralItemsFromJSObj() {
		cambrient.loadFragmentVar('/modletInclude/shopping_list/fragments/general_items', function(template) {
			$('general_items').innerHTML = cambrient.processTemplate(template, generalItems);
		});
	}
	
	constructorFn.prototype.addGeneralItem = function(id, name, department) {
		setSaveState(saveStates[1]);
		if (name != null && name.length > 0 && name != "Enter Item Name") {		
			// check if it already exists
			var foundIndex = -1;
			if (id == null || id.length < 1) {
				id = name;
			}
			for (var i=0; i<generalItems['generalItems'].length && foundIndex < 0; i++) {
				if (generalItems['generalItems'][i].name == id) {
					foundIndex = i;
				}
			}			
			
			var newItem = {};
			if (foundIndex > -1) {
				newItem = generalItems['generalItems'][foundIndex];
			}
			
			newItem.name = name;
			newItem.department = department;
			
			if (foundIndex > -1) {
				// if it's an edit, leave the item's selected status as it was
				
				// if it was selected but they changed the name then also update the selected array
				if (newItem.selected && id != name) {
					addSelected(id, false);
					addSelected(name, true);
				}
				
				generalItems['generalItems'][foundIndex] = newItem;
			} else {
				// if it's a new item, pre-select the item
				newItem.selected = true;
				addSelected(newItem.name, true);
				generalItems['generalItems'].push(newItem);
			}
						
			loadGeneralItemsFromJSObj();
			
			// reset add area
			$('item_id').value = "";
			$('item_name').value = "Enter Item Name";
			$('item_department_list').selectedIndex = 0;
			$('item_department_' + department).selected = false;
		} else {
			alert("Please Enter an Item Name before clicking Add");
		}
	}
	
	constructorFn.prototype.deleteGeneralItem = function(name) {
		setSaveState(saveStates[1]);
		
		// find item
		var foundIndex = -1;
	
		for (var i=0; i<generalItems['generalItems'].length && foundIndex < 0; i++) {
			if (generalItems['generalItems'][i].name == name) {
				foundIndex = i;
			}
		}
		
		generalItems['generalItems'].splice(foundIndex, 1);
		addSelected(name, false);
		loadGeneralItemsFromJSObj();		
	}
	
	constructorFn.prototype.loadListing = function(listingType) {
		$("shopping_list").innerHTML = "<img src='" + ccs.templatePath + "images/ajax-loader.gif'/>";
		currentListing = listingType;
		cambrient.loadFragmentVar('/modletInclude/shopping_list/fragments/' + listingType, function(template) {		
			new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/get_" + listingType + ".json",
			{
				method:'post',
				
				onSuccess: function(reply) {
					if (reply.responseText) {		
						response = reply.responseText.evalJSON();
						if (response.success) {			
							if (response.selected != null && response.selected.length > 0) {
								var selectedItems = response.selected.split(",");
								for (var i=0; i<selectedItems.length; i++) {
									addSelected(selectedItems[i], true);
								}
							}
							if (response.generalItems != null && response.generalItems.length > 0) {
								generalItems = response.generalItems.evalJSON();
							}
							
							for (var i=0; i<response.recipes.length; i++) {								
								recipeParametersForIndexSearch += "&recipe_id=" + response.recipes[i].id;
							}
							
							$("shopping_list").innerHTML = cambrient.processTemplate(template, response);							
						} else {
							console(res.message);
						}
					}
				},
						
				onFailure: function(transport) {
					var err = transport.responseText.evalJSON();
					if (err != null && err.error) {
						alert(err.message);
					} else {
						alert("Error speaking to server:" + transport.responseText);
					}
				}
			});
		});
	}
	
	constructorFn.prototype.removeFromListing = function(listingTableId, selectedItems, rowIndex) {
		$(listingTableId).deleteRow(rowIndex);
		
		if (selectedItems != null) {
			var selectedItems = selectedItems.split(",");
			for (var i=0; i<selectedItems.length; i++) {
				var itemCode = selectedItems[i];
				addSelected(itemCode, false);
				
				// check if it's a general item as well
				var found = false;				
				for (var j=0; j<generalItems['generalItems'].length && !found; j++) {
					if (generalItems['generalItems'][j].name == itemCode) {
						generalItems['generalItems'][j].selected = false;
						foundIndex = true;
						generalItems.checkAll = false;
					}
				}
				
				setSaveState(saveStates[1]);				
			}			
		}			
	}
	
	constructorFn.prototype.switchListing = function(newListingType) {
		if (newListingType != currentListing) {
			$(newListingType + "_button").src = $(newListingType + "_button").src.replace("_inactive", "_active");
			$(currentListing + "_button").src = $(currentListing + "_button").src.replace("_active", "_inactive");
			self.loadListing(newListingType);			
		}
	}
	
	/*
	constructorFn.prototype.emailShoppingList = function() {
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/get_email_details.json",
		{
			method:'post',
			
			onSuccess: function(reply) {
				if (reply.responseText) {		
					response = reply.responseText.evalJSON();
					if (response.success) {		
						
						var img = new Image();		
						img.src = response.baseUrl + "/email/picknpay/en/page8283?ccsemail_to=" + response.email + "&ccsemail_from=zoe@cambrient.com&ccsemail_subject=Your%20Shopping%20List&listing_type=" + currentListing;
						alert("An email has been sent to you at " + response.email);		
						
					} else {
						console(res.message);
					}
				}
			},
					
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});		
	}
	*/
	
	constructorFn.prototype.emailShoppingList = function() {	
		ccs.user.loadUserData(picknpay.modlets.shopList.sendEmail);
	}
	
	constructorFn.prototype.sendEmail = function() {	
		var img = new Image();		
		img.src = ccs.contextPath + "/email/picknpay/en/page8283?ccsemail_to=" + ccs.user.emailAddress + "&ccsemail_replyto=noreply@picknpay.co.za&ccsemail_from=noreply@picknpay.co.za&ccsemail_subject=Your%20Shopping%20List&listing_type=" + currentListing;
		alert("An email has been sent to you at " + ccs.user.emailAddress);
	}
	
	constructorFn.prototype.printShoppingListWithRecipes = function(userId) {
      var url = "shopping-list-recipe-print?listing_type=" + currentListing + (recipeParametersForIndexSearch.length > 0 ? recipeParametersForIndexSearch : "&recipe_id=-1");
      url += "&userId=" + userId; //The pdf creator doesn't have session info, so can't get the user.
		console.log(url);
		printUrl(url);

	}

	constructorFn.prototype.printShoppingListWithoutRecipes = function(userId) {
      var url = "shopping-list-print?listing_type=" + currentListing 
      url += "&userId=" + userId; //The pdf creator doesn't have session info, so can't get the user.
		console.log(url);
		printUrl(url);

	}

	constructorFn.prototype.showDivIfHasRecipes = function(divId) {
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/shopping_list/get_recipe_count.json",
		{
			method:'post',
			
			onSuccess: function(reply) {
				if (reply.responseText) {		
					response = reply.responseText.evalJSON();
					if (response.success) {		
						
						if (response.count > 0) {
							$(divId).style.display = "block";
						} else {
							$(divId).style.display = "none";
						}
						
					} else {
						console(res.message);
					}
				}
			},
					
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});
	}	
	
	return new constructorFn();	
}

picknpay.modlets.shopList = new picknpay.modlets.ShoppingList();
/*--------------------------------------------------------------------------*/
///shared/content/facebook/js/facebook.js
/*--------------------------------------------------------------------------*/
ccs.Facebook = function() {
	var self;
	
	// constructor function
	function constructorFn() {
		self = this;
	}
	
	constructorFn.prototype.init = function(apiKey, contextPath) {	
		FB.init(apiKey, contextPath + "/shared/content/facebook/xd_receiver.htm");		
	}
	
	constructorFn.prototype.postLogin = function() {
		// updateUserBox();
		var facebookUID = FB.Connect.get_loggedInUser();		
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/set_user_facebook_status.json?facebook_uid=" + facebookUID,
		{
			method:'post',

			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
				
				if (res.success = false) {
					alert("Error storing Facebook UID");
				}
			},
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});	
	}	
	
	constructorFn.prototype.connect = function(clipId) {		
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/get_user_facebook_status.json",
		{
			method:'post',

			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
				
				if (res.userLoggedIn == true) {					
					if (res.connectedToFacebook == true) {
						FB.ensureInit(function() {
							FB.Connect.get_status().waitUntilReady(function(status) {
								   switch(status) {
								   case FB.ConnectState.connected:
									   if (res.facebookUID > 0) {									   
										   // Logged into PnP, connected to FB and logged into FB > nothing
										   // updateUserBox();
									   } else {
										   ccs.fb.postLogin();
									   }
									   break;
								   case res.facebookUID > 0 && FB.ConnectState.userNotLoggedIn:								  
								   case FB.ConnectState.appNotAuthorized:
									default:
										$("fb_connect_" + clipId).style.display = "block";
										break;
								   }
								 });
						});
					} else {
						// user is not connected to FB yet ...
						$("fb_connect_" + clipId).style.display = "block";
					}
				} else {
					// do nothing, user not logged into ccs
				}
			},
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});		
	}
	
	/*
	function updateUserBox() { 
		$("fb_connect").style.display = "none";
		var user_box = $("user_box"); 
		// add in some XFBML. note that we set useyou=false so it doesn't display "you"
		user_box.innerHTML = "<span>" + "<fb:profile-pic uid='loggedinuser' facebook-logo='true'></fb:profile-pic>" + 
			"Welcome, <fb:name uid='loggedinuser' useyou='false'></fb:name>. You are signed in with your Facebook account." + 
			"</span>"; 
		// because this is XFBML, we need to tell Facebook to re-process the document 
		FB.XFBML.Host.parseDomTree(); 
	} 
	*/
	
	constructorFn.prototype.getAppFriends = function(confName, fragmentUrl, divId, spinnerDivId, displayWarning) {
		cambrient.loadFragmentVar(fragmentUrl, function(template) {			
			new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/get_app_friends.json?conf_name=" + confName,
				{
					method:'post',
			
					onSuccess: function(reply) {				
						if (reply.responseText) {		
							response = reply.responseText.evalJSON();
							response.warning = "";
							if (displayWarning) {
								response.warning = "WARNING: Your Facebook User is not associated with this PnP User."
							}
							if (spinnerDivId) {
								$(spinnerDivId).style.display = "none";
							}
							$(divId).innerHTML = cambrient.processTemplate(template, response);
							FB.XFBML.Host.parseDomTree();
						}
					},
					
					onFailure: function(transport) {
						var err = transport.responseText.evalJSON();
						if (err != null && err.error) {
							alert(err.message);
						} else {
							alert("Error speaking to server:" + transport.responseText);
						}
					}
				});
				
		});
	}
	
	constructorFn.prototype.checkReadStreamPermission = function(confName, divId) {
		FB.ensureInit(function() {
			FB.Connect.showPermissionDialog("read_stream", function(divId) {
				new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/get_app_friends_feed.json?conf_name=" + confName,
				{
					method:'post',
		
					onSuccess: function(transport) {
						
						var res = transport.responseText.evalJSON();
										
					},
					onFailure: function(transport) {
						var err = transport.responseText.evalJSON();
						if (err != null && err.error) {
							alert(err.message);
						} else {
							alert("Error speaking to server:" + transport.responseText);
						}
					}
				});				
			});			
		});
	}
	
	constructorFn.prototype.logActivity = function(contextPath, oid, fieldName, activity, detailPage, detailScheme) {
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/get_log_details.json?oid=" + oid + "&field_name=" + fieldName + "&activity=" + activity + "&detail_page=" + detailPage + "&detail_scheme=" + detailScheme,
		{
			method:'post',

			onSuccess: function(transport) {
				
				var res = transport.responseText.evalJSON();
				
				if (res.success) {
					var logimg = new Image();
					//console.log(contextPath + '/eventLogServlet?type=application_event&table=pnp_facebook_activity&facebook_uid=' + res.facebookUID + '&activity=' + activity + "&url=" + res.url + "&linkText=" + res.linkText);
			        logimg.src = contextPath + '/eventLogServlet?type=application_event&table=pnp_facebook_activity&facebook_uid=' + res.facebookUID + '&activity=' + activity + "&url=" + res.url + "&linkText=" + res.linkText;
				}
								
			},
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});			
	}
	
	return new constructorFn();
}

ccs.fb = new ccs.Facebook();
/*--------------------------------------------------------------------------*/
///modletInclude/facebook_activity/js/facebookActivity.js
/*--------------------------------------------------------------------------*/
declarePackage("picknpay");
declarePackage("picknpay.modlets");

picknpay.modlets.FacebookActivity = function() {
	var self;
	
	// constructor function
	function constructorFn() {
		self = this;
	}
	
	constructorFn.prototype.checkLoginState = function() {
		var facebookKey = arguments[1];
		var contextPath = arguments[2];
		
		if (ccs.user.isLoggedIn) {
			// Logged into PnP > check FB connection status
			
			ccs.fb.init(facebookKey, contextPath);
			picknpay.modlets.fbActivity.checkFBConnect();
		} else {
			// Not logged into PnP > show "log_into_ccs" view
			$("activity_facebook_loading").style.display = "none";
			$("activity_log_into_ccs").style.display = "block";
		}
	}
	
	constructorFn.prototype.checkFBConnect = function() {		
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/get_user_facebook_status.json",
		{
			method:'post',
			
			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
					
				if (res.userLoggedIn == true) {
					if (res.connectedToFacebook == true) {					
						FB.ensureInit(function() {												
							FB.Connect.get_status().waitUntilReady(function(status) {
								switch(status) {
									case FB.ConnectState.connected:										
										$('activity_connected_fb').style.display = "block";
										getFriendActivity("fln", FB.Connect.get_loggedInUser() != res.facebookUID);
										
										break;
									case res.facebookUID > 0 && FB.ConnectState.userNotLoggedIn:
									case FB.ConnectState.appNotAuthorized:
									default:
										$("activity_facebook_loading").style.display = "none";
										$("activity_not_connected_fb").style.display = "block";
										break;
								}
							});
						});
					} else {
						$("activity_facebook_loading").style.display = "none";
						$("activity_not_connected_fb").style.display = "block";
					}
				} else {
					// do nothing, user not logged in - should not reach this
				}
			},
					
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});	
	}
	
	function getFriendActivity(confName, displayWarning) {
		cambrient.loadFragmentVar('/modletInclude/facebook_activity/fragments/friend_activity', function(template) {		
			new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/modules/facebook_activity/get_friend_activity.json?conf_name=" + confName,
			{
				method:'post',
				
				onSuccess: function(reply) {
					if (reply.responseText) {		
						response = reply.responseText.evalJSON();						
						response.warning = "";
						if (displayWarning) {
							response.warning = "WARNING: Your Facebook User is not associated with this PnP User."
						}
						$("activity_facebook_loading").style.display = "none";
						$('activity_connected_fb').innerHTML = cambrient.processTemplate(template, response);
						FB.XFBML.Host.parseDomTree();
					}
				},
						
				onFailure: function(transport) {
					var err = transport.responseText.evalJSON();
					if (err != null && err.error) {
						alert(err.message);
					} else {
						alert("Error speaking to server:" + transport.responseText);
					}
				}
			});
		});		
	}
	
	constructorFn.prototype.postLogin = function() {
		$("activity_facebook_loading").style.display = "block";
		$('activity_connected_fb').style.display = "block";
		$("activity_not_connected_fb").style.display = "none";
		getFriendActivity("fln");
	}
	
	return new constructorFn();	
}

picknpay.modlets.fbActivity = new picknpay.modlets.FacebookActivity();
/*--------------------------------------------------------------------------*/
///modletInclude/facebook_friends/js/facebookFriends.js
/*--------------------------------------------------------------------------*/
declarePackage("picknpay");
declarePackage("picknpay.modlets");

picknpay.modlets.FacebookFriends = function() {
	var self;
	
	// constructor function
	function constructorFn() {
		self = this;
	}
	
	constructorFn.prototype.checkLoginState = function() {	
		var facebookKey = arguments[1];
		var contextPath = arguments[2];
		
		if (ccs.user.isLoggedIn) {
			// Logged into PnP > hand over to facebook js
			ccs.fb.init(facebookKey, contextPath);
			self.getAppFriends();
		} else {
			// Not logged into PnP > show "log_into_ccs" view
			$("friends_facebook_loading").style.display = "none";
			$("friends_log_into_ccs").style.display = "block";
		}
	}
	
	constructorFn.prototype.getAppFriends = function() {
		new Ajax.Request(ccs.contextPath + "/json/" + ccs.appName + "/" + ccs.languageCode + "/content/facebook/get_user_facebook_status.json",
		{
			method:'post',
			
			onSuccess: function(transport) {
				var res = transport.responseText.evalJSON();
					
				if (res.userLoggedIn == true) {
					if (res.connectedToFacebook == true) {
					
						FB.ensureInit(function() {
							FB.Connect.get_status().waitUntilReady(function(status) {
								switch(status) {
									case FB.ConnectState.connected:
										$('friends_connected_fb').style.display = "block";
										ccs.fb.getAppFriends("fln", "/modletInclude/facebook_friends/fragments/friends", "facebookFriends",
												"friends_facebook_loading", FB.Connect.get_loggedInUser() != res.facebookUID);
																			
										break;
									case res.facebookUID > 0 && FB.ConnectState.userNotLoggedIn:
									case FB.ConnectState.appNotAuthorized:
									default:
										$("friends_facebook_loading").style.display = "none";
										$("friends_not_connected_fb").style.display = "block";
										break;
								}
							});
						});
					} else {
						$("friends_facebook_loading").style.display = "none";
						$("friends_not_connected_fb").style.display = "block";
					}
				} else {
					// do nothing, user not logged in - should not reach this
				}
			},
					
			onFailure: function(transport) {
				var err = transport.responseText.evalJSON();
				if (err != null && err.error) {
					alert(err.message);
				} else {
					alert("Error speaking to server:" + transport.responseText);
				}
			}
		});		
	}
	
	constructorFn.prototype.postLogin = function() {
		$('friends_connected_fb').style.display = "block";
		$("friends_not_connected_fb").style.display = "none";
		ccs.fb.getAppFriends("fln", "/modletInclude/facebook_friends/fragments/friends", "facebookFriends", "friends_facebook_loading");
	}
	
	/*constructorFn.prototype.showFriendSelector = function(baseUrl, contextPath, templatePath) {
		var inviteFriendsBox = new lightbox($('lightLink')); 
		inviteFriendsBox.activate();
		FB.ensureInit(function() {
			cambrient.loadFragmentVar('/modletInclude/facebook_friends/fragments/invite_leightbox', function(template) {
				var json = {};
				json.baseUrl = baseUrl;
				json.contextPath = contextPath;
				json.templatePath = templatePath;
				json.loggedInUser = FB.Connect.get_loggedInUser();
				$("inviteFriends").innerHTML = cambrient.processTemplate(template, json);
				FB.XFBML.Host.parseDomTree();
			}
			
		}); 
	}*/
	
	constructorFn.prototype.showFriendSelector = function(baseUrl, contextPath) {
        Modalbox.show($('inviteFriendsPopup'), {title: "none", width: 820, afterLoad: function() {
            $('MB_window').style.top="2%";
            //$('MB_window').style.height="200px";
            FB.ensureInit(function() {
                var screenHeight = document.viewport.getHeight();
                var rows = "rows=\"4\"";
                var inviteButton = "";
                var condensed = "false";    
                if (screenHeight < 700) rows = "rows=\"3\"";;
                if (screenHeight < 600) {
                    inviteButton = "<br/><br/><fb:request-form-submit /><br/><br/><br/>";
                    rows = "";    
                    condensed = "true";
                }
                
                $("inviteFriends").innerHTML = "<fb:serverfbml style=\"width: 776px;\" ><script type=\"text/fbml\">" +
                    "<fb:fbml> <fb:request-form action=\"" + baseUrl + contextPath + "/content/en/recipes\" method=\"POST\" " +
                    "invite=\"true\" type=\"Fresh Living Network\" " +
                    "content=\"<fb:name uid='" + FB.Connect.get_loggedInUser() + "' useyou='false' /> is a member of the Pick n Pay Fresh Living Network and would like " +
					"to share that experience with you. To see how awesome it is, simply click on the 'Check it out' button below." +
					"<fb:req-choice url='" + baseUrl + contextPath + "/content/en/home' label='Check it out' />\"" +
                    "<fb:multi-friend-selector condensed=\"" + condensed + "\" " + rows + " showborder=\"false\" actiontext=\"Invite your Facebook Friends to use the Fresh Living Network\" />" + inviteButton + "</fb:request-form></fb:fbml>";
                    //"<fb:multi-friend-selector condensed=\"true\" style=\"width: 200px;\"  rows=\"" + rows + "\" showborder=\"false\" actiontext=\"Invite your Facebook Friends to use the Fresh Living Network\" /></fb:request-form></fb:fbml>";
                FB.XFBML.Host.parseDomTree();
    
            });             
        }});
    }
	
	constructorFn.prototype.showPage = function(page, maxPages) {
		var currentPage = 0;
		for (var i=0; i<=maxPages; i++) {
			if ($("fb_friends_favourites_" + i).style.display == "block") {
				currentPage = i;			
			}
			$("fb_friends_favourites_" + i).style.display = "none";
		}		
		console.log("currentPage: " + currentPage);
		$("fb_friends_favourites_" + (currentPage + page)).style.display = "block";
		$("fb_friends_current_page").innerHTML = (currentPage + page) + 1;

		$("fb_friends_control_up").style.display = "block";
		$("fb_friends_control_down").style.display = "block";
		if ((currentPage + page) == 0) {
			$("fb_friends_control_up").style.display = "none";
		}
		if ((currentPage + page) == maxPages) {
			$("fb_friends_control_down").style.display = "none";
		}
	}
	
	return new constructorFn();	
}

picknpay.modlets.fbFriends = new picknpay.modlets.FacebookFriends();
/*--------------------------------------------------------------------------*/
///applications/picknpay/templates/js/lightbox.js
/*--------------------------------------------------------------------------*/
// -----------------------------------------------------------------------------------
//
//	Lightbox v2.04
//	by Lokesh Dhakar - http://www.lokeshdhakar.com
//	Last Modification: 2/9/08
//
//	For more information, visit:
//	http://lokeshdhakar.com/projects/lightbox2/
//
//	Licensed under the Creative Commons Attribution 2.5 License - http://creativecommons.org/licenses/by/2.5/
//  	- Free for use in both personal and commercial projects
//		- Attribution requires leaving author name, author link, and the license info intact.
//	
//  Thanks: Scott Upton(uptonic.com), Peter-Paul Koch(quirksmode.com), and Thomas Fuchs(mir.aculo.us) for ideas, libs, and snippets.
//  		Artemy Tregubenko (arty.name) for cleanup and help in updating to latest ver of proto-aculous.
//
// -----------------------------------------------------------------------------------
/*

    Table of Contents
    -----------------
    Configuration

    Lightbox Class Declaration
    - initialize()
    - updateImageList()
    - start()
    - changeImage()
    - resizeImageContainer()
    - showImage()
    - updateDetails()
    - updateNav()
    - enableKeyboardNav()
    - disableKeyboardNav()
    - keyboardAction()
    - preloadNeighborImages()
    - end()
    
    Function Calls
    - document.observe()
   
*/
// -----------------------------------------------------------------------------------

//
//  Configurationl
//
LightboxOptions = Object.extend({
    fileLoadingImage:        '/picknpay/applications/picknpay/templates/images/lightbox/loading.gif',     
    fileBottomNavCloseImage: '/picknpay/applications/picknpay/templates/images/lightbox/closelabel.png',

    overlayOpacity: 0.8,   // controls transparency of shadow overlay

    animate: true,         // toggles resizing animations
    resizeSpeed: 7,        // controls the speed of the image resizing animations (1=slowest and 10=fastest)

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

	// When grouping images this is used to write: Image # of #.
	// Change it for non-english localization
	labelImage: "Image",
	labelOf: "of"
}, window.LightboxOptions || {});

// -----------------------------------------------------------------------------------

var Lightbox = Class.create();

Lightbox.prototype = {
    imageArray: [],
    activeImage: undefined,
    
    // initialize()
    // Constructor runs on completion of the DOM loading. Calls updateImageList and then
    // the function inserts html at the bottom of the page which is used to display the shadow 
    // overlay and the image container.
    //
    initialize: function() {    
        
        this.updateImageList();
        
        this.keyboardAction = this.keyboardAction.bindAsEventListener(this);

        if (LightboxOptions.resizeSpeed > 10) LightboxOptions.resizeSpeed = 10;
        if (LightboxOptions.resizeSpeed < 1)  LightboxOptions.resizeSpeed = 1;

	    this.resizeDuration = LightboxOptions.animate ? ((11 - LightboxOptions.resizeSpeed) * 0.15) : 0;
	    this.overlayDuration = LightboxOptions.animate ? 0.2 : 0;  // shadow fade in/out duration

        // When Lightbox starts it will resize itself from 250 by 250 to the current image dimension.
        // If animations are turned off, it will be hidden as to prevent a flicker of a
        // white 250 by 250 box.
        var size = (LightboxOptions.animate ? 250 : 1) + 'px';
        

        // Code inserts html at the bottom of the page that looks similar to this:
        //
        //  <div id="overlay"></div>
        //  <div id="lightbox">
        //      <div id="outerImageContainer">
        //          <div id="imageContainer">
        //              <img id="lightboxImage">
        //              <div style="" id="hoverNav">
        //                  <a href="#" id="prevLink"></a>
        //                  <a href="#" id="nextLink"></a>
        //              </div>
        //              <div id="loading">
        //                  <a href="#" id="loadingLink">
        //                      <img src="images/loading.gif">
        //                  </a>
        //              </div>
        //          </div>
        //      </div>
        //      <div id="imageDataContainer">
        //          <div id="imageData">
        //              <div id="imageDetails">
        //                  <span id="caption"></span>
        //                  <span id="numberDisplay"></span>
        //              </div>
        //              <div id="bottomNav">
        //                  <a href="#" id="bottomNavClose">
        //                      <img src="images/close.gif">
        //                  </a>
        //              </div>
        //          </div>
        //      </div>
        //  </div>


        var objBody = $$('body')[0];

		objBody.appendChild(Builder.node('div',{id:'overlay'}));
	
        objBody.appendChild(Builder.node('div',{id:'lightbox'}, [
																 
			 Builder.node('div', {id:'imageDataContainer'},
                Builder.node('div',{id:'imageData'}, [
                    Builder.node('div',{id:'imageDetails'}, [
                        Builder.node('span',{id:'caption'}),
                        Builder.node('span',{id:'numberDisplay'})
                    ]), //end of div 'imageDetails'
                    Builder.node('div',{id:'bottomNav'},
                        Builder.node('a',{id:'bottomNavClose', href: '#' },
                            Builder.node('img', { src: LightboxOptions.fileBottomNavCloseImage })
                        ) //end of a 'bottomNavClose'
                    ) //end of div 'bottomNav'
                ]) //end of div 'imageData'??
            ), //end of div 'imageDataContainer'??
            Builder.node('div',{id:'outerImageContainer'}, 
                Builder.node('div',{id:'imageContainer'}, [
                    Builder.node('img',{id:'lightboxImage'}), 
                    Builder.node('div',{id:'hoverNav'}, [
                        Builder.node('a',{id:'prevLink', href: '#' }),
                        Builder.node('a',{id:'nextLink', href: '#' })
                    ]), //end of div 'hoverNav'
                    Builder.node('div',{id:'loading'}, 
                        Builder.node('a',{id:'loadingLink', href: '#' }, 
                            Builder.node('img', {src: LightboxOptions.fileLoadingImage})
                        ) //end of a 'loadingLink'
                    ) //end of a 'loading'
                ]) //end of div 'imageContainer'??
            ) //end of div 'outer image container'??
           
        ])); //end of div (lightbox) and builder.node


		$('overlay').hide().observe('click', (function() { this.end(); }).bind(this));
		$('lightbox').hide().observe('click', (function(event) { if (event.element().id == 'lightbox') this.end(); }).bind(this));
		$('outerImageContainer').setStyle({ width: size, height: size });
		$('prevLink').observe('click', (function(event) { event.stop(); this.changeImage(this.activeImage - 1); }).bindAsEventListener(this));
		$('nextLink').observe('click', (function(event) { event.stop(); this.changeImage(this.activeImage + 1); }).bindAsEventListener(this));
		$('loadingLink').observe('click', (function(event) { event.stop(); this.end(); }).bind(this));
		$('bottomNavClose').observe('click', (function(event) { event.stop(); this.end(); }).bind(this));

        var th = this;
        (function(){
            var ids = 
                'overlay lightbox outerImageContainer imageContainer lightboxImage hoverNav prevLink nextLink loading loadingLink ' + 
                'imageDataContainer imageData imageDetails caption numberDisplay bottomNav bottomNavClose';   
            $w(ids).each(function(id){ th[id] = $(id); });
        }).defer();
    },

    //
    // updateImageList()
    // Loops through anchor tags looking for 'lightbox' references and applies onclick
    // events to appropriate links. You can rerun after dynamically adding images w/ajax.
    //
    updateImageList: function() {   
        this.updateImageList = Prototype.emptyFunction;

        document.observe('click', (function(event){
            var target = event.findElement('a[rel^=lightbox]') || event.findElement('area[rel^=lightbox]');
            if (target) {
                event.stop();
                this.start(target);
            }
        }).bind(this));
    },
    
    //
    //  start()
    //  Display overlay and lightbox. If image is part of a set, add siblings to imageArray.
    //
    start: function(imageLink) {    

        $$('select', 'object', 'embed').each(function(node){ node.style.visibility = 'hidden' });

        // stretch overlay to fill page and fade in
        var arrayPageSize = this.getPageSize();
        $('overlay').setStyle({ width: arrayPageSize[0] + 'px', height: arrayPageSize[1] + 'px' });

        new Effect.Appear(this.overlay, { duration: this.overlayDuration, from: 0.0, to: LightboxOptions.overlayOpacity });

        this.imageArray = [];
        var imageNum = 0;       

        if ((imageLink.rel == 'lightbox')){
            // if image is NOT part of a set, add single image to imageArray
            this.imageArray.push([imageLink.href, imageLink.title]);         
        } else {
            // if image is part of a set..
            this.imageArray = 
                $$(imageLink.tagName + '[href][rel="' + imageLink.rel + '"]').
                collect(function(anchor){ return [anchor.href, anchor.title]; }).
                uniq();
            
            while (this.imageArray[imageNum][0] != imageLink.href) { imageNum++; }
        }

        // calculate top and left offset for the lightbox 
        var arrayPageScroll = document.viewport.getScrollOffsets();
        var lightboxTop = arrayPageScroll[1] + (document.viewport.getHeight() / 10);
		//var lightboxTop = "0"
        var lightboxLeft = arrayPageScroll[0];
        this.lightbox.setStyle({ top: lightboxTop + 'px', left: lightboxLeft + 'px' }).show();
        
        this.changeImage(imageNum);
    },

    //
    //  changeImage()
    //  Hide most elements and preload image in preparation for resizing image container.
    //
    changeImage: function(imageNum) {   
        
        this.activeImage = imageNum; // update global var

        // hide elements during transition
        if (LightboxOptions.animate) this.loading.show();
        this.lightboxImage.hide();
        this.hoverNav.hide();
        this.prevLink.hide();
        this.nextLink.hide();
		// HACK: Opera9 does not currently support scriptaculous opacity and appear fx
        this.imageDataContainer.setStyle({opacity: .0001});
        this.numberDisplay.hide();      
        
        var imgPreloader = new Image();
        
        // once image is preloaded, resize image container


        imgPreloader.onload = (function(){
            this.lightboxImage.src = this.imageArray[this.activeImage][0];
            this.resizeImageContainer(imgPreloader.width, imgPreloader.height);
        }).bind(this);
        imgPreloader.src = this.imageArray[this.activeImage][0];
    },

    //
    //  resizeImageContainer()
    //
    resizeImageContainer: function(imgWidth, imgHeight) {

        // get current width and height
        var widthCurrent  = this.outerImageContainer.getWidth();
        var heightCurrent = this.outerImageContainer.getHeight();

        // get new width and height
        var widthNew  = (imgWidth  + LightboxOptions.borderSize * 2);
        var heightNew = (imgHeight + LightboxOptions.borderSize * 2);

        // scalars based on change from old to new
        var xScale = (widthNew  / widthCurrent)  * 100;
        var yScale = (heightNew / heightCurrent) * 100;

        // calculate size difference between new and old image, and resize if necessary
        var wDiff = widthCurrent - widthNew;
        var hDiff = heightCurrent - heightNew;

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

        // if new and old image are same size and no scaling transition is necessary, 
        // do a quick pause to prevent image flicker.
        var timeout = 0;
        if ((hDiff == 0) && (wDiff == 0)){
            timeout = 100;
            if (Prototype.Browser.IE) timeout = 250;   
        }

        (function(){
            this.prevLink.setStyle({ height: imgHeight + 'px' });
            this.nextLink.setStyle({ height: imgHeight + 'px' });
            this.imageDataContainer.setStyle({ width: widthNew + 'px' });

            this.showImage();
        }).bind(this).delay(timeout / 1000);
    },
    
    //
    //  showImage()
    //  Display image and begin preloading neighbors.
    //
    showImage: function(){
        this.loading.hide();
        new Effect.Appear(this.lightboxImage, { 
            duration: this.resizeDuration, 
            queue: 'end', 
            afterFinish: (function(){ this.updateDetails(); }).bind(this) 
        });
        this.preloadNeighborImages();
    },

    //
    //  updateDetails()
    //  Display caption, image number, and bottom nav.
    //
    updateDetails: function() {
    
        // if caption is not null
        if (this.imageArray[this.activeImage][1] != ""){
            this.caption.update(this.imageArray[this.activeImage][1]).show();
        }
        
        // if image is part of set display 'Image x of x' 
        if (this.imageArray.length > 1){
            this.numberDisplay.update( LightboxOptions.labelImage + ' ' + (this.activeImage + 1) + ' ' + LightboxOptions.labelOf + '  ' + this.imageArray.length).show();
        }

        new Effect.Parallel(
            [ 
                new Effect.SlideDown(this.imageDataContainer, { sync: true, duration: this.resizeDuration, from: 0.0, to: 1.0 }), 
                new Effect.Appear(this.imageDataContainer, { sync: true, duration: this.resizeDuration }) 
            ], 
            { 
                duration: this.resizeDuration, 
                afterFinish: (function() {
	                // update overlay size and update nav
	                var arrayPageSize = this.getPageSize();
	                this.overlay.setStyle({ height: arrayPageSize[1] + 'px' });
	                this.updateNav();
                }).bind(this)
            } 
        );
    },

    //
    //  updateNav()
    //  Display appropriate previous and next hover navigation.
    //
    updateNav: function() {

        this.hoverNav.show();               

        // if not first image in set, display prev image button
        if (this.activeImage > 0) this.prevLink.show();

        // if not last image in set, display next image button
        if (this.activeImage < (this.imageArray.length - 1)) this.nextLink.show();
        
        this.enableKeyboardNav();
    },

    //
    //  enableKeyboardNav()
    //
    enableKeyboardNav: function() {
        document.observe('keydown', this.keyboardAction); 
    },

    //
    //  disableKeyboardNav()
    //
    disableKeyboardNav: function() {
        document.stopObserving('keydown', this.keyboardAction); 
    },

    //
    //  keyboardAction()
    //
    keyboardAction: function(event) {
        var keycode = event.keyCode;

        var escapeKey;
        if (event.DOM_VK_ESCAPE) {  // mozilla
            escapeKey = event.DOM_VK_ESCAPE;
        } else { // ie
            escapeKey = 27;
        }

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

    //
    //  preloadNeighborImages()
    //  Preload previous and next images.
    //
    preloadNeighborImages: function(){
        var preloadNextImage, preloadPrevImage;
        if (this.imageArray.length > this.activeImage + 1){
            preloadNextImage = new Image();
            preloadNextImage.src = this.imageArray[this.activeImage + 1][0];
        }
        if (this.activeImage > 0){
            preloadPrevImage = new Image();
            preloadPrevImage.src = this.imageArray[this.activeImage - 1][0];
        }
    
    },

    //
    //  end()
    //
    end: function() {
        this.disableKeyboardNav();
        this.lightbox.hide();
        new Effect.Fade(this.overlay, { duration: this.overlayDuration });
        $$('select', 'object', 'embed').each(function(node){ node.style.visibility = 'visible' });
    },

    //
    //  getPageSize()
    //
    getPageSize: function() {
	        
	     var xScroll, yScroll;
		
		if (window.innerHeight && window.scrollMaxY) {	
			xScroll = window.innerWidth + window.scrollMaxX;
			yScroll = window.innerHeight + window.scrollMaxY;
		} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
			xScroll = document.body.scrollWidth;
			yScroll = document.body.scrollHeight;
		} else { // Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
			xScroll = document.body.offsetWidth;
			yScroll = document.body.offsetHeight;
		}
		
		var windowWidth, windowHeight;
		
		if (self.innerHeight) {	// all except Explorer
			if(document.documentElement.clientWidth){
				windowWidth = document.documentElement.clientWidth; 
			} else {
				windowWidth = self.innerWidth;
			}
			windowHeight = self.innerHeight;
		} else if (document.documentElement && document.documentElement.clientHeight) { // Explorer 6 Strict Mode
			windowWidth = document.documentElement.clientWidth;
			windowHeight = document.documentElement.clientHeight;
		} else if (document.body) { // other Explorers
			windowWidth = document.body.clientWidth;
			windowHeight = document.body.clientHeight;
		}	
		
		// for small pages with total height less then height of the viewport
		if(yScroll < windowHeight){
			pageHeight = windowHeight;
		} else { 
			pageHeight = yScroll;
		}
	
		// for small pages with total width less then width of the viewport
		if(xScroll < windowWidth){	
			pageWidth = xScroll;		
		} else {
			pageWidth = windowWidth;
		}

		return [pageWidth,pageHeight];
	}
}

document.observe('dom:loaded', function () { new Lightbox(); });
/*--------------------------------------------------------------------------*/
///modletInclude/udm/skins/pnp/udm.js
/*--------------------------------------------------------------------------*/
// UDMv4.5 //
/***************************************************************/
var um={'menuClasses':[],'itemClasses':[],'menuCode':[]};
/***************************************************************\

  ULTIMATE DROP DOWN MENU Version 4.5 by Brothercake
  http://www.udm4.com/

  This script may not be used or distributed without license

\***************************************************************/


/***************************************************************\
 * CORE CONFIGURATION
\***************************************************************/


//path to images folder
um.baseSRC = "/udm-resources/";


//initialization trigger element ["id"];
um.trigger = "contact";


//navbar orientation
um.orientation = [
	"horizontal",	// alignment ["vertical"|"horizontal"|"popup"|"expanding"]
	"left",		// h align ["left"|"right"|"rtl"]
	"top",		// v align ["top"|"bottom"]
	"",	// positioning ["relative"|"absolute"|"fixed"|"allfixed"]
	"0",	// x position ["em"|"ex"|"px"|"0"]
	"0",	// y position ["em"|"ex"|"px"|"0"]
	"1000",		// z order ["0" to "10000"] (menu takes 20000 headroom)
	];


//navbar list output
um.list = [
	"rigid",	// horizontal overflow ["rigid"|"flexible"]
	"yes",		// -SPARE-
	"no", 		// -SPARE-
	];


//menu behaviors
um.behaviors = [
	"200",		// open timer ["milliseconds"|"0"]
	"500",		// close timer ["milliseconds"|"never"|"0"]
	"yes",		// reposition menus to stay inside the viewport ["yes"|"no"]
	"default",	// manage windowed controls for win/ie ["default","hide","iframe","none"]
	];


//reset behaviors
um.reset = [
	"yes",		// reset from document mouse click ["yes"|"no"]
	"yes",		// reset from window resize ["yes"|"no"]
	"yes",		// reset from text resize ["yes"|"no"]
	"no",		// reset after following link ["yes"|"no"]
	];


//horizontal continuation strip
um.hstrip = [
	"none",		// background ["color"|"#hex"|"rgb()"|"image.gif"|"none"]
	"yes",		// copy item margin-right to margin-bottom ["yes"|"no"]
	];


/***************************************************************\
 * MODULE SETTINGS
\***************************************************************/


//keyboard navigation
um.keys = [
	"38",		// up ["n"] ("38" = up arrow key)
	"39",		// right ["n"] ("39" = right arrow key)
	"40",		// down ["n"] ("40" = down arrow key)
	"37",		// left ["n"] ("37" = left arrow key)
	"123",		// hotkey ["n"] ("123" = F12)
	"none",		// hotkey modifier ["none"|"shiftKey"|"ctrlKey"|"altKey"|"metaKey"]
	"27",		// escape ["n"|"none"] ("27" = escape key)
	"document.getElementsByTagName('a')[4]", // exit focus ["js-expression"]
	];


/***************************************************************\
 * NAVBAR DEFAULT STYLES
\***************************************************************/


//styles which apply to the navbar
um.navbar = [
	"-1",		// nav to menu x-offset (+-)["n" pixels]
	"0",	// nav to menu y-offset (+-)["n" pixels]
	"7.5em",	// width ["em"|"ex"|"px"] (vertical navbar only - horizontal navbar items have "auto" width) ("%" doesn't work right)
	];


//styles which apply to each navbar item
um.items = [
	"0",		// margin between items ["n" pixels]
	"0",		// border size ["n" pixels] (single value only)
	"collapse",	// border collapse ["collapse"|"separate"] (only applies when margin = "0")
	"",// border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"none",	// border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"",// hover/focus border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"none",	// hover/focus border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"",// visited border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"none",// visited border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"0",		// left/right padding ["n" pixels] (single value only)
	"0",		// top/bottom padding ["n" pixels] (single value only)
	"none",// background ["color"|"#hex"|"rgb()"|"image.gif"]
	"none",// hover/focus background ["color"|"#hex"|"rgb()"|"image.gif"]
	"none",// visited background ["color"|"#hex"|"rgb()"|"image.gif"]
	"50%",		// font size ["em"|"ex"|"%"|"px"|"pt"|"absolute-size"|"relative-size"]
	"arial, helvetica ,sans-serif",// font family ["font1,font2,font3"] (always end with a generic family name)
	"bold",		// font weight ["normal"|"bold"|"bolder"|"lighter|"100" to "900"]
	"none",		// text decoration ["none"|"underline"|"overline"|"line-through"]
	"left",		// text-align ["left"|"right"|"center"]
	"#ffffff",	// color ["color"|"#hex"|"rgb()"]
	"#fff",	// hover/focus color ["color"|"#hex"|"rgb()"]
	"#ffffff",	// visited color ["color"|"#hex"|"rgb()"]
	"normal",	// font-style ["normal"|"italic"|"oblique"]
	"normal",	// hover/focus font-style ["normal"|"italic"|"oblique"]
	"normal",	// visited font-style ["normal"|"italic"|"oblique"]
	"background-color:#ffffff;",// additional link CSS (careful!)
	"background-color:#ffffff;",// additional hover/focus CSS (careful!)
	"background-color:#ffffff;",// additional visited CSS (careful!)
	"none",// menu indicator character/image ["text"|"image.gif"|"none"]
	"",// menu indicator rollover image ["image.gif"|"none"] (only when using image arrows)
	"",		// clipping width of indicator image ["n" pixels] (only when using image arrows)
	"",		// alt text of indicator image ["text"] (only when using image arrows)
	];


/***************************************************************\
 * MENU DEFAULT STYLES
\***************************************************************/


//styles which apply to each menu
um.menus = [
	"-2",		// menu to menu x-offset (+-)["n" pixels]
	"-5",	// menu to menu y-offset (+-)["n" pixels]
	"1",		// border size ["n" pixels] (single value only)
	"#ddd",// border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"solid",	// border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"12em",	// width ["em"|"ex"|"px"]
	"0",		// padding ["n" pixels] (single value only)
	"none",	// background ["color"|"#hex"|"rgb()"|"image.gif"]
	"background-color:#fafafa;",		// additional menu CSS (careful!) (you can use a transition here but *not* a static filter)
	"none",// shadow background ["color"|"#hex"|"rgb()"|"image.gif"|"none"]
	"0.15em",		// shadow offset (+-)["em"|"ex"|"px"|"%"|"0"]
	"-moz-opacity:0.5;-khtml-opacity:0.5;filter:alpha(opacity=50);",// additional shadow layer CSS (if you use a Microsoft.Shadow filter here then Win/IE5.5+ will do that *instead* of default shadow)
	];


//styles which apply to each menu item
um.menuItems = [
	"0",		// margin around items ["n" pixels] (single value only; margins are like table cellspacing)
	"0",		// border size ["n" pixels] (single value only)
	"separate",	// border collapse ["collapse"|"separate"] (only applies when margin = "0")
	"#000",	// border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"solid",	// border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"#000",		// hover/focus border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"solid",	// hover/focus border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"#000",	// visited border colors ["color"|"#hex"|"rgb()"] (single, double or four values)
	"solid",	// visited border styles ["solid"|"double"|"dotted"|"dashed"|"groove"|"ridge"|"inset"|"outset"] (single, double or four values; be careful with using "none")
	"0",		// left/right padding ["n" pixels] (single value only)
	"0",		// top/bottom padding ["n" pixels] (single value only)
	"transparent",	// background ["color"|"#hex"|"rgb()"|"image.gif"]
	"none",	// hover/focus background ["color"|"#hex"|"rgb()"|"image.gif"]
	"transparent",	// visited background ["color"|"#hex"|"rgb()"|"image.gif"]
	"70%",		// font size ["em"|"ex"|"%"|"px"|"pt"|"absolute-size"|"relative-size"]
	"tahoma,sans-serif",// font family ["font1,font2,font3"] (always end with a generic family name)
	"bold",	// font weight ["normal"|"bold"|"bolder"|"lighter|"100" to "900"]
	"none",		// text decoration ["none"|"underline"|"overline"|"line-through"]
	"left",		// text-align ["left"|"right"|"center"]
	"#333",		// color ["color"|"#hex"|"rgb()"]
	"#fff",		// hover/focus color ["color"|"#hex"|"rgb()"]
	"#333",		// visited color ["color"|"#hex"|"rgb()"]
	"normal",	// font-style ["normal"|"italic"|"oblique"]
	"normal",	// hover/focus font-style ["normal"|"italic"|"oblique"]
	"normal",	// visited font-style ["normal"|"italic"|"oblique"]
	"padding-left:15px !important;",		// additional link CSS (careful!)
	"background-color:#ffffff;",		// additional hover/focus CSS (careful!)
	"",		// additional visited CSS (careful!)
	"none",// menu indicator character/image ["text"|"image.gif"|"none"]
	"none",// menu indicator rollover image ["image.gif"|"none"] (only when using image arrows)
	"7",		// clipping width of indicator image ["n" pixels] (only when using image arrows)
	"..",		// alt text of indicator image ["text"] (only when using image arrows)
	];


/***************************************************************\
 * MENU CLASSES
\***************************************************************/





/***************************************************************\
 * DYNAMIC MENUS
\***************************************************************/





/***************************************************************\
\***************************************************************/

/*--------------------------------------------------------------------------*/
///modletInclude/udm/js/udm-control.js
/*--------------------------------------------------------------------------*/
// UDMv4.52 //
///////////////////////////////////////////////////////////////////
//                                                               //
//  ULTIMATE DROP DOWN MENU Version 4.52 by Brothercake          //
//  http://www.udm4.com/                                         //
//                                                               //
//  This script may not be used or distributed without license   //
//                                                               //
///////////////////////////////////////////////////////////////////



//##########################################################

//*** YOU WILL ALMOST-CERTAINLY NEED TO UPDATE
//*** SERVER-SIDE GENERATORS WHENEVER YOU CHANGE THIS

//##########################################################



//*** DO NOT REMOVE //start or //stop OR SIMILAR COMMENTS


//udm tree global var
var umTree=null;

//ready state flag for popup alignment
//and for shielding unsupported browsers from interactive scripting
//because for them it's never true
um.ready=0;

//cpstart

//parseInt shortcut function
um.pi=function(n){n=parseInt(n,10);return (isNaN(n)?0:n);};

//'undefined'
um.un='undefined';

//document
um.m=document;

//cpstop

//getElementById
um.gd=function(n){return um.m.getElementById(n);};

//make it displayed/non-displayed
um.xd=function(n){n.style.display='block';};
um.xn=function(n){n.style.display='none';};
//make it visible/invisible
um.xv=function(n){n.style.visibility='visible';};
um.xh=function(n){n.style.visibility='hidden';};

//is this a navbar element
um.ne=function(n){return n.parentNode.className=='udm';};

//cpstart

//check for undefined new variables
if(typeof um.reset==um.un){um.reset=['yes','yes','yes'];}
if(typeof um.hstrip==um.un){um.hstrip=['none','yes'];}
//CHANGED
if(typeof um.reset[3]==um.un){um.reset[3]='no';}

//process and copy all custom vars
//both so that we can process them more efficiently
//and so we'll have shortcut-names to reduce the code size

//create an array of custom.js array names
//so we can reference um.something == um['something'] == um[um.cx[i]]
//      0-6           7-9    10-13       14-16    17-48   49-60   61-92
um.cx=['orientation','list','behaviors','navbar','items','menus','menuItems','menuClasses','itemClasses'];

//compact array for custom vars
um.ei=0;um.e=[];

//compact matrix for classes
um.v=[];um.w=[];

//count ad-hoc classes
um.vl=0;
um.wl=0;

//image objects array for caching
um.ek=0;um.im=[];


//process vars method
um.pcv=function(v)
{
	//using regex literals here,because mac/ie5.0
	//appears not to garbage collect the RegExp constructor properly

	//if it's a number variable
	if(v&&/^[+\-]?[0-9]+$/.test(v))
	{
		//turn it into a number
		v=um.pi(v);
		//if this is open or close timer
		//and it's less than 1 set it to 1
		//having a minimum value prevents a potential
		//shadow-displacement problem with popup alignment
		//and also saves a few snips of code in udm-dom.js
		//and also prevents negative numbers
		if((um.ei==10||um.ei==11)&&v<1){v=1;}
	}

	//if it's an image
	if(v&&/\.(gif|png|mng|jpg|jpeg|jpe|bmp)/i.test(v))
	{
		//cache image objects in an array because image loading is asynchronous
		//so it might not have finished before this comes round again
		um.im[um.ek]=new Image;
		um.im[um.ek++].src=um.baseSRC+v;
	}
	return v;
};


//cpstop

//identify dom support//exclude HPR3.04 because its JS capabilities get in the way of good accessibility through graceful degrading
um.d=(typeof um.m.getElementById!=um.un&&(typeof um.m.createElement!=um.un||typeof um.m.createElementNS!=um.un)&&typeof navigator.IBM_HPR==um.un);

//get UA string - used with caution :)
um.u=navigator.userAgent.toLowerCase();

//need to exclude O6,because it declares support for createElement()
//but can't actually add the created element to the page
//this var includes O5 for convenience's sake
um.o5=/opera[\/ ][56]/.test(um.u);
um.k=(navigator.vendor=='KDE');
//CHANGED: if(um.o5||um.k){um.d=0;}
if(um.o5){um.d=0;}

//browsers which support the basic navbar styling
//CHANGED: um.b=(um.d||um.o5||um.k);
um.b=(um.d||um.o5);

//hide static menus for netscape 4 and other primitive CSS browsers
//CHANGED: if(um.list[2]=='yes'&&!(um.d||um.b))
//{
//	document.write('<style type="text/css" media="screen">#udm ul{display:none;}</style>');
//}


//identify specific browsers - these are used to exclude from a feature or add in a hack,
//on the basis that everything is assumed to work right unless it's known not to



//opera 7 or later
um.o7=(um.d&&typeof window.opera!=um.un);
//opera 7.5+ supports clip properly,so clip-based extensions can now be supported
um.o75=0;
//opera 7.3 supports <script> in XHTML
//and hence can't use document.write for generating the CSS rules
//but the alternative methods we're going to use
//fail spectacularly in earlier versions,so we need to distinguish
um.o73=0;
//also need to know about<=7.1,because of a dropshadow positioning problem in 7.0
//it's unlikely anyone will be using 7.0,but it does look terrible,so better to tweak than leave it
//and opera 7.11 dropshadow has lesser,but still unsightly,rendering,sizing and positioning problems
um.o71=0;
if(um.o7)
{
	//CHANGED: split ua string to detect versions
	//um.ov=um.u;
	//um.ov=um.ov.split(/opera[\/ ]7./);
	//um.ov=um.pi(um.ov[1].charAt(0));
	//get major and minor versions from ua string
	um.ova=um.pi(um.u.split(/opera[\/ ]/)[1].match(/[7-9]/)[0]);
	um.ovi=um.pi(um.u.split(/opera[\/ ][7-9]\./)[1].match(/^[0-9]/)[0]);

	//opera 7.5 or later
	//CHANGED: um.o75=(um.ov>=5);
	um.o75=(um.ova>=8||um.ovi>=5);

	//opera 7.3 or later
	//CHANGED: um.o73=(um.ov>=3);
	um.o73=(um.ova>=8||um.ovi>=3);

	//opera 7.1 or earlier
	//CHANGED: um.o71=(um.ov<=1);
	um.o71=(um.ova==7&&um.ovi<=1);
}
//safari
//CHANGED: um.s=(navigator.vendor=='Apple Computer, Inc.'&&typeof um.m.childNodes!=um.un&&typeof um.m.all==um.un&&typeof navigator.taintEnabled==um.un);
//4.52 removed this line:
//um.s=(navigator.vendor=='Apple Computer, Inc.');
//4.52 added these two lines:
um.google=(navigator.vendor=='Google Inc.');
um.s=(navigator.vendor=='Apple Computer, Inc.'||um.google);
//safari 1.2
um.s2=(um.s&&typeof XMLHttpRequest!=um.un);
//4.51 ADDED: safari 3
um.s3=(um.s&&um.u.indexOf('version/3')!=-1);
//4.52 include google in that
um.s3=(um.s3||um.google);
//windows internet explorer
//CHANGED: um.wie=(um.d&&typeof um.m.all!=um.un&&typeof window.opera==um.un);
um.wie=(um.d&&typeof um.m.all!=um.un&&typeof window.opera==um.un&&!um.k);
//mac internet explorer
um.mie=(um.wie&&um.u.indexOf('mac')>0);
//maintain a false OSX/MSN variable, for backward safety
um.mx=0;
um.omie=0;
if(um.mie)
{
	//mac/ie is not win/ie
	um.wie=0;
	//split ua string to detect earlier version
	um.iev=um.u;
	um.iev=um.iev.split('msie ');
	um.iev[1]=um.iev[1].split(';');
	um.iev=parseFloat(um.iev[1][0],10);
	um.omie=(um.iev<5.2);
}
//any version of internet explorer
um.ie=(um.wie||um.mie);
//ie5
um.wie5=(um.wie&&um.u.indexOf('msie 5')>0);
//ie5.5
um.wie55=(um.wie&&um.u.indexOf('msie 5.5')>0);
//ie5.0
um.wie50=(um.wie5&&!um.wie55);
//ie6
um.wie6=(um.wie&&um.u.indexOf('msie 6')>0);
//ie6 is also ie5.5 in these terms
if(um.wie6){um.wie55=1;}
//ie7.0
um.wie7=(um.wie&&typeof XMLHttpRequest!=um.un);

//quirks mode
um.q=(um.wie5||um.mie||((um.wie6||um.wie7||um.o7)&&um.m.compatMode!='CSS1Compat'));
//document.title=um.q;

//***DEV
//alert(''
//	+ 'ie = ' + um.ie + '\n'
//	+ 'wie5 = ' + um.wie5 + '\n'
//	+ 'wie55 = ' + um.wie55 + '\n'
//	+ 'wie50 = ' + um.wie50 + '\n'
//	+ 'wie6 = ' + um.wie6 + '\n'
//	+ 'wie7 = ' + um.wie7 + '\n'
//	+ 'wie8 = ' + um.wie8 + '\n'
//	+ 'quirks = ' + um.q + '\n'
//	);

//gecko earlier than 1.3
um.og=0;
//gecko earlier than 0.9.2
um.dg=0;
//safari spoofs as gecko
if(navigator.product=='Gecko'&&!um.s)
{
	//detect gecko builds by product sub
	um.sub=um.pi(navigator.productSub);
	//gecko<1.3 [tested with 1.3 final]
	um.og=(um.sub<20030312);
	//gecko<1.0.2 [tested with ns7.02]
	um.dg=(um.sub<20030208);
	//win/moz1.0 rc1=Gecko/20020417
	//win/ns7.0=rv:1.0.1) Gecko/20020823
	//win/ns7.02=rv:1.0.2) Gecko/20030208
	//lin/moz1.0.1=20020830
}


//only do the rest for basically support browsers
//this saves unsupported browsers needlessly processing variables
//and also protects MSN TV 2.8 from crash bugs due to (what looks like)
//uses of parseInt and parseFloat,and running the var process code when concatenated!
if(um.b)
{
	//cpstart


	//for each item in the matrix
	var i=0;
	do
	{
		//a normal array
		if(um.cx[i].indexOf('Classes')<0)
		{
			//get array length
			um.cxl=um[um.cx[i]].length;
			//for each item in this array
			var j=0;
			do
			{
				//if array item is not undefined
				//this is for the benefit of opera 5
				//which creates undefined array items from trailing commas
				if(typeof um[um.cx[i]][j]!=um.un)
				{
					//process it
					um.pv=um.pcv(um[um.cx[i]][j]);

					//copy this value
					um.e[um.ei]=um.pv;

					//increment array counter
					um.ei++;
				}
				j++;
			}
			while(j<um.cxl);
		}

		//an ad-hoc class array
		else
		{
			//for each item in this classes array
			for(j in um[um.cx[i]])
			{
				//if member is not a function
				//this is to prevent Array prototypes from being included
				//which might be present in other scripting
				if(typeof um[um.cx[i]][j]!='function')
				{
					//get array length
					um.cxl=um[um.cx[i]][j].length;
					//for each item in this array
					var k=0;
					do
					{
						//if array item is not undefined
						if(typeof um[um.cx[i]][j][k]!=um.un)
						{
							//process it
							um.pcv(um[um.cx[i]][j][k]);
						}
						k++;
					}
					while(k<um.cxl);

					//if this is um.v
					if(um.cx[i]=='menuClasses')
					{
						//copy this array
						um.v[j]=um[um.cx[i]][j];

						//increment matrix counter
						um.vl++;
					}
					//if this is um.w
					else
					{
						//copy this array
						um.w[j]=um[um.cx[i]][j];

						//increment matrix counter
						um.wl++;
					}
				}
			}
		}
		i++;
	}
	while(i<9);


	//cpstop


	//find keyboard module by looking for um.keys    //but some browsers don't support it
	//um.kb=(typeof um.keys!=um.un&&!(um.mie||um.o7||um.s));
	//CHANGED: um.kb=(typeof um.keys!=um.un&&!(um.mie||um.o7||(um.s&&!um.s2)));
	um.kb=(typeof um.keys!=um.un&&!(um.mie||um.o7||um.k||(um.s&&!um.s2)));

	//opera 7.1+ can navigate using spatial navigation,
	//but it doesn't support the hotkey or custom arrow-key navigation
	//because it doesn't allow default-action suppression
	//konqueror 3.2+ also has partial support
	//it can tab navigate the whole structure
	//but it doesn't support the hotkey or custom arrow-key navigation
	//because the event keyCode always comes back as 0
	//CHANGED: um.skb=(um.kb||(typeof um.keys!=um.un&&(um.o7&&!um.o71)));
	um.skb=(um.kb||(typeof um.keys!=um.un&&((um.o7&&!um.o71)||um.k)));


	//find speech module by looking for um.speech // only win/ie supports it
	um.sp=(typeof um.speech!=um.un&&um.wie);

	//when using speech (for all browsers for consistency)
	if(typeof um.speech!=um.un)
	{
		//all menus must open in the same direction
		//and the nav and menus must have the same orientation
		//this makes it easier to use
		//therefore,turn off reposition menus
		//and force the orientation to be vertical
		um.e[12]='no';
		um.e[0]='vertical';
	}


	//cpstart


	//detect relative positioning
	um.rp=(um.e[3]=='relative');



	//cpstop

	//disable reposition menus for win/ie5.0 with relpos v-align navbar
	//because getRealPosition(obj,'y') always returns 0
	if(um.wie50&&um.rp){um.e[12]='no';}


	//cpstart


	//get writing mode from h align variable
	//and set right alignment if it's there
	um.dir='left';
	if(um.e[1]=='rtl'){um.dir='right';um.e[1]='right';}




	//cpstop

	//map old values for windowed control management for backward compatibility
	um.e[13]=(um.e[13]=='yes')?'default':(um.e[13]=='no')?'iframe':um.e[13];


	//detect whether select element hiding is being used
	um.hz=(um.wie50&&um.e[13]=='default')||(um.wie&&um.e[13]=='hide');



	//cpstart


	//detect horizontal navbar
	um.h=um.e[0]=='horizontal';

	//restrict positions to positive values
	i=4;do{if(parseFloat(um.e[i],10)<0){um.e[i]='0';}i++}while(i<6);

	//if rtl text with an h-nav is in use make x an inverse number
	if(um.h&&um.dir=='right'){um.e[4]='-'+um.e[4];}


	//detect popup alignment
	um.p=um.e[0]=='popup';


	//cpstop



	//convert values for popup aligment
	if(um.p)
	{
		um.va=['left','top','absolute','-2000px','-2000px'];
		i=0;do{um.e[i+1]=um.va[i];i++}while(i<5);
		um.e[14]=0;
		um.e[15]=0;
	}


	//CHANGED: detect expanding menus
	um.ep=0;if(um.e[0]=='expanding'){um.ep=1;um.e[0]='vertical';}

	//CHANGED:FT: detect foldertree menus
	//um.ft=0;if(um.e[0]=='foldertree'){um.ep=1;um.ft=1;um.e[0]='vertical';}


	//cpstart

	//store right alignment
	um.a=(um.e[1]=='right');


	//cpstop

	//detect rigid overflow//not supported for RTL text
	um.rg=(um.h&&um.e[7]=='rigid'&&um.dir!='right');


	//cpstart

	//detect position fixed // not supported for IE5-6 or old gecko
	//implement IE5-6 JS equivalent if value is "allfixed"
	//IE7: exclude ie7 from this because it supports true position fixed
	um.fe=false;if(um.e[3]=='allfixed'){um.e[3]='fixed';if(um.wie5||um.wie6){um.fe=true;}}
	um.f=(um.e[3]=='fixed'&&!(um.wie5||um.wie6||um.og));


	//detect active border collapse
	um.nc=(um.e[17]==0&&um.e[19]=='collapse');
	um.mc=(um.e[61]==0&&um.e[63]=='collapse');


	//cpstop


	//no menus for ..
	//	- old gecko builds with relpos
	//	- old mac/ie5 with an h-nav
	//	- ancient gecko or win/ie5.0 with RTL text
	um.nm=((um.og&&um.rp)||(um.omie&&um.h)||((um.dg||um.wie50)&&um.dir=='right'));

	//no arrows for ..
	//	- nomenus group
	//	- mac/ie5
	um.nr=(um.nm||um.mie);

	//no dropshadows for ..
	//	- ancient gecko builds
	//	- opera 7.1 or earlier
	//	- win/ie5.0 with relative positioning
	//	- opera 7 with position:fixed
	//	- mac/ie5
	um.ns=(um.dg||um.o71||(um.wie50&&um.rp)||(um.o7&&um.f)||um.mie);



	//cpstart


	//test support for creating namespaced elements,which allows the script to work within XHTML
	um.cns=(typeof um.m.createElementNS!=um.un);

	//cpstop


	//we also need to use document.styleSheets because document.write won't work
	//IE supports it but uses a proprietary rule syntax
	//that doesn't matter,because IE doesn't support XHTML anyway
	//so we just exclude it by additionally testing for createElementNS
	//safari and konqueror support createElementNS,and they say they supports document.styleSheets
	//but the latter doesn't work properly,so we need to exclude them specifically
	um.ss=(um.cns&&typeof um.m.styleSheets!=um.un&&!(um.s||um.k));

	//4.51 ADDED: Safari 3 supports document.styleSheets properly now
	if(um.s3){um.ss=1;}


	//if keyboard module is in use
	if(um.kb)
	{
		//convert key-handling codes to number
		i=0;do{um.keys[i]=um.pi(um.keys[i]);i++}while(i<5);
		if(um.keys[6]!='none'){um.keys[6]=um.pi(um.keys[6]);}
		else{um.keys[6]=-1;}
	}

	//find arrow images
	//using a regex literal here
	//because mac/ie5.0 doesn't
	//garbage collect the RegExp constructor properly
	um.ni=/(gif|png|mng|jpg|jpeg|jpe|bmp)/i.test(um.e[45]);
	um.mi=/(gif|png|mng|jpg|jpeg|jpe|bmp)/i.test(um.e[89]);


}




//api receivers array
um.rn=0;um.rv=[];

//add to receivers array method
um.addReceiver=function(f,c)
{
	um.rv[um.rn++]=[f,c];
};

//get parent <li> method
um.gp=function(n)
{
	//if input is null,return null
	//if input is a list-item (nodeName converted for O7 in XHTML mode) return it
	//otherwise recur
	return n?um.vn(n.nodeName).toLowerCase()=='li'?n:this.gp(n.parentNode):null;
};


//cpstart

//create element and attributes based on a method by beetle (http://www.peterbailey.net/)
//see http://www.codingforums.com/showthread.php?t=29097 for details
um.createElement=function(n,a)
{
	um.el=(um.cns)?um.m.createElementNS('http://www.w3.org/1999/xhtml',n):um.m.createElement(n);
	if(typeof a!=um.un)
	{
		for(var i in a)
		{
			switch(i)
			{
				case 'text' :
					um.el.appendChild(um.m.createTextNode(a[i]));
					break;
				case 'class' :
					um.el.className=a[i];
					break;
				default :
					um.el.setAttribute(i,'');
					um.el[i]=a[i];
					break;
			}
		}
	}
	return um.el;
};


//cpstop
/*--------------------------------------------------------------------------*/
///modletInclude/udm/js/udm-style.js
/*--------------------------------------------------------------------------*/
// UDMv4.52 //
///////////////////////////////////////////////////////////////////
//                                                               //
//  ULTIMATE DROP DOWN MENU Version 4.52 by Brothercake           //
//  http://www.udm4.com/                                         //
//                                                               //
//  This script may not be used or distributed without license   //
//                                                               //
///////////////////////////////////////////////////////////////////
if(um.b){um.bk=function(udmP){return (/(gif|png|mng|jpg|jpeg|jpe|bmp)/i.test(udmP))?'background-image:url('+um.baseSRC+udmP+');':(udmP=='none')?'':um.t[33]+'background-color:'+udmP+';';};um.t=['margin-left:','padding-top:','@media screen,projection{','margin-top:0;','padding-left:','border-width:','border-color:','border-style:','margin-left:0;','display:none;','margin-right:','text-decoration:','position:absolute;','margin-bottom:','visibility:hidden;','cursor:default !important;','position:static;','display:block;','@media Screen,Projection{','position:relative;','* html .udm ul ',' a:hover .udmA',' a:focus .udmA',' a:visited .udmA','',' a:visited:hover',' a.nohref:focus',' a.nohref:hover','width:auto;height:auto;','cursor:pointer !important;','background-repeat:no-repeat;background-position:','',' a.nohref .udmA','background-image:none;','* html .udm li a',' a.udmR:visited',' a.udmR .udmA',' a.udmY:visited',' a.udmY .udmA','display:block;visibility:visible;height:0;','overflow:scroll;','overflow:visible;'];var j=0;um.r=[];um.ad=(um.a)?'left':'right';um.dra=(um.dir=='right');um.r[j++]='.udm,.udm li,.udm ul{margin:0;padding:0;list-style-type:none;}';if(um.dra){if(um.h&&um.rp){um.r[j++]='* html .udm{left:100%;left:expression(this.offsetWidth);left/**/:0 !important;}';}um.r[j++]='.udm,.udm li,.udm ul{unicode-bidi:bidi-override;direction:ltr;}';um.r[j++]='.udm a *,.udm a {unicode-bidi/**/:bidi-override;direction/**/:rtl;}';}um.na=(um.h)?'left':um.e[1];um.txl=(um.h)?'left':um.e[35];um.r[j++]='.udm{position:'+um.e[3]+';'+um.na+':0;'+um.e[2]+':0;z-index:'+(um.e[6]+19000)+';width:'+um.e[16]+';'+um.t[15]+'border:none;text-align:left;}';if(um.e[3]=='fixed'){um.r[j++]='* html .udm{'+um.t[12]+'}';um.r[j++]='ul[id="udm"]{'+um.t[12]+'}';um.r[j++]='ul/**/[id="udm"]{position:fixed;}';}if(um.h){um.hfl=(um.hstrip[0]=='none')?'none':um.dir;um.r[j++]='.udm{'+um.bk(um.hstrip[0])+'float:'+um.hfl+';width:100%;}';if(um.hstrip[0]!='none'){um.r[j++]='ul[class="udm"]{float:none;}';um.r[j++]='ul/**/[class="udm"]{float:'+um.dir+';}';um.r[j++]='.udm{margin-'+um.e[2]+':0;'+um.e[2]+':'+um.e[5]+';}';um.r[j++]=um.t[2]+'.udm{margin-'+um.e[2]+':'+um.e[5]+';'+um.e[2]+':0}}';}else{um.r[j++]=um.t[2]+'.udm{float:'+um.dir+';}}';if(um.rp){um.r[j++]='.udm{padding-'+um.e[2]+':'+um.e[5]+';}';}else{um.r[j++]='.udm{margin-'+um.e[2]+':'+um.e[5]+';}';}}if(um.dra){um.r[j++]='.udm>li:first-child{margin-right:'+um.e[4].replace('-','')+';}';}else{um.r[j++]='.udm>li:first-child{'+um.t[0]+um.e[4]+';}';}um.r[j++]=um.t[18]+'.udm>li:first-child{'+um.t[8]+'margin-right:0;}}';um.r[j++]='.udm li{left:'+um.e[4]+';}';um.r[j++]=um.t[2]+'.udm li{'+um.t[19]+'}}';um.r[j++]='.udm ul li{left:0;}';um.r[j++]=':root ul[class^="udm"] li{left:0;'+um.t[16]+'}';um.r[j++]=um.t[18]+':root ul[class^="udm"] li{left:'+um.e[4]+';'+um.t[19]+'}}';um.r[j++]=um.t[18]+'.udm/**/[class="udm"]:not([class="xxx"]) ul li{'+um.t[19]+'left:0;}}';um.r[j++]='.udm li{'+um.t[17]+'width:auto;float:'+um.dir+';}';um.r[j++]='.udm li a{'+um.t[16]+um.t[17]+'float:'+um.dir+';white-space:nowrap;}';um.r[j++]=um.t[2]+'.udm l\\i a{'+um.t[19]+'float:none;}}';um.r[j++]='ul[class^="udm"] li a{'+um.t[19]+'float:none;}';um.r[j++]=um.t[2]+um.t[34]+'{'+um.t[19]+'float:none;}}';if(um.dra){um.r[j++]=um.t[2]+um.t[34]+'{'+um.t[16]+'}}';um.r[j++]='ul[class$="udm"].udm li a{'+um.t[16]+'}';um.r[j++]='ul[class$="udm"].udm:not([class="xxx"]) li a{'+um.t[19]+'}';um.r[j++]='@media all and (min-width:0px){ul[class$="udm"].udm li a{'+um.t[19]+'}}';}um.r[j++]='.udm ul li a{'+um.t[19]+'float:none !important;white-space:normal;}';if(um.nc){um.r[j++]='.udm li a{'+um.t[0]+'-'+um.e[18]+'px;}';um.r[j++]=um.t[18]+'.udm li{'+um.t[0]+'-'+um.e[18]+'px !important;}}';um.r[j++]=um.t[18]+'.udm li a{'+um.t[8]+'}}';um.r[j++]='ul[class^="udm"] li:not(:first-child){'+um.t[0]+'-'+um.e[18]+'px;}';um.r[j++]='.udm ul li{'+um.t[0]+'0 !important;}';um.r[j++]='ul[class^="udm"]:not([class="xxx"]) ul li{'+um.t[0]+'0 !important;}';}else{um.r[j++]='.udm li,.udm li:first-child{'+um.t[10]+um.e[17]+'px;}';um.r[j++]='.udm ul li{'+um.t[8]+um.t[10]+'0;}';if(um.hstrip[1]=='yes'){um.r[j++]='.udm li a{'+um.t[13]+um.e[17]+'px;}';um.r[j++]='.udm ul li a{'+um.t[13]+'0;}';um.r[j++]='ul[class^="udm"]:not([class="xxx"]) li a{'+um.t[13]+'0;}';um.r[j++]='ul[class^="udm"]:not([class="xxx"]) li{'+um.t[13]+um.e[17]+'px;}';um.r[j++]='ul[class^="udm"]:not([class="xxx"]) ul li{'+um.t[13]+'0;}';}}}else{if(um.rp){um.r[j++]='.udm{'+um.t[16]+'padding-'+um.e[1]+':'+um.e[4]+';padding-'+um.e[2]+':'+um.e[5]+';}';}else{um.r[j++]='.udm{margin-'+um.e[1]+':'+um.e[4]+';margin-'+um.e[2]+':'+um.e[5]+';}';}um.ps=(um.p)?'absolute':'static';um.r[j++]='.udm li{'+um.t[17]+'width:'+um.e[16]+';position:'+um.ps+';}';um.ps=(um.p)?'static':'relative';um.r[j++]=um.t[18]+':root .udm/**/[class="udm"] li{position:'+um.ps+';}}';um.r[j++]=um.t[18]+':root .udm/**/[class="udm"] ul li{'+um.t[19]+'}}';um.r[j++]='.udm li a{'+um.t[19]+um.t[17]+'}';if(um.nc){um.r[j++]='.udm a{margin-top:-'+um.e[18]+'px;}';}else{um.r[j++]='.udm li{'+um.t[13]+um.e[17]+'px;}';um.r[j++]='.udm ul li{'+um.t[13]+'0;}';}}um.r[j++]='.udm ul a{margin:0;}';if(um.mc){um.r[j++]='.udm ul li{margin-top:-'+um.e[62]+'px;}';um.r[j++]='.udm ul li:first-child{margin-top:0px;}';}else{um.r[j++]='.udm ul li{'+um.t[13]+um.e[61]+'px !important;}';um.r[j++]='.udm ul li:first-child{margin-top:'+um.e[61]+'px;}';um.r[j++]='.udm ul a{margin-top:0;margin-right:'+um.e[61]+'px !important;margin-bottom:0;'+um.t[0]+um.e[61]+'px !important;}';}um.r[j++]='.udm ul{'+um.bk(um.e[56])+um.t[15]+'width:'+um.e[54]+';height:auto;'+um.t[5]+um.e[51]+'px;'+um.t[6]+um.e[52]+';'+um.t[7]+um.e[53]+';'+um.t[12]+'z-index:'+(um.e[6]+19100)+';padding:'+um.e[55]+'px;'+um.e[57]+'}';um.r[j++]='.udm ul li{'+um.t[15]+'width:100%;'+um.t[16]+'float:none;}';if(!(um.mc)&&um.e[61]>0&&!um.a){um.r[j++]='ul[class^="udm"].udm ul{padding-bottom:'+(um.e[55]+um.e[61])+'px;}';um.r[j++]='ul[class^="udm"].udm:not([class="xxx"]) ul{padding-bottom:'+um.e[55]+'px;}';um.r[j++]='@media all and (min-width:0px){ul[class^="udm"].udm ul{padding-bottom:'+um.e[55]+'px;}}';}um.r[j++]='.udm ul{'+um.t[9]+um.t[14]+'}';um.r[j++]='html/**/[xmlns] .udm u\\l{'+um.t[39]+um.t[40]+'left:-10000px;}';um.r[j++]=um.t[2]+um.t[20]+'{'+um.t[39]+um.t[40]+'top:-10000px;}}';um.r[j++]='ul.udm/**/[class^="udm"] u\\l{'+um.t[39]+um.t[41]+'left:-1000em;}';if(um.dir=='right'){um.r[j++]='ul.udm[class$="udm"] ul{top:-1000em;left:0;}';um.r[j++]='ul.udm[class$="udm"]:not([class="xxx"]) ul{top:0;left:-1000em;}';}if(um.e[45]!='none'||um.e[89]!='none'){um.r[j++]='.udm a .udmA{visibility:hidden;margin:0 '+um.e[26]+'px;'+um.t[17]+um.t[29]+um.t[12]+um.ad+':0;top:0;text-align:'+um.ad+';border:none;cursor:inherit !important;}';um.r[j++]='.udm a .udmA img{display:block;}';um.r[j++]='.udm ul a .udmA{margin:0 '+um.e[70]+'px;}';if(um.a){um.r[j++]='* html .udm '+((um.h)?'ul ':'')+'a{height:1%;}';um.r[j++]='ul[class$="udm"].udm '+((um.h)?'ul ':'')+'a{height:1%;}';if(um.h&&um.dir!='right'){um.r[j++]='* html .udm a/**/ {width:expression("auto",this.runtimeStyle.width=(!document.compatMode||compatMode=="BackCompat")?"100%":(this.parentNode.offsetWidth-(isNaN(parseInt(this.currentStyle.marginRight))?0:parseInt(this.currentStyle.marginRight))-(isNaN(parseInt(this.currentStyle.marginLeft))?0:parseInt(this.currentStyle.marginLeft))-(isNaN(parseInt(this.currentStyle.paddingRight))?0:parseInt(this.currentStyle.paddingRight))-(isNaN(parseInt(this.currentStyle.paddingLeft))?0:parseInt(this.currentStyle.paddingLeft))-(isNaN(parseInt(this.currentStyle.borderRightWidth))?0:parseInt(this.currentStyle.borderRightWidth))-(isNaN(parseInt(this.currentStyle.borderLeftWidth))?0:parseInt(this.currentStyle.borderLeftWidth))));}';um.r[j++]='* html .udm ul a{width:auto;}';um.r[j++]='ul[class$="udm"].udm a .udmA{left:'+(um.e[26])+'px;}';um.r[j++]='ul[class$="udm"].udm ul a .udmA{left:0;}';um.r[j++]='ul[class$="udm"].udm:not([class="xxx"]) a .udmA{left:0;}';um.r[j++]='@media all and (min-width:0px){ul[class$="udm"].udm a .udmA{left:0;}}';}if(um.h&&um.dir=='right'){um.r[j++]='ul[class$="udm"].udm a .udmA{top:expression("0",um.q?"0":"'+um.e[18]+'px");left:expression("0",um.q?"0":"'+(um.e[18])+'px");}';um.r[j++]='ul[class$="udm"].udm ul a .udmA{top:expression("0",um.q?"0":"'+(um.e[55]+um.e[61]+um.e[62])+'px");left:expression("0",um.q?"0":"'+(um.e[55]+um.e[61]+um.e[62])+'px");}';}}else{um.r[j++]='* html .udm a .udmA{'+um.ad+':'+um.e[18]+'px;top:'+um.e[18]+'px;}';um.r[j++]=um.t[20]+'a .udmA{'+um.ad+':'+(um.e[62]+um.e[61])+'px;top:'+um.e[62]+'px;}';}}if(um.e[58]!='none'){um.mrg=um.t[0]+um.e[59]+';margin-top:'+(um.e[59]==0?0:um.e[59].replace('-',''))+';';um.r[j++]='.udm .udmS{'+um.mrg+'}';um.r[j++]='.udm .udmS{'+um.bk(um.e[58])+um.t[15]+um.t[12]+'z-index:'+(um.e[6]+19050)+';'+um.t[28]+'left:0px;top:0px;'+um.t[9]+um.e[60]+'}';if(/filter\:progid\:DXImageTransform\.Microsoft\.Shadow/.test(um.e[60])){um.r[j++]=um.t[2]+'* html .udm .udmS/**/ {'+um.t[33]+'background:#ccc;'+um.t[8]+um.t[3]+'}}';um.r[j++]='ul[class$="udm"].udm .udmS{'+um.t[33]+'background:#ccc;'+um.t[8]+um.t[3]+'}';um.r[j++]='ul[class$="udm"].udm:not([class="xxx"]) .udmS{background:transparent;'+um.bk(um.e[58])+um.mrg+'}';um.r[j++]='@media all and (min-width:0px){ul[class$="udm"].udm .udmS{background:transparent;'+um.bk(um.e[58])+um.mrg+'}}';}}um.r[j++]='.udm a,.udm a:link,.udm a.nohref{'+um.bk(um.e[28])+um.t[29]+'z-index:'+um.e[6]+';text-align:'+um.txl+';'+um.t[7]+um.e[21]+';'+um.t[6]+um.e[20]+';'+um.t[4]+um.e[26]+'px;padding-right:'+um.e[26]+'px;'+um.t[1]+um.e[27]+'px !important;padding-bottom:'+um.e[27]+'px !important;'+um.t[11]+um.e[34]+';color:'+um.e[36]+';'+um.t[5]+um.e[18]+'px;font-style:'+um.e[39]+';font-family:'+um.e[32]+';font-weight:'+um.e[33]+' !important;}';um.r[j++]='.udm a,.udm a.nohref{font-size:'+um.e[31]+';}';if(um.e[45]!='none'||um.e[89]!='none'){um.r[j++]='.udm a .udmA,.udm a:link .udmA,.udm'+um.t[32]+'{font-family:'+um.e[32]+';font-weight:'+um.e[33]+' !important;}';}if(um.e[42]!=''){um.r[j++]='.udm li a,.udm li a:link,.udm li a.nohref,.udm li a:visited{'+um.e[42]+'}';}um.r[j++]='.udm li a:visited{'+um.bk(um.e[30])+um.t[5]+um.e[18]+'px;color:'+um.e[38]+';font-style:'+um.e[41]+';'+um.t[7]+um.e[25]+';'+um.t[6]+um.e[24]+';'+um.e[44]+'}';um.r[j++]='.udm li a.udmR,.udm li a.udmY,.udm li'+um.t[35]+',.udm li'+um.t[37]+',.udm li a:hover,.udm li a:focus,.udm li'+um.t[27]+',.udm li'+um.t[26]+'{font-style:'+um.e[40]+';'+um.bk(um.e[29])+um.t[11]+um.e[34]+';color:'+um.e[37]+';'+um.t[6]+um.e[22]+';'+um.t[7]+um.e[23]+';'+um.t[5]+um.e[18]+'px;'+um.e[43]+'}';um.r[j++]='* html .udm li a:active{font-style:'+um.e[40]+';'+um.bk(um.e[29])+um.t[11]+um.e[34]+';color:'+um.e[37]+';'+um.t[6]+um.e[22]+';'+um.t[7]+um.e[23]+';'+um.t[5]+um.e[18]+'px;'+um.e[43]+'}';um.r[j++]='.udm ul a,.udm ul a:link,.udm ul a.nohref{'+um.bk(um.e[72])+'text-align:'+um.e[79]+';'+um.t[5]+um.e[62]+'px;'+um.t[7]+um.e[65]+';'+um.t[6]+um.e[64]+';'+um.t[4]+um.e[70]+'px;padding-right:'+um.e[70]+'px;'+um.t[1]+um.e[71]+'px !important;padding-bottom:'+um.e[71]+'px !important;'+um.t[11]+um.e[78]+';color:'+um.e[80]+';font-style:'+um.e[83]+';font-size:'+um.e[75]+';font-family:'+um.e[76]+';font-weight:'+um.e[77]+' !important;}';if(um.e[89]!='none'){um.r[j++]='.udm ul a .udmA,.udm ul a:link .udmA,.udm ul'+um.t[32]+'{font-family:'+um.e[76]+';font-weight:'+um.e[77]+' !important;}';}if(um.e[86]!=''){um.r[j++]='.udm ul li a,.udm ul li a:link,.udm ul li a.nohref,.udm ul li a:visited{'+um.e[86]+'}';}um.r[j++]='.udm ul li a:visited,'+um.t[20]+'li a:visited{'+um.bk(um.e[74])+'color:'+um.e[82]+';font-style:'+um.e[85]+';'+um.t[5]+um.e[62]+'px;'+um.t[7]+um.e[69]+';'+um.t[6]+um.e[68]+';'+um.e[88]+'}';um.r[j++]='.udm ul li a.udmR,.udm ul li a.udmY,.udm ul li'+um.t[35]+',.udm ul li'+um.t[37]+',.udm ul li a:hover,.udm ul li a:focus,.udm ul li'+um.t[27]+',.udm ul li'+um.t[26]+',.udm ul li'+um.t[25]+'{font-style:'+um.e[84]+';'+um.bk(um.e[73])+um.t[11]+um.e[78]+';color:'+um.e[81]+';'+um.t[6]+um.e[66]+';'+um.t[7]+um.e[67]+';'+um.t[5]+um.e[62]+'px;'+um.e[87]+'}';um.r[j++]='* html .udm ul li a:active{font-style:'+um.e[84]+';'+um.bk(um.e[73])+um.t[11]+um.e[78]+';color:'+um.e[81]+';'+um.t[6]+um.e[66]+';'+um.t[7]+um.e[67]+';'+um.t[5]+um.e[62]+'px;'+um.e[87]+'}';um.r[j++]='.udm a.nohref,.udm ul a.nohref{cursor:default !important;}';um.r[j++]='.udm h3,.udm h4,.udm h5,.udm h6{display:block;background:none;margin:0;padding:0;border:none;font-size:1em;font-weight:normal;text-decoration:none;}';if(um.h){um.r[j++]='.udm h3,.udm h4,.udm h5,.udm h6{display:inline;}';um.r[j++]='.udm h\\3,.udm h\\4,.udm h\\5,.udm h\\6{display:block;}';um.r[j++]='ul[class^="udm"] h3,ul[class^="udm"] h4,ul[class^="udm"] h5,ul[class^="udm"] h6{display:block;}';um.r[j++]='* html .udm h3,* html .udm h4,* html .udm h5,* html .udm h6{display:block;}';um.r[j++]='* html .udm h3,* html .udm h4,* html .udm h5,* html .udm h6{width:expression("auto",this.runtimeStyle.width=this.parentNode.offsetWidth);width/**/:auto;}';um.r[j++]='* html .udm ul h3,* html .udm ul h4,* html .udm ul h5,* html .udm ul h6{width:expression("auto",this.runtimeStyle.width=this.parentNode.currentStyle.width);width/**/:auto;}';}else{um.r[j++]='.udm h1,.udm h2,.udm h3,.udm h4,.udm h5,.udm h6{width:100%;}';}um.r[j++]=um.t[2]+'* html .udm li{display:inline;}}';um.floats=(um.h)?um.dir:um.e[1];um.r[j++]=um.t[2]+'* html .udm li,* html .udm ul li{display/**/:block;float/**/:'+um.floats+';}}';if(um.h){um.r[j++]=um.t[2]+'* html .udm li,'+um.t[20]+'li{clear:none;}}';}um.r[j++]='ul[class$="udm"].udm li,ul[class$="udm"].udm ul li{display:block;float:'+um.floats+';}';um.floats=(um.h)?um.dir:'none';um.r[j++]='ul[class$="udm"].udm:not([class="xxx"]) li{float:'+um.floats+';}';um.r[j++]='ul[class$="udm"].udm:not([class="xxx"]) ul li{float:none;}';um.r[j++]='@media all and (min-width:0px){ul[class$="udm"].udm li{float:'+um.floats+';}}';um.r[j++]='@media all and (min-width:0px){ul[class$="udm"].udm ul li{float:none;}}';if(um.e[13]=='default'||um.e[13]=='hide'){um.r[j++]='select{visibility:visible;}';}if(um.e[13]=='default'||um.e[13]=='iframe'){um.r[j++]='.udm .udmC{'+um.t[12]+'left:0;top:0;z-index:'+(um.e[6]+19020)+';'+um.t[28]+'filter:alpha(opacity=0);}';}if(um.vl>0){for(i in um.v){if(typeof um.v[i]!='function'){um.r[j++]='.udm ul.'+i+'{width:'+um.v[i][2]+';'+um.t[6]+um.v[i][0]+';'+um.t[7]+um.v[i][1]+';'+um.bk(um.v[i][3])+um.v[i][4]+'}';um.mrg=um.t[0]+um.v[i][6]+';margin-top:'+um.v[i][6].replace('-','')+';';um.r[j++]='.udm span.'+i+'{'+um.mrg+'}';if(/filter\:progid\:DXImageTransform\.Microsoft\.Shadow/.test(um.v[i][7])){um.r[j++]=um.t[2]+'* html .udm span.'+i+'/**/ {'+um.t[8]+um.t[3]+'}}';um.r[j++]='ul[class$="udm"].udm span.'+i+'{'+um.t[8]+um.t[3]+'}';um.r[j++]='ul[class$="udm"].udm:not([class="xxx"]) span.'+i+'{'+um.mrg+'}';um.r[j++]='@media all and (min-width:0px){ul[class$="udm"].udm span.'+i+'{'+um.mrg+'}}';}if(um.v[i][5]!='none'){um.r[j++]='.udm span.'+i+'{'+um.bk(um.v[i][5])+'filter:none;'+um.v[i][7]+'}';}}}}if(um.wl>0){for(i in um.w){if(typeof um.w[i]!='function'){um.bg=um.bk(um.w[i][6]);um.r[j++]='.udm li.'+i+' a,.udm li.'+i+' a:link,.udm li.'+i+' a.nohref{'+um.t[6]+um.w[i][0]+';'+um.t[7]+um.w[i][1]+';'+um.t[5]+um.e[62]+'px;'+um.bg+um.t[11]+um.w[i][12]+';text-align:'+um.w[i][13]+';color:'+um.w[i][14]+';font-style:'+um.w[i][17]+';font-size:'+um.w[i][9]+';}';um.r[j++]='.udm li.'+i+' a,.udm li.'+i+' a:link,.udm li.'+i+um.t[32]+',.udm li.'+i+' a,.udm li.'+i+um.t[32]+'{font-family:'+um.w[i][10]+';font-weight:'+um.w[i][11]+' !important;}';if(um.w[i][20]!=''){um.r[j++]='.udm ul li.'+i+' a,.udm ul li.'+i+' a:link,.udm ul li.'+i+' a.nohref,.udm ul li.'+i+' a:visited{'+um.w[i][20]+'}';}um.r[j++]='.udm ul li.'+i+' a:visited,'+um.t[20]+'li.'+i+' a:visited{'+um.bk(um.w[i][8])+'color:'+um.w[i][16]+';font-style:'+um.w[i][19]+';'+um.t[5]+um.e[62]+'px;'+um.t[6]+um.w[i][4]+';'+um.t[7]+um.w[i][5]+';'+um.w[i][22]+'}';um.r[j++]='.udm ul li.'+i+' a.udmR,.udm ul li.'+i+' a.udmY,.udm ul li.'+i+um.t[35]+',.udm ul li.'+i+um.t[37]+',.udm ul li.'+i+' a:hover,.udm ul li.'+i+' a:focus,.udm ul li.'+i+um.t[27]+',.udm ul li.'+i+um.t[26]+',.udm ul li.'+i+um.t[25]+'{'+um.bk(um.w[i][7])+um.t[11]+um.w[i][12]+';color:'+um.w[i][15]+';'+um.t[5]+um.e[62]+'px;'+um.t[6]+um.w[i][2]+';'+um.t[7]+um.w[i][3]+';font-style:'+um.w[i][18]+';'+um.w[i][21]+'}';um.r[j++]='* html .udm li.'+i+' a:active{'+um.bk(um.w[i][7])+um.t[11]+um.w[i][12]+';color:'+um.w[i][15]+';'+um.t[5]+um.e[62]+'px;'+um.t[6]+um.w[i][2]+';'+um.t[7]+um.w[i][3]+';font-style:'+um.w[i][18]+';'+um.w[i][21]+'}';}}}um.rLen=um.r.length;if(um.ss||um.o73){um.at={'type':'text/css','media':'screen,projection'};um.stn=um.createElement('html:style',um.at);document.getElementsByTagName('head')[0].appendChild(um.stn);if(um.ss){if(document.styleSheets.length==0){um.ss=0;}else{um.sy=document.styleSheets.item(document.styleSheets.length-1);i=0;do{try{um.sy.insertRule(um.r[i++],um.sy.cssRules.length);}catch(err){}}while(i<um.rLen);}}else if(um.o73){i=0;do{um.stn.appendChild(document.createTextNode(um.r[i++]));}while(i<um.rLen);}}if(!(um.ss||um.o73)){um.styStr='';i=0;do{um.styStr+=um.r[i++];}while(i<um.rLen);document.write('<style type="text/css" media="screen,projection">'+um.styStr+'</style>');}}
/*--------------------------------------------------------------------------*/
///modletInclude/udm/js/udm-dom.js
/*--------------------------------------------------------------------------*/
// UDMv4.52 //
///////////////////////////////////////////////////////////////////
//                                                               //
//  ULTIMATE DROP DOWN MENU Version 4.52 by Brothercake          //
//  http://www.udm4.com/                                         //
//                                                               //
//  This script may not be used or distributed without license   //
//                                                               //
///////////////////////////////////////////////////////////////////
um.ap=function(c,v){var r=um.rv.length;if(r>0){for(var i=0;i<r;i++){if(um.rv[i][1]==''){um.rv[i][0](v,c);}else if(c==um.rv[i][1]){um.rv[i][0](v);}}}};if(um.wie){um.eva=[];um.ex=['onmouseover','onmouseout','onmousedown','onmouseup','onclick','onmousewheel','onfilterchange','onkeydown','onfocus','onactivate','onscroll','over','out'];um.gg=um.ex.length;window.attachEvent('onunload',function(){um.lil=umTree.getElementsByTagName('li');for(var i=0;i<um.lil.length;i++){um.gc(um.lil[i]).detachEvent((um.wie55)?'onactivate':'onfocus',um.eva[i]);i++;}um.da=document.all.length;i=0;do{um.t=document.all[i];j=0;do{um.t[um.ex[j]]=null;j++;}while(j<um.gg);i++;}while(i<um.da);});}if(!um.k&&typeof window.addEventListener!=um.un){window.addEventListener('load',umIni,0);}else if(um.o7){um.m.addEventListener('load',umIni,0);}else if(um.wie){window.attachEvent('onload',umIni);}else{if(typeof window.onload=='function'){um.on=onload;window.onload=function(){um.on();umIni();};}else{window.onload=umIni;}}function umIni(g){if(typeof g==um.un){g=1;}if(typeof um.ini!=um.un||(um.k&&typeof window.sidebar==um.un)){return;}if(um.drt){clearTimeout(um.drt);}um.ini=1;um.ha=0;umTree=(um.b)?um.gd('udm'):null;if(umTree&&um.d){if(g){um.ap('000',umTree);}for(i in um.menuCode){var l=um.gd(i);if(l){if(um.mie){um.menuCode[i]=um.menuCode[i].replace(/<\/(li|ul)>/ig,'</$1>\n');}l.innerHTML+=um.menuCode[i];if(um.mie){um.dm=um.gm(l);um.xn(um.dm);um.xh(um.dm);}}}um.bub=0;um.wsr=0;um.rtl=um.m.getElementsByTagName('html')[0].getAttribute('dir')=='rtl';um.kdf=0;if(um.o7){um.m.addEventListener('keydown',function(e){if(e.keyCode==16){um.kdf=1;}},0);um.m.addEventListener('keyup',function(e){if(e.keyCode==16){um.kdf=0;}},0);}um.skb=(um.skb&&typeof umKM=='function');um.kb=(um.skb&&um.kb);if(um.skb){um.kbm=new umKM;if(g){um.ap('001',um.kbm);}}um.sp=(um.sp&&typeof udmSpeechModule=='function');if(um.sp){um.sapi=new udmSpeechModule;if(g){um.ap('002',um.sapi);}}um.n=new umNav(umTree,g);if(g){um.ap('009',um.n);}if(um.fe){um.tr.style.left=(um.getScrollAmount(1))+'px';um.tr.style.top=(um.getScrollAmount())+'px';window.attachEvent('onscroll',function(){um.tr.style.left=(um.getScrollAmount(1))+'px';um.tr.style.top=(um.getScrollAmount())+'px';});}if(um.s){umTree.style.KhtmlOpacity='1';}um.s1=(typeof umTree.style.KhtmlOpacity!=um.un);um.ready=1;if(g){um.ap('010',um.tr);}}};function umNav(umTree,g){um.n=this;um.tr=umTree;if(um.wie){um.tr.style.color='black';}um.jv='javascript:void(0)';if(um.rg){um.rw=0;}var l=umTree.getElementsByTagName('li');if(l.length==0){return;}var i=0;do{if(um.wl>0){var b=um.es(l[i].className);if(b==''&&!um.ne(l[i])){var a=um.gp(l[i].parentNode);b=um.es(a.className);if(b!=''&&!um.ne(a)){l[i].className=b;}}}this.it(l[i]);if(g){um.ap('008',l[i]);}i++;}while(i<l.length);if(um.vl>0){um.mo=um.gu(um.tr);um.en=um.mo.length;if(um.en>0){i=0;do{b=um.es(um.mo[i].className);if(b==''){a=um.mo[i].parentNode.parentNode;b=um.es(a.className);if(b!=''&&b!='udm'){um.mo[i].className=b;}}i++;}while(i<um.en);}}um.mf=0;um.lf=0;um.ety=typeof document.addEventListener!=um.un?'addEventListener':typeof document.attachEvent!=um.un?'attachEvent':'';um.epx=um.ety=='attachEvent'?'on':'';if(um.ety!=''){um.m[um.ety](um.epx+'mousedown',function(e){if(!e){e=window.event;}um.mf=1;if(um.skb){um.ha=0;}clearInterval(um.oc);um.or=0;if(um.reset[0]!='no'){if(um.hz){if(!um.tr.contains(event.srcElement)){um.n.ts('visible');}}um.cm(e);}},0);um.m[um.ety](um.epx+'mouseup',function(){um.mf=0;},0);}if(um.kb){um.kbm.bdh();}if(um.skb&&um.o7){um.kbm.bfh();}if(um.rg){this.aw();}um.cc=null,um.cr=0,um.oc=null,um.or=0;if(!um.ie){um.tr.contains=function(n){return (n==null)?false:(n==this)?true:this.contains(n.parentNode);};}um.lw=um.getWindowDimensions();um.lh=um.gc(um.tr).offsetHeight;if(um.og&&um.hstrip[0]!='none'){um.tr.style.height=(um.hstrip[1]=='yes')?(um.lh+um.e[17])+'px':um.lh+'px';}var p=um.m.getElementById('udm-purecss');if(p){p.disabled=1;}um.vs=setInterval('um.n.ws()',55);};umNav.prototype.it=function(l){if(um.wie){var f=(um.wie55)?'onactivate':'onfocus';um.gc(l).attachEvent(f,um.eva[um.eva.length]=function(){if(um.kb&&!um.lf){um.bub=0;l.over(1,um.gc(l));}});}var a=um.es(l.className);var h=(a.indexOf('onclick')!=-1)?'onclick':'onmouseover';var s=um.ne(l);var umM=(typeof um.gu(l)[0]!=um.un)?um.gu(l)[0]:null;if(typeof um.fl==um.un){um.fl=um.gc(l);}if(umM&&!um.nr){if(((s&&um.e[45]!='none')||(!s&&um.e[89]!='none'))&&um.n.cck()){if(s){var r=um.e[45];var x=(um.ni)?um.e[48]:'��';}else{r=um.e[89];x=(um.mi)?um.e[92]:'��';if(typeof um.w[a]!=um.un){r=um.w[a][23];x=(um.mi)?um.w[a][25]:'��';}}if(x=='��'){var t={'class':'udmA','text':r};var u=u=um.gc(l).appendChild(um.createElement('span',t));}else{if(um.wie){um.gc(l).insertAdjacentHTML('beforeEnd','<img class=\'udmA\' alt=\''+x+'\' title=\'\' />');u=um.gc(l).lastChild;u.src=um.baseSRC+r;}else if(um.s||um.k){t={'class':'udmA'};u=um.gc(l).appendChild(um.createElement('span',t));t={'src':um.baseSRC+r,'alt':x,'title':''};u.appendChild(um.createElement('img',t));}else{t={'class':'udmA','alt':x,'title':''};u=um.gc(l).appendChild(um.createElement('img',t));u.src=um.baseSRC+r;}}if(h=='onclick'){u.onmousedown=function(){return false;}};u.onmouseover=function(e){var t=um.gp(this.parentNode).parentNode.childNodes;var n=t.length;for(var i=0;i<n;i++){if(t[i].nodeName!='#text'&&um.gu(t[i]).length>0){if(um.gu(t[i])[0].style.visibility=='visible'){(!e)?event.cancelBubble=1:e.stopPropagation();this.parentNode.style.zIndex=um.e[6]+=2;return false;break;}}clearInterval(um.oc);um.or=0;}return true;};u.onmouseout=function(){clearInterval(um.oc);um.or=0;};um.xd(u);if(s){this.wp(u,l,um.e[26],um.e[18],1);}}}if(um.mie){var v=l.getElementsByTagName('span')[0];if(typeof v!=um.un){v.onclick=function(){this.parentNode.click();};}}if(um.rg&&um.ne(l)){um.n.dw(l);}if(um.mie){t=um.gc(l);if(t.className&&/nohref/.test(t.className)){um.gc(l).href=um.jv;}}if(um.skb){um.kbm.bth(l);}l.onmousedown=function(e){um.lf=1;um.ap('030',um.gc(this));(!e)?event.cancelBubble=1:e.stopPropagation();};l.onmouseup=function(e){um.ap('035',um.gc(this));(!e)?event.cancelBubble=1:e.stopPropagation();};if(h!='onclick'){l.onclick=function(e){if(!um.bub){um.qc(um.gc(this).href);}um.bub=1;};}else if(!um.mie){l.onmouseover=function(){um.n.lr(um.gc(l),1);um.bub=0;};}if(!(um.mie&&h=='onclick')){l[h]=function(e){var v=(um.ie)?window.event.srcElement:e.target;if(v.nodeName=='#text'&&e.type=='click'){v=v.parentNode;}if(!um.gp(v)){return false;}var b=um.es(um.gp(v).className);var c=(um.lf&&!um.nm&&b.indexOf('onclick')!=-1);if(c){um.rt=um.e[10];um.e[10]=1;}if(b.indexOf('onclick')==-1){um.bub=0;}else if(!um.lf){if(!um.bub){um.qc(v.href);}um.bub=1;}this.over(0,v);if(c){um.e[10]=um.rt;um.lf=0;if(v.nodeName!='#text'&&um.gu(um.gp(v)).length>0){if(typeof v.blur!=um.un){v.blur();}if(um.gu(um.gp(v))[0].style.display=='block'){um.n.cd(this.parentNode);(!e)?event.cancelBubble=1:e.stopPropagation();return false;}(!e)?event.cancelBubble=1:e.stopPropagation();b=um.es(um.gp(v).className);return (b.indexOf('(true)')!=-1);}else{um.qc(v.href);um.bub=1;}}if(!e){e=window.event;}return (e.type=='click'||um.o7);};l.onmouseout=function(e){this.out(e);};}l.over=function(f,t){if(um.bub||(!f&&um.ha&&um.kdf)){return false;}var c=um.n.cck();if(!c||um.mf){um.mf=0;if(!um.ec){if(um.gm(this)){this.removeChild(um.gm(this));}}return false;}if(f){if(!um.wsr&&!um.ie){um.kbm.cws(um.tr);um.wsr=1;}if(um.sp){um.sapi.speechBuffer(um.gc(l));event.cancelBubble=1;}um.ha=1;if(um.ie&&event.altKey){um.n.ck(um.gp(t).parentNode);}um.ap('040',t);}if(!f){var n=um.vn(t.nodeName).toLowerCase();if(/(li|ul)/.test(n)){return false;}if(um.skb){if(!um.lf){um.e[10]=um.mt[0];um.e[11]=um.mt[1];}um.nf=um.gc(this);if(um.ha){um.n.ck(l.parentNode);um.n.cd(um.gp(t).parentNode);um.nf.focus();um.nf.blur();um.ha=0;}}um.ap('020',t);}clearInterval(um.cc);um.cr=0;um.n.lr(um.gc(l),1);um.n.pr(umM,l,f,t);return l;};l.out=function(e){if(um.o7&&um.ha&&um.kdf){return;}if(um.lf){um.gc(this).blur();}um.lf=0;if(!e){e=window.event;e.relatedTarget=e.toElement;}if(!l.contains(e.relatedTarget)){if(!um.tr.contains(e.relatedTarget)){clearInterval(um.cc);um.cr=0;}um.n.cp(umM,l);um.ap('025',um.gc(this));}};if(!um.ie){l.contains=function(n){return (n==null)?false:(n==this)?true:this.contains(n.parentNode);};}};umNav.prototype.cck=function(){if(typeof document.defaultView!=um.un&&typeof document.defaultView.getComputedStyle!=um.un){um.sa=document.defaultView.getComputedStyle(um.fl,'').getPropertyValue('display');}else if(typeof um.fl.currentStyle!=um.un&&um.fl.currentStyle){um.sa=um.fl.currentStyle.display;}um.mv=1;um.ec=(!um.wie||um.tr.currentStyle.color=='black');return ((um.sa!='inline'||typeof um.sa==um.un)&&um.ec);};umNav.prototype.lr=function(l,v){if(l&&typeof l.style!=um.un){um.cl=um.es(l.className);um.ii=um.ne(um.gp(l));if(v){l.style.zIndex=um.e[6]+=2;(um.cl=='')?l.className='udmR':l.className+=(l.className.indexOf('udmR')==-1)?' udmR':'';}else{if(um.cl.indexOf('udmR')!=-1){l.className=um.cl.replace(/([ ]?udmR)/g,'');}}um.n.wv(l,um.ii);}};umNav.prototype.pr=function(m,l,f,r){if(um.skb&&f){um.kbm.cu(m,l,r);}if(!um.nm&&m&&m.style.visibility!='visible'){if(um.wie&&!um.wie7){if(um.e[61]>0){um.gc(m).style.marginTop=um.e[61]+'px';}else if(um.e[63]=='collapse'){m.firstChild.style.marginTop=0+'px';}}if(um.skb&&f){um.n.ou(m);}if(!(um.skb&&f)){um.n.tu(m,null);}}if(m==null){um.n.tu(null,l);}};umNav.prototype.tu=function(m,l){if(um.cr){clearInterval(um.oc);um.oj=m;um.ij=l;um.or=1;um.oc=setInterval('um.n.tu(um.oj,um.ij)',um.e[10]);}else if(um.or){clearInterval(um.oc);um.or=0;this.ou(m,l);}else{um.ap('061',m);um.oj=m;um.ij=l;um.or=1;um.oc=setInterval('um.n.tu(um.oj,um.ij)',um.e[10]);}};umNav.prototype.ou=function(m,l){if(m==null){this.cd(l.parentNode);return false;}this.cd(um.gp(m).parentNode);if(typeof m.m==um.un){m.m=um.gu(m);m.l=m.m.length;if(m.l>0){for(var i=0;i<m.l;i++){um.xh(m.m[i]);um.xn(m.m[i]);}}}if(um.ep){m.style.position='static';}if(um.hz){this.ts('hidden');}um.xd(m);if(!um.nr&&um.e[89]!='none'){var c=m.childNodes.length;for(i=0;i<c;i++){var t=m.childNodes.item(i);var n=um.vn(t.nodeName).toLowerCase();if(n=='li'){var a=um.n.ga(um.gc(t));if(a){this.wp(a,t,um.e[70],um.e[62],0);}}}}um.ap('058',m);this.pu(m);if(um.e[12]=='yes'){this.ru(m);}um.mp={x:(m.offsetLeft),y:(m.offsetTop)};um.sh=null;if(!um.ns&&um.e[58]!='none'){this.hl(m);}if(um.wie55&&(um.e[13]=='default'||um.e[13]=='iframe')){this.il(m);}um.hf=(um.wie55&&typeof m.filters!='unknown'&&m.filters&&m.filters.length>0);if(um.hf){m.filters[0].Apply();}if(um.wie&&um.h){var t=m.parentNode;if(um.ne(t)){t=t.style;t.position='absolute';t.zIndex=um.e[6]+=2;t.position='relative';}}um.xv(m);if(um.hf){um.ap('065',m);m.filters[0].Play();if(um.sh){m.onfilterchange=function(){um.xd(um.sh);um.ap('066',m);};}}else if(um.sh){um.xd(um.sh);}if(um.wie50){um.xn(m);um.xd(m);}if(um.ep&&um.s&&m.offsetLeft<-1000){var fs=um.pi(document.defaultView.getComputedStyle(m,'').getPropertyValue('font-size'));m.style.fontSize=(fs-1)+'px';setTimeout(function(){m.style.fontSize=fs+'px';},0);}um.ap('060',m);return m;};umNav.prototype.cd=function(m){var s=um.mie?um.gt(m,'ul'):um.gu(m);var n=s.length;for(var i=0;i<n;i++){this.clm(s[i]);}};umNav.prototype.ck=function(m){var l=um.mie?um.gt(m,'a'):m.getElementsByTagName('a');var n=l.length;for(var i=0;i<n;i++){this.lr(l[i],0);}};umNav.prototype.cp=function(m,l){clearTimeout(um.oc);um.or=0;this.lr(um.gc(l),0);if(!um.nm&&m){this.cot(m);}};umNav.prototype.cot=function(m){if(um.cr){clearInterval(um.cc);um.cr=0;this.clm(m);}else if(um.e[11]!='never'){um.ap('071',m);um.cb=m;um.cr=1;um.cc=setInterval('um.n.cot(um.cb)',um.e[11]);}};umNav.prototype.clm=function(m){if(m.style.visibility=='visible'){if(typeof um.sim==um.un||!um.sim||um.ha){um.xh(m);um.xn(m);if(um.hz){if(um.ne(m.parentNode)){this.ts('visible');}}um.t=['udmC','udmS'];for(var i=0;i<2;i++){var b=m.parentNode.lastChild;if(b&&b.className&&b.className.indexOf(um.t[i])!=-1){m.parentNode.removeChild(b);}}}um.ap('070',m);}};umNav.prototype.ga=function(l){var a=null;var t=['span','img'];for(var k=0;k<2;k++){var s=l.getElementsByTagName(t[k]);var n=s.length;for(var j=0;j<n;j++){var b=um.es(s[j].className);if(b=='udmA'){a=s[j];break;}}}return a;};umNav.prototype.wp=function(a,l,p,b,n){a.fn=arguments;if(a.offsetHeight>0&&!um.o7){this.wpo(a.fn[0],a.fn[1],a.fn[2],a.fn[3],a.fn[4]);}else{a.c=0;a.ti=window.setInterval(function(){if(a.offsetHeight>0){clearInterval(a.ti);um.n.wpo(a.fn[0],a.fn[1],a.fn[2],a.fn[3],a.fn[4]);}else{a.c++;if(a.c>=100){clearInterval(a.ti);}}},55);}return true;};umNav.prototype.wpo=function(a,l,p,b,n){var s=um.gc(l);var t=[a.offsetWidth,a.offsetHeight];a.style.marginTop=um.pi(((s.offsetHeight-t[1])/2)-b)+'px';s.style[(um.a||um.rtl)?'paddingLeft':'paddingRight']=((p*2)+t[0])+'px';if(um.wie&&um.rtl){a.style.marginRight=((n)?(0-um.e[26]):(0-um.e[70]))+'px';}if(((um.wie50&&um.a)||(um.wie55&&um.rtl))&&n&&um.h){a.style.top=(b)+'px';a.style.left=(b)+'px';}if((n&&um.ni)||(!n&&um.mi)){var c=((n)?um.e[47]:um.e[91]);if((t[0]-c)<0){c=t[0];}a.style.clip=(um.a||um.rtl)?'rect(0,'+c+'px,'+t[1]+'px,0)':'rect(0,'+t[0]+'px,'+t[1]+'px,'+(t[0]-c)+'px)';}um.xv(a);return true;};umNav.prototype.wv=function(l,n){if(um.nr){return false;}var a=this.ga(l);if(a){var c=um.es(l.className);var r=(c.indexOf('udmR')==-1);if(c.indexOf('udmY')!=-1){r=0;}var p=um.es(um.gp(l).className);var t=(um.s||um.k)?a.firstChild:a;t.src=um.baseSRC+((n)?(r)?um.e[45]:um.e[46]:(typeof um.w[p]!=um.un)?(r)?um.w[p][23]:um.w[p][24]:(r)?um.e[89]:um.e[90]);}return a;};umNav.prototype.pu=function(m){m.style.height='auto';m.style.overflow='visible';var s=(um.ne(m.parentNode));var l=m.parentNode;var p={tw:l.offsetWidth,th:l.offsetHeight,mw:m.offsetWidth,pw:(s)?um.gc(l).offsetWidth:l.parentNode.offsetWidth};var x=(um.p)?2000:0;var y=(um.p)?2000:0;if(!((um.h||um.p)&&s)){x=(s)?(um.a?(0-p.mw):p.pw):((um.a?(0-p.mw):p.pw)-um.e[51]-um.e[55]);y=(0-p.th);}else if(um.h&&s&&um.a){x=(0-p.mw+p.tw);}x+=(s)?(um.a?(0-um.e[14]):um.e[14]):(um.a?(0-um.e[49]):um.e[49]);y+=(s)?(um.e[2]=='bottom')?(0-um.e[15]):um.e[15]:um.e[50];if(s){if(um.h){if(um.e[2]=='bottom'){y-=(m.offsetHeight+p.th);}if(um.s){if(um.nc&&!um.a){x-=um.e[18];}if(!um.s1&&um.rp){x+=um.getRealPosition(um.tr,'x');y+=um.getRealPosition(um.tr,'y');}}if(um.mie){x-=um.gc(l).offsetWidth;if(um.nc&&um.a){x+=um.e[18];}y+=p.th;}if(um.ie&&um.hstrip[1]=='yes'){y-=um.e[17];}}else if(um.ie&&um.nc){y-=um.e[18];}}m.style.marginLeft=x+'px';m.style.marginTop=y+'px';if(!um.p||!s){m.style.left='auto';m.style.top='auto';if(um.s1||um.k){m.style.top=(p.th)+'px';}if(um.s3){m.style.top='auto';}}if(um.wie50){um.xn(m);um.xd(m);}};umNav.prototype.ru=function(m){var c=um.es(m.className);if(/nomove/.test(c)){return false;}var w=um.getWindowDimensions();var p={x:um.getRealPosition(m,'x'),y:um.getRealPosition(m,'y'),w:m.offsetWidth,h:m.offsetHeight,pw:m.parentNode.parentNode.offsetWidth,m:32,nx:-1,ny:-1,sc:um.getScrollAmount(),scx:um.getScrollAmount(1)};if(um.wie50&&um.rtl){p.x-=um.m.body.clientWidth;}if(typeof um.scr!=um.un){p.h=scr.gmh(m);}var s=(um.ne(m.parentNode));if(um.s&&!um.s3){p.x-=um.m.body.offsetLeft;p.y-=um.m.body.offsetTop;}else if(um.mie){var t=um.e[55]+um.e[51];p.x-=t;p.y-=t;}else{t=m;while(!um.ne(t.parentNode)){p.x+=um.e[51];p.y+=um.e[51];t=t.parentNode.parentNode;}}if(!um.ie&&um.e[3]=='fixed'&&s){p.x+=p.scx;p.y+=p.sc;}t=[(p.x+p.w),(w.x-p.m+p.scx)];if(t[0]>t[1]){if(s){p.nx=(((um.p)?p.x:0)-(t[0]-t[1]));}else{p.nx=(((um.p)?(0-p.w-p.pw+um.e[55]-um.e[49]):(0-p.w-um.e[55]-um.e[51]))-um.e[49]);}}if(p.x<0){if(!s){p.nx=(0-um.e[55]-um.e[51]+p.pw+um.e[49]);}}um.yd=(p.y+p.h)-(w.y-p.m+p.sc);if(um.f&&!s){um.yd+=p.sc;}if(um.yd>0){t=m.parentNode;um.y=um.getRealPosition(t,'y');while(!um.ne(t)){um.y+=um.e[51];t=t.parentNode.parentNode;}p.ny=(0-um.y-(p.m*2)+w.y+p.sc-p.h);if(um.f){p.ny-=p.sc;}}if(p.y<0){p.ny=(0-(0-p.y));}if(p.nx!=-1){if(um.p){m.style.left=p.nx+'px';}else{m.style.marginLeft=p.nx+'px';}um.ap('110',m);}if(p.ny!=-1){if(um.p&&um.ne(m.parentNode)){m.style.marginTop=(2000-um.yd)+'px';}else{m.style.marginTop=p.ny+'px';}um.ap('120',m);}t=m;var y=(um.wie50&&!um.p)?((um.pi(m.style.marginTop)+m.parentNode.offsetHeight+um.getRealPosition(m.parentNode,'y'))-p.sc):(um.getRealPosition(t,'y')-p.sc);while(!um.ne(t.parentNode)){y+=um.e[51];t=t.parentNode.parentNode;}if(um.f){y+=p.sc;}if(y<0){p.ny=um.pi(m.style.marginTop);if(isNaN(p.ny)){p.ny=0;}m.style.marginTop=(p.ny-y)+'px';}t=m;var x=um.getRealPosition(t,'x')-p.scx;while(!um.ne(t.parentNode)){x+=um.e[51];t=t.parentNode.parentNode;}if(x<0){m.style.marginLeft=(um.p&&um.ne(m.parentNode))?'2000px':(p.scx>0?0-x:0)+'px';m.style.left='0';}return true;};umNav.prototype.hl=function(m){var d={'class':'udmS'};um.sh=m.parentNode.appendChild(um.createElement('span',d));var c=um.es(m.className);if(c!=''){if(typeof um.v[c]!=um.un){if(um.sh.className.indexOf(c)==-1){um.sh.className+=' '+c;}}}um.sh.style.width=m.offsetWidth+'px';var h=m.offsetHeight;if(typeof um.scr!=um.un){h=scr.gmh(m);}um.sh.style.height=h+'px';var p={x:(m.offsetLeft),y:(m.offsetTop)};var s=um.ne(um.sh.parentNode);if(um.s&&!um.s1&&!s){p.x-=um.e[51];p.y-=um.e[51];}um.sh.style.left=p.x+'px';um.sh.style.top=p.y+'px';return um.sh;};umNav.prototype.il=function(m){var c=m.parentNode.appendChild(um.createElement('iframe',{'class':'udmC', 'src':'javascript:false;'}));c.tabIndex='-1';c.style.width=m.offsetWidth+'px';c.style.height=(typeof um.scr!=um.un?scr.gmh(m):m.offsetHeight)+'px';c.style.left=m.offsetLeft+'px';c.style.top=m.offsetTop+'px';return c;};umNav.prototype.dw=function(a){um.rw+=a.offsetWidth;if(um.nc){um.rw-=um.e[18];}else{um.rw+=um.e[17];}};umNav.prototype.aw=function(){if(um.o7||um.mie||um.q){um.rw+=(um.gp(um.gc(um.tr)).offsetLeft+um.getRealPosition(um.tr,'x'));}if(um.mie||um.og){um.rw*=1.05;}if(um.getWindowDimensions().x<um.rw){um.tr.style.width=um.rw+'px';}else{if(um.wie50){um.tr.style.setExpression('width','document.body.clientWidth');}else{um.tr.style.width='100%';}}if(um.mie){um.tr.style.height=um.gc(um.tr).offsetHeight+'px';}};umNav.prototype.ts=function(v){var s=um.m.getElementsByTagName('select');var n=s.length;if(n>0){var i=0;do{s[i++].style.visibility=v;}while(i<n);um.ap((v=='hidden')?'067':'077',s);}};umNav.prototype.ws=function(){clearInterval(um.vs);var h=um.gc(um.tr).offsetHeight;var w=um.getWindowDimensions();if((h!=um.lh&&um.reset[2]!='no')||((w.x!=um.lw.x||w.y!=um.lw.y)&&um.reset[1]!='no')){um.closeAllMenus();if(um.rg){um.rw=0;var n=um.tr.childNodes;var l=n.length;for(var i=0;i<l;i++){if(n[i].nodeName!='#text'){this.dw(n[i]);}}this.aw();}um.lw=w;um.lh=h;if(um.og&&um.hstrip[0]!='none'){um.tr.style.height=(um.hstrip[1]=='yes')?(um.lh+um.e[17])+'px':um.lh+'px';}}um.vs=setInterval('um.n.ws()',55);};um.qc=function(l){if(um.reset[3]=='yes'&&l!=''&&l!=um.jv){um.closeAllMenus();}};um.vn=function(n){return n.replace(/html[:]+/,'');};um.es=function(c){return c==null?'':c;};um.gt=function(r,t,a){if(!a){a=[];}for(var i=0;i<r.childNodes.length;i++){if(r.childNodes[i].nodeName.toUpperCase()==t.toUpperCase()||t=='*'){a[a.length]=r.childNodes[i];}a=um.gt(r.childNodes[i],t,a);}return a;};um.gc=function(r){return r.getElementsByTagName('a')[0];};um.gu=function(r){return r.getElementsByTagName('ul');};um.gm=function(r){var m=null;var c=r.childNodes;var l=c.length;for(var i=0;i<l;i++){var n=um.vn(c[i].nodeName).toLowerCase();if(n=='ul'){m=c[i];break;}}return m;};um.cm=function(e){if(!e){e=window.event;}if(!um.tr.contains(e.srcElement||e.target)||e.keyCode){um.closeAllMenus();}};um.refresh=function(g){if(typeof g==um.un){g=0;}delete um.ini;um.ready=0;if(umTree){var l=um.tr.getElementsByTagName('li');var n=l.length;for(i=0;i<n;i++){var a=um.n.ga(l[i]);if(a){a.parentNode.removeChild(a);}}}umIni(g);};um.closeAllMenus=function(){um.n.cd(um.tr);um.n.ck(um.tr);um.ha=0;};um.getWindowDimensions=function(){if(typeof window.innerWidth!=um.un){var w={x:window.innerWidth,y:window.innerHeight};}else if(um.q){w={x:um.m.body.clientWidth,y:um.m.body.clientHeight};}else{w={x:um.m.documentElement.offsetWidth,y:um.m.documentElement.offsetHeight};}return w;};um.getScrollAmount=function(d){return ((typeof d==um.un||!d)?(typeof window.pageYOffset!=um.un?window.pageYOffset:um.q?um.m.body.scrollTop:um.m.documentElement.scrollTop):(typeof window.pageXOffset!=um.un?window.pageXOffset:um.q?um.m.body.scrollLeft:um.m.documentElement.scrollLeft));};um.getRealPosition=function(r,d){um.ps=(d=='x')?r.offsetLeft:r.offsetTop;um.te=r.offsetParent;while(um.te){um.ps+=(d=='x')?um.te.offsetLeft:um.te.offsetTop;um.te=um.te.offsetParent;}return um.ps;};if(typeof um.trigger!=um.un&&um.trigger!=''&&!um.mie){um.drt=null;um.drw=function(){this.n=typeof this.n==um.un?0:this.n++;if(typeof um.m.getElementsByTagName!=um.un&&um.m.getElementsByTagName('body')[0]&&um.gd('udm')&&um.gd(um.trigger)){try{umIni();}catch(err){clearTimeout(um.drt);return;}}else if(this.n<60){um.drt=setTimeout('um.drw()',250);}};um.drw();}um.activateMenu=function(n,x,y){if(!um.pet()){return;}var umVN=um.gd(n);if(umVN&&!um.rtl){um.vm=um.gm(umVN);if(um.vm){if(um.n.cck()){um.n.cd(umVN);um.n.pr(um.vm,umVN,0);um.vm.style.left=x;um.vm.style.top=y;}}}};um.deactivateMenu=function(n){if(!um.pet()){return;}var umVN=um.gd(n);if(umVN&&!um.rtl){um.n.cp(um.gm(umVN),umVN);}};um.pet=function(){return !um.s||typeof event==um.un||(!(event.target==event.relatedTarget.parentNode||(event.eventPhase==3&&event.target.parentNode==event.relatedTarget)));};
/*--------------------------------------------------------------------------*/
///modletInclude/udm/skins/pnp/extensions/udm-x-youarehere.js
/*--------------------------------------------------------------------------*/
// UDMv4.5 // You Are Here extension v1.2 //
/***************************************************************\

  ULTIMATE DROP DOWN MENU Version 4.5 by Brothercake
  http://www.udm4.com/

\***************************************************************/

/***************************************************************\
 * Set you are here parameters
\***************************************************************/

var youAreHere=[
	"index.jsp",		// default page name [eg "index.php", "default.html" etc]
	"You are here: ",	// add text to here-page title ["text"|"none"]
	"You are here: ", // add text to here-branch title ["text"|"none"]
	"after",		// where to add title text ["before"|"after"]
	"no",			// open here-branch menus automatically ["yes"|"no"]
	];

/***************************************************************\
\***************************************************************/
var yah=new Object;yah.addToTitle=function(titleNode,titleText){yah.iText='';yah.nodes=titleNode.childNodes;yah.nodesLen=yah.nodes.length;for(i=0; i<yah.nodesLen; i++){if(yah.nodes[i].nodeType==3){yah.iText=yah.nodes[i].nodeValue;break;}}yah.title=(titleNode.title=='') ? yah.iText : titleNode.title;yah.title=(youAreHere[3]=='before') ? titleText + yah.title : yah.title + titleText;titleNode.title=yah.title;};function compareNumbers(a,b){return b[0]-a[0];};if(typeof window.onload=='function'){um.yon=onload;window.onload=function(){um.yon();prepFind();};}else{window.onload=prepFind;}function prepFind(){var n=0,t=setInterval(function(){if(typeof um.n!='undefined'&&um.ready){clearInterval(t);findHere();}else if(++n>=75){clearInterval(t);}},200);};function findHere(){var tree=document.getElementById('udm');if(!tree){return false;}yah.uri=top.document.location.href.replace('https://','http://');yah.uri=yah.uri.replace(youAreHere[0],'');yah.uri=yah.uri.replace(/,/g,'%2C');yah.matches=[];yah.links=tree.getElementsByTagName('a');yah.linksLen=yah.links.length;for(var i=0; i<yah.linksLen; i++){yah.href=yah.links[i].href.replace('https://','http://');if(yah.href&&yah.href!=um.jv&&!/[a-z]+\:\/\//.test(yah.href)){yah.matches=[];break;}yah.href=yah.href.replace(youAreHere[0],'');yah.href=yah.href.replace(/,/g,'%2C');if(yah.href!=''&&yah.href!=um.jv&&yah.uri.indexOf(yah.href)!=-1){yah.matches[yah.matches.length]=yah.links[i];}}yah.matchesLen=yah.matches.length;if(yah.matchesLen < 1) {return false;}yah.probs=[];for(i=0; i<yah.matchesLen; i++){yah.href=yah.matches[i].href.replace('https://','http://');yah.hrefLen=yah.href.length;yah.probs[i]=[0,yah.href];for(var j=0; j<yah.hrefLen; j++){if(yah.href.charAt(j)==yah.uri.charAt(j)){yah.probs[i][0]++;}}}yah.probs.sort(compareNumbers);yah.href=yah.probs[0][1];for(i=0; i<yah.linksLen; i++){yah.linkref=yah.links[i].href.replace('https://','http://');if(yah.linkref==yah.href){if(youAreHere[1]!='none'){yah.addToTitle(yah.links[i],youAreHere[1]);}applyHereClass(yah.links[i]);}}return true;};function applyHereClass(link){link.style.zIndex=um.e[6]+=2;yah.cname=um.es(link.className);(yah.cname=='')?link.className='udmY':link.className+=' udmY';if(youAreHere[2]!='none'){if(link.title.indexOf(youAreHere[1])==-1){yah.addToTitle(link,youAreHere[2]);}}yah.ppc=um.es(um.gp(link).parentNode.className);yah.isNav=yah.ppc=='udm';if(youAreHere[4]=='yes'&&!yah.isNav){yah.pm=um.gp(link).parentNode;yah.pm.style.height='auto';yah.pm.style.overflow='visible';yah.pm.style.left='auto';yah.pm.style.top='0';if(um.ep){yah.pm.style.position='static';}um.xd(yah.pm);if(!um.mie&&um.e[89]!='none'){um.kl=yah.pm.childNodes.length;i=0;do{um.tn=yah.pm.childNodes.item(i);um.nn=um.vn(um.tn.nodeName).toLowerCase();if(um.nn=='li'){um.ar=um.n.ga(um.gc(um.tn));if(um.ar!=null){um.n.wp(um.ar,um.tn,um.e[70],0,0);}}i++;}while(i<um.kl);}um.sh=null;if(!um.ns&&um.e[58]!='none'){um.n.hl(yah.pm);um.xd(um.sh);}if(um.wie55&&(um.e[13]=='default'||um.e[13]=='iframe')){um.n.il(yah.pm);}if(um.hz){um.n.ts('hidden');}um.xv(yah.pm);}yah.arrow=(!um.mie&&typeof um.n.ga=='function')?um.n.ga(link):null;if(yah.arrow!=null){if(um.s||um.k){yah.arrow=yah.arrow.firstChild;}if((yah.isNav&&um.ni)||(!yah.isNav&&um.mi)){yah.pic=um.es(um.gp(link).className);yah.arrow.src=um.baseSRC+((yah.isNav)?um.e[46]:(typeof um.w[yah.pic]!=um.un)?um.w[yah.pic][24]:um.e[90]);}}if(!yah.isNav){yah.link=um.gc(um.gp(link).parentNode.parentNode);applyHereClass(yah.link);}};