/**
 *
 * HAEDUS Javascript-Library
 * @Version 1.0
 *
 *
 *
 */
Haedus = {
	
	version			: '1.0'
	
};


/**
 * Browser ermitteln
 */
(function() {
	
	ua				= navigator.userAgent.toLowerCase();
	
	isStrict		= ("CSS1Compat" == document.compatMode);
	isOpera			= (-1 < ua.indexOf("opera"));
	isSafari		= (/webkit|khtml/).test(ua);
	isSafari3		= ((-1 != isSafari) && ua.indexOf("webkit/5"));
	isIE			= ((-1 < !isOpera) && ua.indexOf("msie"));
	isIE7			= ((-1 < !isOpera) && ua.indexOf("msie 7"));
	isGecko			= ((-1 < !isSafari) && ua.indexOf("gecko"));
	isBorderBox		= (isIE && !isStrict);
	isWindows		= ((-1 != ua.indexOf("windows")) || (-1 != ua.indexOf("win32")));
	isMac			= ((-1 != ua.indexOf("macintosh")) || (-1 != ua.indexOf("mac os x")));
	isAir			= (-1 != ua.indexOf("adobeair"));
	isLinux			= (-1 != ua.indexOf("linux"));
	isSecure		= (0 === window.location.href.toLowerCase().indexOf("https"));
	
	Haedus.getDom = function(element) {
		
		if(!element || !document) {
			return null;
		}
		
		return ((element.dom)
					?	element.dom
					:	(("string" == typeof element)
							?	document.getElementById(element)
							:	element)
		);
		
	};
	
}) ();






/**
 * HAEDUS Software Solutions
 * DOM-Funktion
 * 
 * getOffset(obj)
 * getId(obj)
 * getOffsetX(obj)
 * getOffsetY(obj)
 * getOffsetW(obj)
 * getOffsetH(obj)
 * 
 */
Haedus.Dom = function() {
	
	return {
		
		/**
		 * Liefert die aktuelle Position und Größe des übergebenen Objektes
		 * @param element obj
		 * @return object
		 */
		getOffset : function(obj) {
			
			var left	= 0;
			var top		= 0;
			var width	= obj.offsetWidth;
			var height	= obj.offsetHeight;
			
			if (obj == (document.body || document.documentElement)) {
				
				return {
					X : left,
					Y : top,
					W : width,
					H : height
				};
				
			}
			
			while (obj.offsetParent){
				
				left	+=	obj.offsetLeft;
				top		+=	obj.offsetTop;
				obj		=	obj.offsetParent;
				
			}
		
			return {
				X : left,
				Y : top,
				W : width,
				H : height
			};
			
		},
		
		/**
		 * Liefert die ID des übergebenen Objektes
		 * @param element obj
		 * @return string
		 */
		getId : function(obj) {
			return obj.getAttribute('id');
		},
		
		/**
		 * Liefert die Position auf der X-Achse des übergebenen Objektes
		 * @param element obj
		 * @return integer
		 */
		getOffsetX : function(obj) {
			return this.getOffset(obj).X;
		},
		
		/**
		 * Liefert die Position auf der Y-Achse des übergebenen Objektes
		 * @param element obj
		 * @return integer
		 */
		getOffsetY : function(obj) {
			return this.getOffset(obj).Y;
		},
		
		/**
		 * Liefert die Breite des übergebenen Objektes
		 * @param element obj
		 * @return integer
		 */
		getOffsetW : function(obj) {
			return this.getOffset(obj).W;
		},
		
		
		/**
		 * Liefert die Höhe des übergebenen Objektes
		 * @param element obj
		 * @return integer
		 */
		getOffsetH : function(obj) {
			return this.getOffset(obj).H;
		}
		
	}
	
} ();


/**
 * HAEDUS Software Solutions
 * Eventhandling
 * 
 */
