/**
 * Initialisiert den Namespace für das Jaex-Framwork und stellt verschiedene
 * den anderen Jaex-Namespaces verschiedene Funktionen zur Verfügung.
 *
 * @namespace jaex
 * @version 0.8.4
 */ 
var jaex = {
	version: '0.8.4'
};

/**
 * @private
 */
jaex.events = new Array();

/**
 * Managt die Event-Registrierung.
 */
jaex.registerEvent = function(id, element, event, _obj, call, ret) {
	if(!jaex.util.isObject(jaex.events[id])) {
		jaex.events[id] = new Array();
	}
		
	if(!jaex.util.isObject(jaex.events[id][event])) {
		jaex.events[id][event] = new Array();
	}
		
	jaex.events[id][event][jaex.events[id][event].length] = [_obj, call];
	
	var events = jaex.events[id][event];
	var evCode = "";
	
	element._jaexevobj = new Array();
	for(var ec = 0; ec < events.length; ec++) {
		element._jaexevobj[ec] = events[ec][0];
		evCode += "this._jaexevobj[" + ec + "]." + events[ec][1] + "(this); ";
	}
	
	if(jaex.util.isDefined(ret)) evCode += "return " + ret + ";";
	eval("element." + event + " = function() {" + evCode + "};");
}

jaex.unregisterEvent = function(id) {
	jaex.events[id] = new Array();
}

/** 
 * Util-Funktionen
 *
 * @namespace jaex.util
 * @requires jaex vX
 */ 
jaex.util = function() {}

/**
 * Ist Objekt?
 *
 * @param var 
 * @return bool  
 */
jaex.util.isObject = function(obj) {
	if(typeof(obj) == 'object') {
		return true;
	}
	else return false;
}

/**
 * Ist Array?
 *
 * @param var
 * @return bool  
 */
jaex.util.isArray = function(obj) {
   if (obj.constructor.toString().indexOf("Array") == -1)
      return false;
   else
      return true;
}

/**
 * Defniert?
 *
 * @param var
 * @return bool  
 */
jaex.util.isDefined = function(o) {
	return typeof(o)!="undefined";
}

/**
 * Ist String leer?
 *
 * @param string
 * @return bool  
 */
jaex.util.isStrEmpty = function(str) {
	if(str.length > 0) return false;
	else return true;
}

jaex.util.clone = function(obj) {
    if(obj == null || typeof(obj) != 'object')
        return obj;

    var temp = new obj.constructor(); // changed (twice)
    for(var key in obj)
        temp[key] = jaex.util.clone(obj[key]);

    return temp;
    
    /*
    if(obj == null || typeof(obj) != 'object')

        return obj;



    var temp = {};

    for(var key in obj)

        temp[key] = clone(obj[key]);

    return temp;*/

}
/*
jaex.util.isArray = function(o) {
	// If these conditions aren't met, it certainly isn't an Array
	if (o==null || typeof(o)!="object" || typeof(o.length)!="number") {
		return false;
	}
	// Check to see if the object is an instance of the window's Array object
	if (defined(Array) && defined(o.constructor) && o.constructor==Array) {
		return true;
	}
	// It might be an array defined from another window object - check to see
	//if it has an Array's methods
	if (typeof(o.join)=="function" && typeof(o.sort)=="function" && typeof(o.reverse)=="function") {
		return true;
	}
	// As a last resort, let's see if index [0] is defined
	return (o.length==0 || defined(o[0]));
};
*/

jaex.util.datetime = function() {}

jaex.util.datetime.dateTimeStr2Date = function(str) {
	var dttmp = str.split(" ");
	var dtmp = dttmp[0].split(".");
	var ttmp = dttmp[1].split(":");
	return new Date(dtmp[2], (dtmp[1] - 1), dtmp[0], ttmp[0], ttmp[1], ttmp[2]);
}

jaex.util.datetime.dateStr2Date = function(str) {
	var dtmp = str.split(".");
	return new Date(dtmp[2], (dtmp[1] - 1), dtmp[0]);
}

jaex.util.datetime.date2DateStr = function(date) {
	return jaex.util.datetime.d2C(date.getDate()) + "." + 
	jaex.util.datetime.d2C(date.getMonth() + 1) + "." + 
	date.getFullYear();	
}

jaex.util.datetime.d2C = function (num) {
	if(10 > num) return "0" + num;
	else return num;
}

jaex.util.datetime.isDateValid = function(dt) {
	if('Invalid Date' == dt || 'NaN' == dt) return false;
	if(dt.getDate() == 'NaN') return false;
	return true;
}

/**
 * Ajax
 *
 * @namespace jaex.ajax
 * @requires prototype  
 */
jaex.ajax = function() {}

/**
 * Öffnet einen Get-Request
 */
jaex.ajax.openGetRequest = function(url, _obj, handle) {
	 //encodeURIComponent("");
	var myAjax = new Ajax.Request(url, {
			method: 'get', 
			onComplete: function(request) { jaex.ajax.responseGetRequest(_obj, handle, request) }
	});
}

/**
 * Öffnet einen Post-Request
 */
jaex.ajax.openPostRequest = function(url, _obj, handle, params) {
	 //encodeURIComponent("");
	var myAjax = new Ajax.Request(url, {
			method: 'post', 
			parameters: params,
			onComplete: function(request) { jaex.ajax.responseGetRequest(_obj, handle, request) }
	});
}


/**
 * @private 
 */
jaex.ajax.responseGetRequest = function(_obj, handle, request) {
	eval("_obj." + handle +"(request.status, request.responseText);");
}

/**
 * Führt JavaScript des übergebenen HTML-Codes aus.
 *
 * @param string HTML-Code
 */
jaex.ajax.intepretJS = function(html) {
	var regexp = /<script +type="text\/javascript"[^>]*>([^<]+<!--)?[^<\/]+/;
	var val = regexp.exec(html);
	if(jaex.util.isArray(val)) {
		regexp = /<script +type="text\/javascript"[^>]*>([^<]+<!--)?/;
		regexp2 = /-->/;
		for(vc = 0; vc < val.length; vc++) {
			val[vc] = val[vc].replace(regexp, "").replace(regexp2, "");
			eval(val[vc]);
		}
	}
}


/**
 * Vereinfach das verwenden von Timeouts / Sleeps
 *
 * @namespace jaex.timeout  
 */
jaex.timeout = function() {};

/**
 * @private 
 */
jaex.timeout.stack = new Array();

/**
 * Setzt Timeout
 *
 * @param time 		Sleeptime
 * @param _obj 		Objekt und Methode mit Parametern, die nach dem Timeout 
 * @param handle	aufgerufen werden soll.
 * @param param		Parameter
 */
jaex.timeout.set = function(time, _obj, handle, params) {
	var index = jaex.timeout.stack.length;
	jaex.timeout.stack[index] = [_obj, handle, params];
	setTimeout("jaex.timeout.handle(" + index + ")", time);
};

/**
 * @private 
 */
jaex.timeout.handle = function(index) {
	var _obj = jaex.timeout.stack[index][0];
	var handle = jaex.timeout.stack[index][1];
	var params = jaex.timeout.stack[index][2];
	var paramstr = "";
	for(var pc = 0; pc < params.length; pc++) {
		if(pc > 0) paramstr += ", ";
		paramstr += "params[" + pc + "]";
	}
	
	eval("_obj." + handle + "(" + paramstr + ");");
};