//rollover effect

if (1 /*!typeof Netaffinity*/) {
	Netaffinity = {
		Namespace: {
			/**
			 * 
			 * @param {Object} ns
			 * @param {Object} root
			 * @return true if a namespace wasn't registered, ie. we've just registered it, false if it was already registered
			 */
			register: function(ns, root) {
				var wasRegistered = true;
				if (!root) root = window;
				var nsParts = ns.split(".");
				
				for (var i = 0; i < nsParts.length; i++) {
					if (!root[nsParts[i]] /*typeof root[nsParts[i]] == undefined*/) {
						root[nsParts[i]] = {};
						wasRegistered = false;
					}
					
					root = root[nsParts[i]];
				}
				
				return !wasRegistered;
			}
			
			/*
			register: function(_Name) {
				var chk = false;
				var cob = "";
				var spc = _Name.split(".");
				for(var i = 0; i<spc.length; i++) {
				if(cob!=""){cob+=".";}
				cob+=spc[i];
				chk = this.exists(cob);
				if(!chk){this._Create(cob);}
				}
				
				if(chk){ throw "Namespace: " + _Name + " is already defined."; }
				},
				
				_create: function(_Src) {
				window[_Src] = {};
				},
				
				exists: function(_Src) {
				eval("var NE = false; try{if(" + _Src + "){NE = true;}else{NE = false;}}catch(err){NE=false;}");
				return NE;
			}
			*/
		},
		
		Alternator: function (state0Handler, state1Handler) {
			//this.alternatedObject = alternatedObject;
			this.state0Handler = state0Handler;
			
			if (state1Handler) {
				this.state1Handler = state1Handler;
			} else {
				this.state1Handler = state0Handler;
			}
			
			this.state = 0;
		},
		
		Fx: {	
			/**
			 * 	function state1Handler(alternatedObject, stateObject) {
			 *		alternatedObject.morph('height:95px;');
			 *		stateObject.innerHTML = "hide details";
			 *	}
			 *	
			 *	function state2Handler(alternatedObject, stateObject) {
			 *		alternatedObject.morph('height:23px;');
			 *		stateObject.innerHTML = "show details";
			 *	}
			 * 
			 * @param {Object} alternatedObject Element which state you want to alter.
			 * @param {function} state1Handler function(alternatedObject, stateObject).
			 * @param {function} state2Handler=state1Handler *optional* function(alternatedObject, stateObject).
			 * @param {Object} stateObject=alternatedObject *optional* Object that holds the state (eg. anchor element), by default it's alternatedObject. 
			 */
			alternate1: function(alternatedObject, state1Handler, state2Handler, stateObject) {
				if (!stateObject) stateObject = alternatedObject;
				
				// it must be _Netaffinity, because it was collision in 
				// <a onclick="return Netaffinity.Fx.alternate1($('detail-orange'), alternate1, alternate2, this);"/>
				// onlick will take Netaffinity from anchor element instead of global scope
				Netaffinity.Namespace.register('_Netaffinity.Fx.alternate1', stateObject);
				
				var _state = stateObject._Netaffinity.Fx.alternate1;
				_state.state = !_state.state;
				
				if (_state.state || !state2Handler) {
					state1Handler(alternatedObject, stateObject);
				} else {
					state2Handler(alternatedObject, stateObject);
				}
				
				return false;
			},
			
			state1: function(alternatedObject, stateObject) {
				if (!stateObject) stateObject = alternatedObject;
				Netaffinity.Namespace.register('_Netaffinity.Fx.Alternate.alternate', stateObject);
				return !!stateObject._Netaffinity.Fx.alternate.state;
			},
			
			hide: function(alternatedObject, stateObject) {
				if (Netaffinity.Fx.state1(alternatedObject, stateObject)) {
					$('detail-orange').morph('height:23px;');
					self.innerHTML = "show details &raquo;";
				}
				
				self.netaffinity.hidden = !self.netaffinity.hidden;
				
				return false;
			},
			
			hide: function(self) {
				if (!self.netaffinity) 
					self.netaffinity = {
						hidden: true
					};
				
				if (self.netaffinity.hidden) {
				}
				else {
					$('detail-orange').morph('height:23px;');
					self.innerHTML = "show details &raquo;";
				}
				
				self.netaffinity.hidden = !self.netaffinity.hidden;
				
				return false;
			}
		}
	}
	
	Netaffinity.Alternator.prototype = {
		/**
		 * Alternate the state.
		 */
		alternate: function() {
			this.state = !this.state;
			
			if (this.state) {
				this.state0Handler(this);
			} else {
				this.state1Handler(this);
			}
			
			return false;
		},
		
		/**
		 * Enforce the state.
		 * 
		 * @param {Object} state State number 0 or 1
		 */
		setState: function(state) {
			if (this.state != state) this.alternate(); 
		},
		
		getHandler: function() {
			return this.alternate.bind(this);
		}
	}
}