Haedus.Event = function() {
	
	functions = new Object;
	listeners = new Array;
	
	return {
		
		/**
		 * Hinzufügen einer neuen Funktion
		 * Liefert bei erfolg den Bereich oder FALSE wenn der übergebene Bereich bereits existiert
		 * @param string scope
		 * @param element obj
		 * @return mixed
		 */
		addFunction : function(scope, obj) {
			
			functions[scope] = obj;
			/*if (functions[scope]) {
				return false;
			} else {
				functions[scope] = obj;
			}*/
			
			return scope;
			
		},
		
		/**
		 * Liefert das Objekt zum übergebenen Bereich oder FALSE
		 * @param string scope
		 * @return mixed
		 */
		getFunction : function(scope) {
			
			if (functions[scope]) {
				return functions[scope];
			}
			
			return false;
			
		},
		
		/**
		 * Durchsucht die Liste der gespeicherten Funktionen nach einer Bestimmten
		 * Liefert das Funktionsobjet oder FALSE
		 * @param object obj
		 * @param string type
		 * @return mixed
		 */
		findFunction : function(obj, type) {
			
			var id = null;
			var fnc = false;
			
			while ('body' != obj.nodeName.toLowerCase() && 'html' != obj.nodeName.toLowerCase() && '#document' != obj.nodeName.toLowerCase()) {
				
				id = Haedus.Dom.getId(obj);
				
				if (null === id) {
					obj = obj.parentNode;
					continue;
				}
				
				fnc = this.getFunction(id);
				
				if(false !== fnc) {
					break;
				}
				
				obj = obj.parentNode;
				
			}
			
			return fnc;
			
		},
		
		/**
		 * Hinzufügen eines neuen Listeners
		 * Liefert FALSE wenn das Event nicht gesetzt werden konnte
		 * @param string scope
		 * @param string type
		 * @param object fnc
		 * @return boolean
		 */
		addListener : function(scope, type, fnc) {
			
			var obj = Haedus.getDom(scope);
			
			if(!obj) {
				return false;
			}
			
			var usr = function(event) {
				return (("undefined" != typeof Haedus)
							?	fnc(Haedus.Event.getEvent(event))
							:	false);
			};
			
			listeners.push({
				scope : scope,
				type : type,
				fnc : usr}
			);
			
			this.addEvent(obj, type, usr, false);
			
			return true;
			
		},
		
		/**
		 * Entfernen eines Listeners
		 * @param string scope
		 * @param element obj
		 * @return boolean
		 */
		rmvListener : function(scope, type) {
			
			var obj = Haedus.getDom(scope);
			var index = this.findListener(scope, type);
			
			this.rmvEvent(obj, type, listeners[index].fnc, false);
			listeners.splice(index, 1);
			
			return true;
			
		},
		
		/**
		 * Durchsucht die List der gespeicherten Listener nach einem bestimmten
		 * Liefert das Eventobjekt oder FALSE
		 * @param string scope
		 * @param string type
		 * @return mixed
		 */
		findListener : function(scope, type) {
			
			for(i=0; i<listeners.length; i++) {
				
				if (listeners[i].scope == scope && listeners[i].type == type) {
					return i;
				}
				
			}
			
			return -1;
			
		},
		
		/**
		 * Liefert das Objekt zum übergebenen Event oder FALSE
		 * @param event event
		 * @return event
		 */
		getEvent : function(event) {
			
			var current = (event || window.event);
			
			if(!current) {
				
				var tmp = this.getEvent.caller;
				
				while(tmp) {
					
					current = tmp.arguments[0];
					
					if(current && (Event == current.constructor)){
						break;
					}
					
					tmp=tmp.caller;
					
				}
				
			}
			
			return current;
			
		},
		
		/**
		 * Hinzufügen eines neuen Events
		 * @return void
		 */
		addEvent : function() {
			
			if(window.addEventListener) {
				
				return function(obj, type, fnc, cpt){
					obj.addEventListener(type, fnc, cpt);
				};
				
				
			} else if(window.attachEvent) {
				
				return function(obj, type, fnc, cpt){
					obj.attachEvent("on" + type, fnc);
				};
				
				
			} else {
				
				return function() {};
				
			}
			
		} (),
		
		/**
		 * Entfernen eines Events
		 * @return void
		 */
		rmvEvent : function() {
			
			if(window.removeEventListener) {
				
				return function(obj, type, fnc, cpt){
					obj.removeEventListener(type, fnc, cpt);
				};
				
				
			} else if(window.detachEvent) {
				
				return function(obj, type, fnc, cpt){
					obj.detachEvent("on" + type, fnc);
				};
				
				
			} else {
				
				return function() {};
				
			}
			
		} (),
		
		/*
		stopEvent : function(event) {
			
			this.stopPropagation(event);
			this.preventDefault(event);
			
		},
			
		stopPropagation : function(event){
			
			var current = (event || window.event);
			
			if(current.stopPropagation) {
				current.stopPropagation();
			} else {
				current.cancelBubble = true;
			}
			
		},
			
		preventDefault : function(event){
			
			var current = (event || window.event);
			
			if(event.preventDefault) {
				event.preventDefault();
			} else {
				event.returnValue = false;
			}
			
		},
		*/
		
		/**
		 * Liefert das Element auf dem sich das Event bezieht
		 * @param event event
		 * @return element
		 */
		getTarget : function(event, tagName) {
			
			event = (event || window.event);
			
			var target = (event.target || event.srcElement);
			
			if (!tagName) {
				return this.resolveTextNode(target);
			} else {
				return this.getCurrentElementWithTagName(this.resolveTextNode(target), tagName);
			}
			
		},
		
		/**
		 * Liefert das Element
		 * @param element node
		 * @return element
		 */
		resolveTextNode : function(node) {
			
			if(Haedus.isSafari && node && (3 == node.nodeType)){
				return node.parentNode;
			} else {
				return node;
			}
			
		},
		
		/**
		 * Liefert ein bestimmtes Element nach dem TagName
		 * @param element node
		 * @param string tageName
		 * @return element
		 */
		getCurrentElementWithTagName : function(node, tagName) {

			var elementData = new Object();
			counter = 0;
	
			while((node.nodeName.toUpperCase() != tagName.toUpperCase()) && (node.nodeName != 'BODY')) {
				counter++;
				node = node.parentNode;
			}

			if(node.nodeName == tagName) {
				return node ;
			} else {
				return null;
			}
			
		},
		
		/**
		 * Liefert die aktuelle X-Koordinate des Mouszeigers
		 * @param event event
		 * @return integer
		 */
		getMouseX : function(event) {
			
			event = (event || window.event);
			
			var coord = event.pageX;
			
			if(!coord && (0 !== coord)) {
				
				coord = (event.clientX || 0);
				
				if(Haedus.isIE){
					coord += this.getScroll().X;
				}
				
				
			}
			
			return coord;
			
		},
		
		/**
		 * Liefert die aktuelle Y-Koordinate des Mouszeigers
		 * @param event event
		 * @return integer
		 */
		getMouseY : function(event) {
			
			event = (event || window.event);
			
			var coord = event.pageY;
			
			if(!coord && 0 !== coord) {
				
				coord = (event.clientY || 0);
				
				if(Haedus.isIE) {
					coord += this.getScroll().Y;
				}
				
			}
			
			return coord;
			
		},
		
		/**
		 * Liefert die aktuelle Position des Mouszeigers
		 * @param event event
		 * @return integer
		 */
		getMouseXY : function(event) {
			
			event = (event || window.event);
			
			return {
				X : this.getMouseX(event),
				Y : this.getMouseY(event)
			}
			
		},
		
		/**
		 * Liefert die Scrollposition der Seite
		 * @return object
		 */
		getScroll : function() {
			
			var de = document.documentElement;
			var db = document.body;
			
			if(de && (de.scrollTop || de.scrollLeft)) {
				
				return {
					Y : de.scrollTop,
					X : de.scrollLeft
				};
				
			} else if(db) {
				
				return {
					Y : db.scrollTop,
					X : db.scrollLeft
				};
				
			} else {
				
				return {
					Y : 0,
					X : 0
				};
				
			}
			
		}
		
	}
	
} ();

Haedus.Fnc = {};