///////////////////////////////////
/* prototypes properties/methods */
//-------------------------------//
// OBJECT EXTENDING
//////////////////////////////////
//
	Object.extend = function(destination,source,override) {
		if(!destination) destination = {};
	  for (property in source) {
		if((override === false && destination[property] === undefined) || override !== false)
			destination[property] = source[property];
	  }
	  return destination;
	}
	
	Object.wipe = function(o,f){
		Object.each(o, function(oEl){ Try(f,oEl); delete oEl });
	}
	Object.each = function(o,f){
		if(o)
			for(var i in o)
				f(o[i],i);
	}

//--------------------------
// STRING EXTENDING
////////////////////////////
//	
	Object.extend(String,{
					// Separates charsets on understandable
					// names
					charSets: {
						// lowercase letters
							lL:"abcdefghijklmnopqrstuvwxyz",
						// uppercase letters
							uL:"ABCDEFGHIJKLMNOPQRSTUVWXYZ",
						// numbers
							N:"0123456789"					
					},
					//======================
					// String.random()
					//======================
					// @ int 	size :	size of the string to be returned
					// @ array	from :	the types of characters to be used (look above)
					//----------------------------------------------------------------//
					// Created a random key string from the selected charset, look above
					// for the charset. You can always add charset.
					// default charset is uL+lL+N (upper/lowerletter + numbers)
					// 
						random: function(size,from){
							if(!(from instanceof Array)) from = ["uL","lL","N"]; 
							else from = from.split(",");
							var s = "",str = "",a=0;
							for(var i=0;i<from.length;i++) s+= String.charSets[from[i]];
							while(str.length < size)
								str += s.charAt(Math.round(Math.random()*s.length-1));
							return str;
						}
				  });
	Object.extend(String.prototype,{
				  	//====================
					// String.validate()
					//====================
					// @ str	type 	: specifies the validation type
					//----------------------------------------------------------------//
					// Used to validate the string within a defined definition method.
					// Look below for the type listed on the SWITCH
					//
						validate: function (type){
							switch(type){
								// EMAIL
								case "mail":
									var s = this.split(",");
									for(var i=0;i<s.length;i++)
										if(!(/^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,6})$/i.test(s[i])))
											return false;
									break;
							}
							return true;
						},
					//========================
					// String.substringpop()
					//========================
					// @ int 	from 	: remove starting from 'from'
					// @ int 	to 		: remove until 'to', if not given, it will clip to the end, just like
					//						a .substring(0,from)
					//-----------------------------------------------------------------//
					// Takes away from the string the piece from 'from' to 'to'
					// and then returns the string without that string.
					//
						substringpop: function(from,to){
							return this.substring(0,from)+(to>0?this.substring(to,this.length):"");
						},
						
					//============================
					// String.substringreplace()
					//============================
					// @ str	replacement : string to be added
					// @ int	from		: remove starting from 'from'
					// @ int	to			: remove until 'to', if not given, it will remove
					//						  	from+replacement.length
					//-------------------------------------------//
					// Replaces the string from 'from' to 'to' for the 'replacement'
					//
						substringreplace: function(replacement,from,to){
							// In the case of 'from' not existing, it's 0 default
								if(!from) from = 0
							// if 'to' is not set, it'll be 
							if(!(to>0)) to = from + String(replacement).length;
							return this.substring(0,from)+replacement+this.substring(to,this.length);
						},
					//===========================
					// String.addslashes()
					//===========================
					// Replaces any of the following \, ', "
					// for "\" + the matching entry 
					//
						addslashes: function () {
							return this.replace(/('|\\|")/g,"\\$1");
						},
					//===========================
					// String.stripslashes()
					//===========================
					// Replaces any of the following \\, \', \"
					// for the matching entry withou the slash
					// in front of it 
					//
						stripslashes: function() {
							return this.replace(/\\('|\\|")/g,"$1");
						}
				  });
//-----------------------
// ARRAY EXTENDING
/////////////////////////
//
	Object.extend(Array.prototype, {
		sum: function(){
			var s = 0;
			for(var i=0;i<this.length;i++)
				if(!isNaN(Number(this[i])))
					s+=Number(this[i]);
			return s;
		},
		merge: function(){ var target,a=0;
				if(this.length) target = this; else { target = arguments[0]; a=1; }
					for(a;a<arguments.length;a++)
						if(arguments[a].length == undefined)
							for( var i in arguments[a] ) target.push(arguments[a][i]);
						else
							for( var i=0;i<arguments[a].length;i++)  target.push(arguments[a][i]);
				return target;
		},
		
		find: function(w,e){ var A = this;
			try{
			if(e==="i")w=String(w).toUpperCase(); 
			for(var i=0;i<A.length;i++)
				 if((e===true&&A[i]===w) ||
						(e!==true&&(((e==="i"?String(A[i]).toUpperCase():A[i])==w ) ||
								   (w instanceof RegExp && A[i].match(w)))))
					return i; 
			} catch(e){}
			return false; 
		}
		});
//
//----------------------
// NUMBER EXTENDING
////////////////////////
//
	Number.hexString="0123456789ABCDEF";
	Object.extend(Number.prototype, {
			toHex: function (){ 
						var d=this, h = Number.hexString.substr(d&15,1);
						while(d>15) {d>>=4;h=Number.hexString.substr(d&15,1)+h;}
						return h;
					}
			});
	
	Object.extend(String.prototype, {
			replaceall: function(w,r){
				var c = this;
				while( c != (c=c.replace(w,r))) {}
				return c;
			},
			// n stands for not_all_matches
			regexpEscape: function(){
				return this.replaceall(/(^|[^\\])(\^|\.|\-|\*|\+|\?|\$|\[|\]|\{|\}|\(|\))/g,"$1\\$2")
			}
		  });

// Converts to array if the target
// is NOT an array
function array(o){
	return (!(o instanceof Array)) ? ( o ? [o] : []) : o;
}

///----------------------
// Easy-Access Functions
///----------------------
function $t(name,o){ return (o||document).getElementsByTagName(name) }
function Try(w){ 
					try{ if(typeof w=='string') 
							eval(w); 
					  else{
						var args=[]
						for(var i=1;i<arguments.length;i++)
							args.push(arguments[i]);
						  w.apply(this,args);
					  }
					}catch(e){return e;} return true;}
function Int(n){	
	return isNaN((n=parseInt(n))) ? 0 : n;
}
//--------------------------
// loadingDisplay handling
//--------------------------
// is the page loading ?
//
	var __loadingCount = 0,__loadingDisplay;
	function loadingDisplayHandler(l){ 
			// no loading display div was found
			if(__loadingDisplay === null) return;
			if(__loadingDisplay === undefined){
				__loadingDisplay = h("#loadingDisplay");
				if((__loadingDisplay.o.hi.isAbsolute = (__loadingDisplay.getStyle("position")!='fixed'))){
					__loadingDisplay.o.hi.rTop = function(){ __loadingDisplay.o.style.top = document.body.scrollTop; }
					__loadingDisplay.o.hi.onresize = new Event(window,"onresize",__loadingDisplay.o.hi.rTop);
					__loadingDisplay.o.hi.onscroll = new Event(window,"onscroll",__loadingDisplay.o.hi.rTop);				
				}
			}
			if(l===true) __loadingCount++; else __loadingCount = __loadingCount > 0 ? __loadingCount-1 : 0;
			if(__loadingCount > 0){ 
				if(__loadingDisplay.o.hi.isAbsolute){
					__loadingDisplay.o.hi.rTop();
					__loadingDisplay.o.hi.onresize.disabled = __loadingDisplay.o.hi.onscroll.disabled = false;
				}
				__loadingDisplay.show();
			}
				else{
					if(__loadingDisplay.o.hi.isAbsolute)
						__loadingDisplay.o.hi.onresize.disabled = __loadingDisplay.o.hi.onscroll.disabled = true;
					__loadingDisplay.hide();				
				}
	}

// Object extra
// ----------------------------------
// htmlObject
/* handles htmlobjects with some utilities */

var h = function(obj,p){
	// if its already a 'h' class object,
	// nothing to do but return it
	if(obj instanceof h) return obj;
	// we can't make an obj class out of nothing
	if(obj === undefined) return false;
	// makes sure it's an object, not a simple
	// called function
	if(window === this) return new h(obj,p);

	this.o = this.parseObject(obj,p);

	// collection holding h's info
	// on that object 
	if(!this.o.hi)
		this.o.hi = {
				anims: {},
				events: {}
			};
}	


// Defines main config element, used within all the 
// script
	// defines which browser is being used //
	// ----------------------------------- //
		var b = navigator.userAgent.toLowerCase();
		h.browser = {
			safari: /webkit/.test(b),
			opera: /opera/.test(b),
			msie: /msie/.test(b) && !/opera/.test(b),
			mozilla: /mozilla/.test(b) && !/(compatible|webkit)/.test(b)
		};

	// defines extra info //
	// ---------------------
	var brdThick = h.browser.mozilla ? 6 : 5;
	h.ex = {
			// retrieves javascript-level link to the host 1 , 3 , 5
			hostLink: "http://localhost/sites/new_sites/fonts/http/",
			brdSizeByName: {medium: brdThick-2  ,thin:brdThick-4,thick:brdThick}
	};
	// stores collections //
	// ---------------------
	
	// object which holds all the floatables created
	// withing the h element
	// ---------------------------
		h.floatables = [];

// extends h for some objectless methods
Object.extend(h , {
	//========================
	// h.closeAllFloatables()
	//========================
	// @ string		class	:	floatable's class to be closed
	// @ object		cfg		:	shared configuration of h.closeFloating
	//				'CFG' EXTRA PROPERTIE(S)
	//			 -------------------------------
	//			  @ object	condition	:	condition object that must be true when
	//										tested against h.condition()
	// ------------------------------------------------------------------------------
	// Closes all floatables of the selected class, if no class is given, ALL THE
	// FLOATABLES are closed.
	//
		closeAllFloatables: function(Class,cfg){
			if(!cfg) cfg = {};
			var floatable;
			for(var i=0;i<h.floatables.length;i++){
				floatable = h(h.floatables[i]);
				if(
					   (!Class || floatable.o.hi.floatclass == Class) && 
					   floatable.condition(cfg.condition)
				   )
					floatable.closeFloatable(cfg);
			}
		},
		getFloatable: function(id,Class){
			for(var i=0;i<h.floatables.length;i++)
					if( h.floatables &&
						h.floatables[i].hi.floatclass == Class &&
					 	h.floatables[i].hi.floatid == id ){
						// if there's no control option, it'll return
						return h.floatables[i];
			}
			return null;
		}
	});
h.prototype = {
	/////////////
	/* PARSING */
	///////////////////////
	// parses objects
	// to see it requires:
	// - create (tagName){string}
	// - getbyid (#id){string}
		parseObject: function(obj){ var tobj;
			if(typeof obj == 'string'){
			if(tobj = obj.match(/^#(.+)$/))
				obj = document.getElementById(tobj[1]);
			else
				obj = this.create(obj,arguments[1]);
			}
			return obj;
		},
		
	//==================
	// this.condition()
	//==================
	// @ object		c	:	collection of conditions to be evaluated
	//						example: {tagName:"DIV",id:/^mYiD/,parentNode: [object]}
	//
	// # return BOOLEAN	:	TRUE if evaluated collection is true (...)
	// ------------------------------------------------------------------------------
	// Evaluates the provided collection 'c' to match conditions.
	//
		condition: function(c){
			//try{ 
				// if there's no condition, it IS true..
				if(!c) return true;
				if(c){
					var prop;
					for(var i in c){
						// splits the properties
						prop = this.getProp(i);	
						if(c[i] instanceof RegExp && !String(prop).match(c[i])) return false;
						else if(typeof c[i] == "string" && prop != c[i]) return false;
						else if(c[i] instanceof Array)
							switch(c[i][0]){
								case "inarray":
										prop = array(prop);
										if(prop.length)
										for(var i=0;i<array(c[i][1]).length;i++)
											if(prop.find(c[i][1][i]) === false) return false;
										break;
								case "exists":
										if(prop === undefined || prop === null) return false;
										break;
								// otherwise it would be mistaken with options array
								case "array":
										if(prop != c[i][1]) return false;
										break;
								case "!":
									var t = {}; t[i] = c[i][1];							
									if(this.condition(t)) return false;
										break;
							}
						else if(prop != c[i]) return false;
					}
				}	
			// if anything went wrong it may be false
		//} catch(e){ return false; }
			return true;
		},
	
	//////////////
	/* DYNAMIC  */
	///////////////////////
	// creates relative Div + absolute Div to make obj
	// 'float'
	// FLOATING
	///////////////
	//
	
	//=======================
	// this.float()
	//=======================
	// @ object		who	: object to float
	// @ object		cfg	: main element configuration
	//	-------------- 'cfg' ELEMENTS ------------
	//  /////////////////////////////////////////////////////////////////////////////////////////////
	//		@ int		left		: represents starting left disregarding the floating
	//									pos to be used
	//		@ int 		top			: represents starting top disregarding the floating
	//									pos to be used
	//		@ object	relativeObj	: 
	//		@ object	showcfg		: the configuration to be used on every show
	//		@ object	closecfg	: the configuration to be used on every close
	//		@ bool		show		: if no showcfg is given and this is false, the object will
	//									not be shown automatically
	//		@ bool		type	: specifies whether it's absolute(A) , relative+absolute(R) , or static(S)
	//		@ string	Class	: floatable class to specify massive targeting actions
	//		@ string	id		: floatable id to differ them to others belonging to the same class
	//									ieg.: you try to open a second instance of "MyId" floatable,
	//										  if it already exists, a second instance
	//										  won't be opened, but the old one will if not shown
	//		@ string	control		: options regarding how to react when the floatable already
	//								  exists. Example: toggle-...-opt3-opt4-...-optN
	//							'control' OPTIONS
	//						-------------------------------------------------------
	//						 toggle 	: if it's show, it'll then hide, if it's 
	//								  		hidden, it'll show
	//		@ object	eventSrc	: object (pseudo)responsible for the floatable
	//		@ function	onhide		: function to be called everytime the object finished hiding
	//		@ function	onshow		: function to be called everytime the object finished showing
	//		@ function	onremove	: function to be called once the object is REMOVED
	//		@ function	onstarthide	: function to be called when the object starts hiding
	//		@ function	onstartshow : (...)
	//									OBS.: if there's no showcfg animation, onhide/show and 
	//										  onstarthide/show will be caled at the same time
	//		@ bool		unique		: if true, all the others floatables sharings its class
	//								  will be closed
	//		@ bool		zIndex		: persistent permanent zIndex
	//		@ object	floatable	: object to be used instead of creating a new one
	// ----------------------------------------------------------------------------------------------
	// Floats the object 'who' with relative+absolute DIVs
	//		
		float: function(cfg){ 
			if(!cfg) return;
			
			// all the class floatables will get closed if its unique
			// but the floatable being opened
			if(cfg.unique && cfg.Class)
				h.closeAllFloatables(cfg.Class,{condition:{"hi.floatid":["!",cfg.id]}});
				
			// checks if the object already exists or not
			// if it does, it not recreated, and the control
			// config is taken to call some methods
			var cOpt = cfg.control ? cfg.control.split("-") : null;
			
			// if the floating object has already been created, we'll
			// retreive it back
			if(cfg.id){ 
				var floatable = h.getFloatable(cfg.id,cfg.Class);
				if(floatable){
							if(cfg.control){								
								// true -> it is shown; false -> it is hidden
								var tempDA = h(floatable.childNodes[0]);
									showStatus = !(floatable.childNodes[0].hi.showstatus != "show");
								// toggling display
								if(cOpt.find("toggle")!==false){
									if(showStatus)
										tempDA.closeFloatable();
									else
										tempDA.show(cfg.showcfg);
								}
							}
						return true;
					}
			}
		
			var relativeObj = h((cfg.relativeObj || document.body)),
				dA,dR,dS,div,evDiv;
			if(!cfg.type) cfg.type = 'R';			
						
			if(cfg.type=='R' || cfg.type=='A'){			
				dA = h("DIV");
				dA.o.style.position = 'absolute';
				dA.append(this.o);			
				if(cfg.type=='R'){	
				// creates the divRelative which holds the
				// absolute floatable	
					dR = h("DIV");				
					dR.o.style.position = 'relative';	
					dR.append(dA.o);
				}
			}
			else
				dS = h("DIV").append(this.o);
				
			div = dR||dA||dS;
			evDiv = dA||dS;
			// ... > appending the floatable relative to the 
			// 		 relative object
			(cfg.appendTo||relativeObj.o).appendChild(div.o);
			// ------------------
			// DEFINES THE EVENTS
			// ------------------
				// function called once it's closed/hidden
					evDiv.o.hi.onhide = cfg.onhide;
				// function called once it's shown
					evDiv.o.hi.onshow = cfg.onshow;									 
				// function to be called everytime it starts hiding
					evDiv.o.hi.onstarthide = function(){
												 // it should go right to the end
												 // of z stacking
													 div.o.style.zIndex = cfg.zIndex || 0;
													 Try(cfg.onstarthide);
												 };
				// function to be called everytime it starts showing
					evDiv.o.hi.onstartshow = function(){ 
												 // it should go to the front
													 div.o.style.zIndex = cfg.zIndex || 1;
													 Try(cfg.onstartshow) 
												};
			
				// standard close configuration
				// to be used everytime the floatable
				// is closed with closeFloating
					div.o.hi.closecfg = cfg.closecfg;
					
			// ----------------------------------------------
			// positions the absolute to the target relative
			// object
				if(dA)
					dA.setPosition(cfg.left,cfg.top,relativeObj,cfg.pos,cfg.event);
			
			// sets identification
				div.o.hi.floatclass = cfg.Class;
				div.o.hi.floatid = cfg.id;
			// defines whether it is or not a floatable
			// object
				div.o.hi.isFloatable = true;
			// stores the float parent pointer
				this.o.hi.floatParent = div;
			
			// appends the object to the floatables array 
			// stored on 'h' (h.floatables)
				if(h.floatables.find(div.o)===false)
					h.floatables.push(div.o);

			// it must be contracted as its
			// the firts time its popping
			// to minimum size
				div.o.style.zIndex = cfg.zIndex
				if(cfg.showcfg || cfg.show){
					if(cfg.showcfg)
						cfg.showcfg.contractSize = true;
					evDiv.display(false).show(cfg.showcfg);
				}
			return div;
		},
		
		setPosition: function(offsetLeft,offsetTop,relativeObj,pos,evt){
			var top = left = setW = setH = 0,
				oH = this.o.offsetHeight,
				oW = this.o.offsetWidth,
				onBody = (this.o.parentNode||this.o.parentElement) == document.body;
			if(pos){
				relativeObj = h(relativeObj);
				if(typeof pos == 'string') pos = pos.split("-");
				switch(pos[0]){ 
					case "top": top =  - oH
										+ ( onBody ? relativeObj.getTotalOffsetTop()   : 
													- relativeObj.o.offsetHeight 
													+ Int(relativeObj.getStyle("borderTopWidth"))
													+ Int(relativeObj.getStyle("paddingTop"))
										);
										break;
					case "bottom": top = ( onBody ? relativeObj.getTotalOffsetTop() +
													relativeObj.o.offsetHeight: 0 ); break
					case "mouse": top += evt.clientY 
										+ document.body.scrollTop;
								  left += evt.clientX 
										+ document.body.scrollLeft;
								if(relativeObj.o !== document.body)
								  switch(pos[1]){
									case "top"	: top -=  relativeObj.o.offsetHeight + oH;
									case "bottom": top += relativeObj.o.offsetHeight - (evt.clientY + document.body.scrollTop - relativeObj.getTotalOffsetTop()); break;									
								  }
								 
				}
				// adjusts additional positioning
				//
					if(pos[0]=='bottom'||pos[0]=='top'){
						switch(pos[1]){
							case "left":
									left += onBody ? relativeObj.getTotalOffsetLeft():
									- Int(relativeObj.getStyle("borderLeftWidth"))
									- Int(relativeObj.getStyle("paddingLeft"))
									break;
							case "center":
									left += (onBody ? relativeObj.getTotalOffsetLeft() : 0) - (oW-relativeObj.o.offsetWidth)/2;
						}
						// not implemented yet
						//else if (pos[1]=='right')
					}
					
					// size related to the relativeObj
					if(pos[2]){
						if(typeof pos[2] == 'string') pos[2] = pos[2].split(",");
						switch(pos[2][0]){
							case "full": setW = relativeObj.o.offsetWidth; break;
							default: if(Int(pos[2][0])) setW = pos[2][0];
									 if(Int(pos[2][1])) setH = pos[2][1];
						}
					}
				
					
			}
			// avoid clipping
			var setLeft = (offsetLeft||0) + left,
				setTop = (offsetTop||0) + top;
				
				this.o.style.width = setW||"auto";
				this.o.style.height = setH||"auto";
			// sets the floatable position
				this.o.style.top = setTop;
				this.o.style.left = setLeft;
			
				// recall the function if the obj size has changed
				if((!setH && this.o.offsetHeight!=oH) || (!setW && this.o.offsetWidth!=oW)){
					return this.setPosition(offsetLeft,offsetTop,relativeObj,pos,evt);
				}
			return this;
		},
		
	//===================
	// h.closeFloatable()
	//===================
	// @ object		cfg		:	configuration to be called on hide
	// ------------------------------------------------------------
	// Closes the floatable to which 'this.o' object belongs to.
	//
		closeFloatable: function(cfg){
			
			var p = this.getParentFloatable();
			if(!p) return;
			
			try{
				// The floating is starting to get closed
				// the first ChildNode would be the absolute floatable div
				h(p.o.childNodes[0])
				// ...
				.hide(Object
						  .extend(cfg,p.o.hi.closecfg),
							  function(){
									// okay, callback to when animation is finished and
									// floatable is totally closed
									if(cfg.remove===true)
										p.remove();
									} 
							  );
			return true;
			} catch(e){ return false; }
		},
		
		showFloatable: function(cfg){
			var p = this.getParentFloatable();
			if(!p) return;
			h(p.o.childNodes[0]).show(cfg ? cfg.showcfg : null);
		},
	//=========================
	// h.getParentFloatable()	
	//=========================
	// <- bool/object	parentObj
	// -------------------------------------
	// Returns the parent floatable
	// after a loop looking for one
	// if there's none, 'false' is returned
	//
		getParentFloatable: function(){
			var p = this;
			// if it finds a stored floatParent on the element's 
			// properties, it will be returned
				if(this.o.hi.floatParent) return this.o.hi.floatParent;
			
			if(!p.o.hi.isFloatable)
					p=this.parent({"hi.isFloatable":true});	
					
			// sets the stored floatParent to be recalled and returns it
			if(p.o.hi.isFloatable){ 
				this.o.hi.floatParent = p;
				return p;			
			}
			return false;
		},
		
	//===============
	// h.tip()
	//===============
	// @ string		text		: tip's innerHTML context
	// @ object		evt			: event object
	// @ bool		followMouse : should it follow mouse or stand still ?
	// @ string		pos			: position to be used
	// // @ string		id			: id to make the tip unique and don't keep on
	//								creating multiple tips of the same stuff
	//	@ bool		showOverTip	: if !== false it will not hide the tip when the mouse
	//								goes off the object and over the tip
	// ------------------------------------------------
	// displays a tip div
	// note that the tip is unique as 'h.tippingDiv'
	// 
		tip: function(text,evt,followMouse,pos,showOverTip){
			evt = window.event || evt;
			// fixes some issues
			if(evt.type == 'mouseover' && !this.mouseIsOver(evt)) return;
			// retrieves tip div if it already exists
				var tip = h.tipDiv,
					hasTip = !!(tip); //boolean
				
			// it wont follow only if followMouse === false
				followMouse = !(followMouse === false);
				
			// if there's no tip we are creating one
			if(!hasTip){
				tip = h("DIV");
				tip.o.hi.tipParent = this.o;
				h.tipDiv = tip;
				
				// defines the element calling the tip
				tip.o.hi.tipParent = this;
				tip.o.className = "tip";
				// initializes the following responsible event
					tip.o.hi.followMouseEv = new Event(document,"onmousemove",
								function(e){
										tip.getParentFloatable().setPosition(0,0,tip.o.hi.tipParent.o,tip.o.hi.defaultPos,e);
									});
				// it should resize when the window resizes.
					tip.o.hi.followResizeEv = new Event(window,"onresize",
								function(e){
										tip.getParentFloatable().setPosition(0,0,tip.o.hi.tipParent.o,tip.o.hi.defaultPos,e);
									});
			}
			if(tip.o.hi.tipParent.o!=this.o)
				tip.o.hi.tipParent = this;
			
			// default positioning
				tip.o.hi.defaultPos =  pos || tip.o.hi.defaultPos || "mouse-bottom";
				tip.o.hi.showOverTip = showOverTip;
			// enables the event			
			tip.o.hi.followMouseEv.disabled = !followMouse;
			if(tip.o.innerHTML != text)
				tip.o.innerHTML = text;			

			// if the tip has just been created, we'll initialize it,
			// meaning its events & properties
			if(!hasTip){
				// creates the floatable
					tip.float({ 
							  relativeObj: this.o,
							  appendTo: document.body,
							  type: "A",
							  zIndex:100,
							  pos:tip.o.hi.defaultPos,
							  event: evt
							 });
				
			}
			// retrieves the parentFloatable
			var pF = tip.getParentFloatable();
			
			if(!hasTip){
				// defines the custom closeTip function
				// to be called everytime we have to close it
					var closeTip = function(e){					
												pF.o.hi.tipMouseMove.disabled = true;	
												tip.o.hi.followMouseEv.disabled = true;
												tip.closeFloatable(); 
											}
				// initializes floatable parent on mouse out event, so we 
				// can handle it as a part of the tip parent and dont
				// close it when the mouse goes out parent but goes over it
				pF.o.hi.tipMouseMove = new Event(document,'onmousemove',function(e){
														  	if((tip.o.hi.showOverTip===false || !pF.mouseIsOver(e)) && !tip.o.hi.tipParent.mouseIsOver(e))
																closeTip();
														  });
			}
			else{	
				tip.showFloatable();				
				pF.setPosition(0,0,tip.o.hi.tipParent.o,tip.o.hi.defaultPos,evt);
				pF.o.hi.tipMouseMove.disabled = false;
			}
			
		},
		closeTip: function(){
			if(h.tipDiv && this.o == h.tipDiv.o.hi.tipParent.o){
				h.tipDiv.getParentFloatable().o.hi.tipMouseMove.disabled = true;	
				h.tipDiv.o.hi.followMouseEv.disabled = true;
				h.tipDiv.closeFloatable(); 
			}
			return this;
		},
		// 
		// HIDE/SHOW FUNCTION
		////////////////////////
		//
		//
			show: function(cfg,callback,args){
				return this.hideshowFunction("show",cfg,callback,args);
			},
			hide: function(cfg,callback,args){
				return this.hideshowFunction("hide",cfg,callback,args);
			},
			hideshowFunction: function(w,cfg,callback,args){
				if(w!='show')w='hide';
				var wbool = w=='show'?true:false;
				
				// returns if its already hidden
				if(this.o.hi.showstatus==w) return this;	
				
				// this function must be unique
				// within the animations
					this.clearAnim(true);
				this.o.hi.showstatus = w;
				
				Try(this.o.hi["onstart"+w]);
				
				if(cfg && cfg.type){
					cfg.action = w;
					var t = this;
					var c = function(){ t.display(wbool); Try(t.o.hi["on"+w]); Try(callback); };
					this.anim(cfg,c,array(args));
				}
				else{
					Try(this.o.hi["on"+w]);
					Try(callback);
					this.display(wbool);
				}
				return this;
			},
		
	//
	// ANIMATION
	////////////////
	// cfg config:
	// - speed ; of interval
	// - type ; of animation
	// - uspeed ; unit speed (pixel)
	// 
	//intervalSpeed
		iSpeed: {uslow:220,xslow:190,slow:150,medium:100,fast:50,xfast:30,ufast:20,uufast:5},
	// pixelSizeDec ( for animations changing width/height )
		pSizeDec: {fast:11,uslow:1,vslow:3,slow:5,medium:8,xfast:14,vfast:17,ufast:20},
	//============================
		//
		// animates objects 
		// 
		anim: function(config,callback,args){	
			// new object must be created
			// values overriding
			var cfg = Object.extend({},config);
			this.animate(cfg,callback,args);
		},
		
		animate: function(cfg,callback,args){
				// sets the default config
					cfg.speed = this.iSpeed[cfg.speed] || this.iSpeed.ufast;
					cfg.uspeed = this.pSizeDec[cfg.uspeed] || this.pSizeDec.medium;
					
				if(!cfg.type) return false;
				cfg.loops = 0;
				// t: this object, f: function to call on anim
				var t = this,f,type = cfg.type.split("-");
				switch(type[0]){
					
					//
					// slide-(down|up|...) variables
					// 
					///////////////////////////////////
					case "slide":
						// oOv: old overflow to be restored, oSz: old size
						//var oOv = this.style("overflow");
						//var oSz = this.getExpandedSize((cfg.expandWidth!==false),(cfg.expandWidth!==false));
						this.o.style.overflow = "hidden"
						// ...
						// tI : topIncrement , -1 going top | 1 going bottom;
						// sI : sizeIncrement , -1 dec hei | 1 inc hei;
						// n: [tI,sI]
						var n;
						if(type[1] == 'up' )
							if(cfg.fixedAt == 'bottom' || cfg.action == 'show')	n = [-1,1]; else n = [0,-1];
						if(type[1] == 'down')
							if(cfg.fixedAt == 'bottom' || cfg.action == 'hide') n = [1,-1]; else n = [0,1];
						
						var mS = [1,1];
						switch(cfg.action){
							case "show":mS = this.getExpandedSize(); 
										mS = (cfg.height || cfg.width) ? [(cfg.width || mS[0] ),(cfg.height || mS[1])]  : mS;
										if(cfg.contractSize)
											this.contractSize(false,true,false,(n[0]!==0)); break;
						}
						
						this.display(true); 
						// defines which function will be used by 
						// the given type sharing its variables with
						// others
						switch(type[1]){
							case "up":
							case "down":
								f = function(){	
											var sz = t.o.offsetHeight, us = cfg.uspeed;
											// avoid over/undersizing
											if((mS[1] - (sz + n[1]*us))*n[1] < 0)
												us = Math.abs(mS[1]-sz);
											if(sz != mS[1] && mS[1] != 0){ 		
												if(n[0]!==0)
													t.o.style.top = t.o.offsetTop+n[0]*us;
												t.o.style.height = sz+n[1]*us;
												return false;
											}
											return true;
										} 
								break;						
						}
						break;
						
					default: 
				}
				//
				// starts the animation proccess
				//
				var loop = new loopTimeout(cfg.speed,function(){
									if(!f || (f && f() === true)){
										if(callback)
											callback.apply(this,args);
										t.clearAnim(this.id)
										return false;
									}
									return true;
								});
				this.o.hi.anims[loop.id] = loop
				loop.start();
				return this;
			},		
		
	clearAnim: function(id){
		// which collection should i use?
		loopTimeout.erase(id,this.o.hi.anims);
		return this;
	},
	
	// sets its height / width to offsetHeight / offsetWidth or to w / h
	expandSize: function(w,h,tw,th){
		var pos = this.getStyle("position");
		var isFloatable = (pos == "absolute" || pos == "relative");
		this.display(true);
		if(w!==false)		
			this.o.style.width = w || this.o.offsetWidth;
			
		if(h!==false){
			h = !isNaN(parseFloat(h)) ? h : this.o.offsetHeight;
			if(isFloatable && th !== false)
				this.o.style.top = this.o.offsetTop + this.o.offsetHeight - h;
				
			this.o.style.height = h;
		}
		return this
	},
	contractSize: function(w,h,tw,th){
		return this.expandSize( w !== false ? 1 : w , h !== false ? 1 : h,tw,th);
	},	
	// (...)
	setOpacity: function(v){
		if(h.browser.mozilla) this.o.style.MozOpacity = v/100;
		else if (h.browser.msie) this.o.style.filter= "alpha(opacity=" + v + ");";
		else	this.o.style.opacity = v/100;
		
	},

	//
	////////////////
	// RETRIEVING //
	//////////////////////////
	// 
	// DOES NOT CONVERT UNITS <---
	//
	//
		//================
		// this.getStyle()
		//================
		// @ str	styleEl	:	specifies the style element being requested
		// ------------------------------------------------------------------
		// Retrieves the style being used by the element, even if it's not
		// an inline value.
		//
			getStyle: function(styleEl){
				var value;
				if(window.getComputedStyle) value = window.getComputedStyle(this.o,styleEl)[styleEl];
				else if(this.o.currentStyle) value = this.o.currentStyle[styleEl];
				else value = this.o.style[styleEl];
				if(/border((Width)|(Top)|(Left)|(Bottom))Width/.test(styleEl) && h.ex.brdSizeByName[value]) value = h.ex.brdSizeByName[value];
				return value;
			},
			
		//================
		// this.getProp()
		//================
		// @str		propEl	:	specifies the property element to be retrieved
		//						example: prop1.prop2.prop3\\.stillprop3.prop4
		//
		// <- mixed		propertyValue
		// -------------------------------------------------------------------
		// Retrieves the nested/or not property
		//
			getProp: function(propEl){
				var props = propEl.match(/((\\\.)|[^\.])+/g),temp_obj = this.o;
				for(var x=0;x<props.length;x++){
					if(temp_obj[props[x]] !== undefined)
						temp_obj = temp_obj[props[x]];
					else try{ temp_obj = temp_obj.getAttribute(props[x]) }
						 catch(e){}
					if(temp_obj === undefined) return temp_obj;
				}	
				return temp_obj;
			},
			
		 //==========================
		 // this.getTotalOffsetLeft()
		 //==========================
		 // <- int	totaloffsetLeft
		 //-------------------------------------
		 // Returns the total summed offset to the left
		 // in the whole document
		 //
		 	getTotalOffsetLeft: function(){
				var p = this.o,s=0;
				while(p){
					if(p!=this.o && h(p).getStyle("width")=="auto")
						p.style.width = p.offsetWidth;
					s += p.offsetLeft + (this.o!=p&&p.tagName=='TD'?p.clientLeft||0:0);
					p = p.offsetParent;
				}
				return s;
			},
		 //===========================
		 // this.getTotalOffsetTop()
		 //===========================
		 // <- int	totaloffsetTop
		 //-------------------------------------
		 // Returns the total summed offset to the top
		 // in the whole document
		 //		 	
		 	getTotalOffsetTop: function(){
				var p = this.o,s=0;
				while(p){
					if(p!=this.o && h(p).getStyle("height")=="auto")
						p.style.height = p.offsetHeight;
					s += p.offsetTop + (this.o!=p&&p.tagName=='TD'?p.clientTop||0:0);
					p = p.offsetParent;
				}
				return s;
			},
	
			mouseIsOver: function(e){
				var oTop = this.getTotalOffsetTop(),
					oLeft = this.getTotalOffsetLeft(),
					bTop = e.clientY + document.body.scrollTop,
					bLeft = e.clientX + document.body.scrollLeft;
				// capturing it's height/width
				//this.display(true);
				var	height = this.o.offsetHeight,
					width = this.o.offsetWidth;
				if(bLeft >= oLeft && bLeft <= oLeft+width+1
				   && bTop >= oTop && bTop <= oTop+height+1)
					return true;
				return false;
			},
		
		// w | h (false) not with visible overflow
		getExpandedSize: function(w,h){
			// sets the display to true so we can
			// retrieve real sizes and stores its
			// old overflow on 'o'
			var o = this
						.display(true)
						.getStyle("overflow");
			// 
			var bw = this.o.offsetWidth,
				bh = this.o.offsetHeight,
				oh = this.getStyle("height");
				
			this.o.style.overflow = "visible";
			this.o.style.height = "auto";

			if(w!==false) bw = this.o.offsetWidth;
			if(h!==false) bh = this.o.offsetHeight;

			var r = [bw,bh];
			this.o.style.overflow = o;
			this.o.style.height = oh;
			this.display(false);
			return r;
		},	
	//
	////////////////
	// CLASSWORK  //
	///////////////////////////////////////
	// manages/sets classes
	// 'class' seems to be RESERVED, using
	// 'Class' instead
	//
		Class: function(){
			return this.o.className.match(/([^\s]+)/g) || [];
		},
		removeClass: function(c){
			if(c===true){
				this.o.className = ""
				return this;	
			}
			c = array(c); var cs = this.Class();
			for(var i=0;i<cs.length;i++){
				if(c.find(cs[i])!==false) delete cs[i];
			}
			this.o.className = cs.join(" ");
			return this;
		},
		addClass: function(c){
			// checks wether it has or not class (c)
			if(!this.Class().find(c))
				this.o.className = this.o.className+" "+c;
			return this;
		},
	//
	////////////////////////
	//
	
	////////////////
	/* RECALLABLE */
	/////////////////////////
	// -------------
	// ' return this; '
	//
		// adds an event to the root object
		// and to the hi.events collection
		addEvent: function(t,f,args,front){
			var e = new Event(this.o,t,f,args,front);
			return e;
		},
		// basicEvents
		// sets up basic events such as mouseover/out, clicked, clicking..
		// and changes the elements javascript accordingly
		// Arguments:
		//		f : bool ) false - disables basicEvents chains
		//				   true  - creates/enables basicEvents
		bEv: function(f){
			if(f!==undefined) this.removeClass(["over","clicking"]);
			if(f===false)
				return 	this.o.hi.bEv = false;
	
			if(this.o.hi.bEv!==undefined){ 
				this.o.hi.bEv = true;
				return this;
			}
			var t = this;
			this.o.hi.bEv = true;
			this.addEvent("onmouseover",function(){ if(t.o.hi.bEv===false) return;t.addClass("over");})
			this.addEvent("onmouseout",function(){if(t.o.hi.bEv===false)return;t.removeClass(["over","clicking"]);})
			this.addEvent("onmousedown",function(){if(t.o.hi.bEv===false)return;t.addClass("clicking").removeClass("over");})
			this.addEvent("onmouseup",function(){if(t.o.hi.bEv===false)return;t.removeClass("clicking");});
			return this;
		},
		// receiving appended childs
		// appends n({array/obj}) to root obj
		// appending/inserting into innerHTML data d (can be array)
		// inserts before child b if is exists
		append: function(n,b){
			// if the given node is a string, an element is created
			// from that tag string
				n = this.parseObject(n);
			// should it insert before, it will
				if(b)
					this.o.insertBefore(n,b);
				else
					this.o.appendChild(n);
			return this;
		},
		// removes n from the root object
		remove: function(n){
			if(!n){
				try{ this.o.parentNode.removeChild(this.o); return null; } catch(e){}
			}
			else
				this.o.removeChild(n);	
			return this;
		},
		//====================
		// h.create()
		//====================
		// @ string		tag		: element to be created from the given tag
		// @ bool		display	: if 'display' === false, the object will be
		//							initially hidden
		// --------------------------------------------------------------------------
		// Creates an element from the given 'tag'
			create: function(tag,display){
				// creates the element
				var c = h(document.createElement(tag));				
				// if display === false the object will be hidden
				if(display===false)	c.display(false);				
				return c.o;
			},
		// sets the visibility / display of the given object
		// so it will/not be seen
		// if no arguments are given, it returns wether the obj
		// is visible or not
			display: function(s,D){
				if(arguments.length){
					this.o.style.visibility = (s==false?'hidden':'visible');
					
					// if D is !== false, we are going to set the object's 
					// display
					if(D!==false)
						this.o.style.display = (s==false?'none':'');
					return this;
				}
				// if no argument is given, a boolean is returned
				// 		false : object is not visible
				//		true  : object IS visible
				return (this.getStyle("display")!= "none" && this.getStyle("visibility")!="hidden" );
			},
		// retrieves the next parent from level l
		// and respecting conditions given by object
		// c ( { abc: def } )..
		parent: function(c,l){	
			if(!l || l<=0) l = 1;
			var p = this;
			try{
			while(  l > 0 && (p = h(p.o.parentNode)) )
				if(p.condition(c,arguments[2])) l--;
			} catch(e){ return null; };
			if(p) return p; // returns instace of h, so its recallable
			return null;
		},
		
		child: function(c,d,l,cd){
			if(!l || l<=0) l = 1; if(!d || d<0) d = 0;
			var p = this.o,r,a=0;

			try{
				if(d == 0 || cd == d){
					for(var i=0;i<p.childNodes.length&&l>0;i++){
						r=p.childNodes[i];
						if(h(r).condition(c)) l--;
					}
					
				}
				else if((r = this.child(r,d,l,++cd)) instanceof h)
					return r;
			} catch(e){ return null };
			if(l==0&&r) return h(r); // returns instace of h, so its recallable
			return null;	
		},
		childIndex: function(){
			for(var i=0;i<this.o.parentNode.childNodes.length;i++)
				if(this.o === this.o.parentNode.childNodes[i])
					return i
			return false;
		},
		// returns .getElementsByTagName
		tags: function(t){
			return this.o.getElementsByTagName(t);	
		}
}

//
// LOOP TIMEOUT
///////////////////
// Looping class
// timeouts the function f(args) until
// it returns true or it's stopped by the .stop()
// function
//	Class Properties
// 		.lastid : distributes the loopID
//		.all : all the loops
//	Class Methods (loopTimeout.fct_name)
//		.get (int id) : (...)
//		.erase (int id) : stops & erase loop
//	Properties
//		.s : loop speed (MS)
//		.f : function to be called on every loop
//		.args : f's arguments (array)
//		.flag : true|false (false stops when looping)
//	Methods
//		.start(): (...)
//		.loop(): private method
//		.stop(): (...)
//
//

loopTimeout = function(s,f,args){
	if(window == this) return new loopTimeout(s,f,args);
	this.id = loopTimeout.lastid++;
	loopTimeout.all[this.id] = this;
	this.s = s;			
	this.f = f;
	if(!(args instanceof Array)) args =  args ? [args] : [];
	this.args = args;
	this.flag = true;
}
loopTimeout.all = {};
loopTimeout.lastid = 0;
loopTimeout.get = function(id,c){
	return (c||loopTimeout.all)[id];
}
loopTimeout.erase = function(id,a){ a = arguments.length > 1 ?( a ): loopTimeout.all;
	if(!a) return;
	if(id===true) return Object.wipe(a,function(o){  o.stop(); });
	var c = loopTimeout.get(id,a);
	try{ c.stop(); delete c; } catch(e){ return false }
	return true;
}
loopTimeout.prototype = {
	start: function(){
		this.flag = true;
		this.loop();
	},
	loop: function(){
		if(this.flag == false) return false;
		var t = this;
		if(this.f.apply(this,this.args) === true)
			window.setTimeout(function(){ t.loop(); },t.s);
		return true;
	},
	stop: function(){
		this.flag = false;	
	}
}

//
// EVENT CONTROL
///////////////////
//
// Global event handler has to be set. 
//	Class Properties:
//		.lastid : last event id
//		.events : collection of all the event created by
//				  this method
//	Class Methods (Event.fct_name)
//		.get (int id) : (...)
//		.erase (int id) : (...)
//	Properties:
//		.disabled : if its true, the function won't be called
//		.type	: which event type it is
//		.id		: differs events
//		.f		: the function to run

Event = function(n,t,f,args,cfg){ if(!cfg) cfg={};
	if(window == this) return new Event(n,t,f,args,front);
	args = array(args);
	// ...
	this.id = Event.lastid++;
	this.disabled = cfg.disabled || false;
	this.f = f;
	// ...
	Event.all[this.id] = this;
	//while(args.length<f.length) args.push(undefined);
	var oF = n[t],b=this;
	try{
		if(cfg.front !== false)
			eval("n[t] = function(evt){  if(b.disabled!==true){ args.push(window.event||evt); f.apply(this,args); } "+(oF?"oF();":"")+"}");
		else
			eval("n[t] = function(evt){ "+(oF?"oF();":"")+" if(b.disabled!==true){ args.push(window.event||evt); f.apply(this,args); }");
	}catch(e){			 return false; }
	return true;
}
Event.lastid = 0;
Event.all = {};
Event.get = function(id,c){
	return (c||Event.all)[id];
}
Event.erase = function(id,a,remove){
	a = a||Event.all;
	if(typeof id == "string") return Object.each(a,function(o){ if(o.type==id){ o.disabled = true; if(remove!==false) delete o;} });
	if(id===true) return Object.each(a,function(o){ o.disabled = true; if(remove!==false) delete o });
	var c = Event.get(id,a);
	try{ c.disabled=true; if(remove==true) delete c; } catch(e){ return false }
	return true;
}

//
// COOKIE WORK
//////////////////
//
	Cookie = {
		set: function(n,v,e,d,p){
			e = new Date(new Date().getTime()+(e||1)*86400000).toGMTString();
			document.cookie = encodeURIComponent(n)+"="+
								encodeURIComponent(v)+
								"; expires="+e/*+
								"; path="+p || "/"+
								(d?"; domain="+d:"")*/
			return this;
		},
		get: function(n){
			n = document.cookie.match(RegExp("(?:^|[; \s])+" + n.regexpEscape() + "=([^;]*)"));
			return n?decodeURIComponent(n[1]):null;
		},
		erase: function(n){
			return this.set(n,"",-1);	
		},
		find: function(c,e,s){	
			try{
			var r = (c = Cookie.get(c).split(s||",")).find(e)
			if(r===false) return false;
			if(e instanceof RegExp) return [r,c[r]];
			return r;
			}catch(e){ return false };
		},
		// r - repeatable
		// s - search term (regexp/string)
		insert: function(c,v,s) {
			var old = Cookie.get(c);
			if(!old || !s || (s!==true ? old.split(",").find(s):old.split(",").find(v))===false)
				Cookie.set(c,(old? (old+","+v) :v));	
		},
		// checks if the cookieing is enable
		check: function(){
			if(Cookie.cookieEnabled === false) return false
			if(navigator.cookieEnabled) return true;
			else if(Cookie.set("CHECKCOOKIE",1).get("CHECKCOOKIE")){ Cookie.erase("CHECKCOOKIE"); return true; }
			cookieEnabled = false;
			return alert("Aparentemente a funcionalidade dos cookies não está disponível.\nPor favor ative-a.");
			return;
			
			/*
			// this would ask ajax if it 
			// is enabled or not
			var k =String.random(15);
			Cookie.set("CHECKCOOKIE",k);
			var a =new Ajax({handleXML:true});
			a.onFinish = function(o){
				Cookie.erase("CHECKCOOKIE");
			}
			a.get(C.ex.hostLink+"__ajax?sid=check-cookie&k="+k);*/
		},
		cookieEnabled: true
	}

//------------------------
// AJAX CLASS
///////////////////////////////////////////
// Ajax - Asynchronous Javascript and XML
// This class is created to http response from
//
var Ajax = function(cfg){
		this.obj = null;
		this.onComplete = null;
		this.loadCallback = null;
		this.onCompleteFail = function(){ alert("AJAX returned an invalid result, please try again."); }
		this.onFinish = null
		this.iddle = "false";
		this.options = new Array();
		this.errors = new Array();
		this.id = Ajax.lastid++;
		this.pid = 0;
		this.cfg = Object.extend({},cfg);
		Ajax.all[this.id] = this;
		this.create();
		
		// no way to stabilish ajax ...
		if(this.obj == null){
			alert("Impossible to stabilish AJAX connection.");
			for(var i in this)
				this[i] = null;
		}
		
		// set default headers
		this.setHeader('Content-Type','application/x-www-form-urlencoded;',false,"post");
   		this.setHeader('Cache-Control',"no-store, no-cache, must-revalidate",false);
		this.setHeader("Cache-Control","post-check=0, pre-check=0",false);
        this.setHeader("Pragma", "no-cache",false); 
}
// Collection of all the AJAX elements
Ajax.lastid = 0;
Ajax.all = [];
Ajax.prototype = {
	create:	function() { try{ this.obj = new XMLHttpRequest();} catch(e)
						   { try{ this.obj = new ActiveXObject('Msxml2.XMLHTTP');} catch(e)
						   { try{ this.obj = new ActiveXObject('Microsoft.XMLHTTP');} catch(e) { this.obj = null; } } } },
	
	/* header work */
	
	setHeader: function(name,value,temp,type){var index;if(type)type=type.toLowerCase();
			if( (index = this.getHeaderIndex(name)) != null )
				this.options[index].value = value;
			else
				this.options.push( { name:name,value:value,temp:(temp === false ? false : true),type:(type=="post" || type=="get" ? type : null) } );
			},
			
	removeHeader: function(name){
					try{ delete this.options[(typeof name == "string" ? this.getHeaderIndex(name) : name)]; return true;} catch(e){ return false; }
			},
	// gets SET REQUEST HEADER value, not returning REQUEST HEADER -- getResHeader
	getHeader: function(name){ var r = null, index = this.getHeaderIndex(name);
				try{ r = this.options[index].value; } catch(e){};
				return r;
			},
			
	getHeaderIndex: function(name){
				for(var i in this.options)
					if( this.options[i].name == name )
						return i;
				return null;
			},
	// get REQUEST HEADER value	
	getResHeader: function(name){ 
				return this.obj.getRequestHeader(name);
			},
	// sets up all the stored headers in options before sending
	setupAllHeaders: function(type){
				for(var i in this.options)
					try{ 
						if(!this.options[i].type || this.options[i].type == type)
							this.obj.setRequestHeader(this.options[i].name,this.options[i].value)
						if(this.options[i].temp)	
							this.removeHeader(i);
					 } catch(e) {}
			},
			
	
	
	/* Control methods */
	/*-----------------*/			
	abort: function(){ this.obj.abort() },
	
	post: function(url,data,async){ 
				Try(loadingDisplayHandler,true);
				try{	
					this.pid++;
					this.obj.open("POST",url,!(async));
					this.setupConfig("post");
					this.obj.send(data);
				}catch(e){ Try(loadingDisplayHandler,false); return false; }
				return true;
			},
					
	get: function(url,async){ 
				Try(loadingDisplayHandler,true);				
				try{
					this.pid++;
					this.obj.open("GET",url,!(async));
					this.setupConfig("get");
					this.obj.send(null);
				}catch(e){Try(loadingDisplayHandler,false); return false;  }
				return true;
			},
			
	setupConfig: function(type){				
				this.setHandlers();
				this.setupAllHeaders(type);
			},
			
	// handles the loading events
	//
	setHandlers: function(){
				var o = this;
				this.obj.onreadystatechange = function(){ o.setHandlerCallback() };
			},
			
	setHandlerCallback: function(){ 
				if(this.obj.readyState == 4){
					Try(loadingDisplayHandler,false);
					if(this.obj.status == 200){
		
						var xmlDoc = XMLDoc(this.obj.responseXML),xmlError=true;
						if(this.cfg.handleXML===true){	
							if(! (xmlError = xmlDoc.handleError(this.cfg.silent)) )
								Try(this.onXMLError,this.obj,xmlDoc);
						}
						if(xmlError)
							Try(this.onComplete,this.obj,xmlDoc);
					}
					else Try(this.onCompleteFail,this.obj);

					Try(this.onFinish,this.obj);
				}
			},
	
	submitForm: function( form , url , async){
				if(typeof form == "string") form = document.forms[form];
				if(!url) url = form.action;
				if(!url) this.addError("Não há destino para o AJAX."); return false; 
				var qry = "";
				for(var i=0;i<form.elements.length;i++){
					if((!form.elements[i].name) || (form.elements[i].type == "checkbox" && !form.elements[i].checked))
						continue;
					else if(form.elements[i].type == "select") 
						form.elements[i].value = form.elements[i].options[form.elements[i].selectedIndex].value;
					qry += "&" + encodeURIComponent(form.elements[i].name) + "=" + encodeURIComponent(form.elements[i].value);
				}
				if(form.method.toLowerCase() == "get")
					this.get(url,async);
				else
					this.post(url,qry,async);
		}		
}		

// XML Document handling class
//

var XMLDoc = function(xmlDoc){
	if(window==this) return new XMLDoc(xmlDoc);
	this.doc = xmlDoc;
}
XMLDoc.prototype = {
	setDoc: function(xmlDoc){ this.doc = xmlDoc, delete this.returnErrorCache; },
	returnError: function(){ 
			if(this.returnErrorCache) return this.returnErrorCache;
			 var res = this.returnCode();
			 return ((this.returnErrorCache = res) ? (res.match(/^SUCCESS/) ? true : false ) : null);
		},
	returnCode: function(){
			var res = this.nodeValue("returnCode"); return res;
		},			
	nodeValue: function(name){
			try{ return $t(name,this.doc)[0].firstChild.nodeValue; } catch(e){ return null }	
		},
	getNodesByNameAndAttributes: function(name,attributes,parentNode){
			if(!parentNode) parentNode = this.doc;

			var attrArray,broken,nodes = $t(name,parentNode),resNodes = new Array();
			for(var i=0;i<nodes.length;i++){
				broken=false,attrArray = new Array();
				for(var b=0;b<nodes[i].attributes.length;b++)
					attrArray[nodes[i].attributes[b].name] = nodes[i].attributes[b].value;
				for(b in attributes)
					if(!attrArray[b] || attrArray[b] != attributes[b]){
						broken = true; break;
					}
				if(!broken)
					resNodes.push(nodes[i]);
			}
			return resNodes;
		},
	handleError: function(silent){
		var e =this.returnError();
		if(e!==true){
			if(!silent){
				var r = this.returnCode();
				// removes ERROR_
				if(r.length) r=r.substr(6);
				switch(r){
					case "EMAIL_VALIDATION": alert("O(s) email(s) não foi(ram) validado(s). Por favor tente novamente."); break;
					case "EMAIL_SEND":	alert("Erro no servidor ao enviar email, por favor tente novamente."); break;
					case "COOKIE_WRONG":
					case "COOKIE_INEXIST":  alert("A funcionalidade dos cookies em seu browser aparenta não estar funcionando.\nPor favor reveja isso."); break;
					default: alert("Houve um erro inesperado na reposta do AJAX, por favor tente novamente."+(r?"\n   - "+r:""));
				}
			}
			return false;
		}
		return true;
	}
}
//
// TEMPLATE OBJECTS CLASS
///////////////////////////
// 

/* templateObj class */
templateObj = function(type){		
		if(type);
		this.setType(type);
		
		this.ajax = new Ajax();
		
		this.onLoad = null;
		this.onError = null;
		this.onCreate = null;
		this.onCreateError = function(){ alert("Error on creating the templateObject."); } ;
		this.status = null;
	}
templateObj.cfg = { templates: {} }
templateObj.prototype = {
		loadFromXML: function(){
				var oThis = this;
				try{
				switch(templateObj.cfg['templates'][this.type]['status']){
				case "loaded": return true;
				case "loading": return false;
				// case "error": 	--> overwritten by status below - loading
				}} catch(e){}
				
				templateObj.cfg['templates'][this.type] = {status:"loading"};
				this.ajax.onComplete = function(){ oThis.loadFromXMLOnComplete(); }
				this.ajax.onCompleteFail = function(){ oThis.loadFromXMLOnCompleteFail(); }
				this.ajax.get(h.ex.hostLink+"__ajax?sid=templateObj&name="+encodeURIComponent(this.type));
				return true;
			},
		
		setType: function(type){
				if(this.type && templateObj.cfg['templates'][type]['status'] == 'loading') return false;
				
				this.type = type;
				if(!templateObjArray(type))
					templateObj.cfg['templates'][type] = new Array();
			},
		
		create: function(){
			if(!this.loadFromXML()) return false;
			this.createCallback();	
		},
		
		// Waiting for it to load
		// ----------------------
		createCallback: function(){

			var oThis = this;
			try{
				switch(templateObj.cfg['templates'][this.type]['status']){
				case "error": throw null;
				case "loading": setTimeout(function(){ oThis.createCallback() },"100"); return;
				// case "error": 	--> overwritten by status below - loading
			}} catch(e){ if(this.onError) this.onError(); if(this.onCreateError) this.onCreateError(this); return false; }
			
			if(this.onCreate)
				this.onCreate(this);
		},
		
		// AJAX reponse functions
		// -----------------------
		loadFromXMLOnComplete: function(){
			var xmlDoc = new XMLDoc(this.ajax.obj.responseXML.documentElement);	
			templateObj.cfg['templates'][this.type] = !xmlDoc.returnError() ? {status:"error"} : {status:"loaded", data:xmlDoc.nodeValue("templateObj")};
			if(this.onLoad)
				this.onLoad(this);
		},
		
		loadFromXMLOnCompleteFail: function(){
			if(this.onError) this.onError();
			alert("AJAX failed to retrieve templateObject contents, please try again.");
			templateObj.cfg['templates'][this.type] = {status:'error'};
		},
		
		// working around the template itself
		replaceData: function(dataArray){ 			
			try{
			if( !templateObj.cfg['templates'][this.type] || !templateObj.cfg['templates'][this.type]['data'] ) return "";
			var data = templateObj.cfg['templates'][this.type]['data'];
			for(var k in dataArray)
				data = data.replaceall("<!--"+k+"-->",dataArray[k]);
			return data;
			} catch(e){ alert("The templateObj returned an error while replacing the data.") }
		}
	}

function templateObjArray(type){ return templateObj.cfg['templates'][type]; }