//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// GLOBALE JAVASCRIPT FUNKTIONEN UND KLASSEN WELCHE QUER DURCH DIE APPLIKATION BENÖTIGT WERDEN
//
// Beinhaltet aktuell folgende Klassen:
//
//   #XX Allgemeine Funktionen wie LTrim, RTrim, Trim, NumTrim ...
//   #XX Allgemeine Handler wie window.onerror usw.
//
//   sowie die Klassen
//
//   #01 ####RESERVIERT######
//   #02 Url (utf8 encode und decode von strings)
//   #03 FunctionDelayer (verzögert einen Funktionsaufruf so lange bis kein Trigger Event innerhalb der  x ms aufgetreten ist.
//   #04 Office - Menü (Superfish Menü) Funktionalität für das Hauptmenü der Applikation
//	 #05 LyoFileUpload - Klasse für FileUpload Diloage
//	 #06 CustomerIdFormatter - Formatiert die eingegebene KundenID beim Verlassen anhand des Kunden-ID Schemas
//	 #07 DealerIdFormatter - Formatiert eine HändlerID beim Verlassen eines Feldes anhand des Händler-ID Schemas
//	 #08 FieldRubber - Löscht den Wert aus allen übergebenen Eingabefeldern
//	 #09 Klasse onchangeblur - Ruft eine Funktion auf wenn sich der Wert im Eingabefeld seit dem letzten Verlassen geändert hat, und das Eingabefeld verlassen wird.
//	 #10 Klasse für Please Wait
//	 #11 Serveraufruf via Ajax
//	 #12 Klasse FormFieldReminder - Merkt sich alle Formularfelder beim Seitenaufbau beim verlassen kann so z.B. geprüft werden ob mann nicht auf das Speichern vergessen hat.
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// <reference path="jquery-1.3.2.min-vsdoc.js" />

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ToDo Eventuell umabuen auf eine sichere Variante
// Eval ist 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function doEval(str) {
	return eval(str);
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Allgemeine Funktionen
//
// Beinhaltet:
//
//      LTrim, RTrim, Trim, NumTrim
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*tp%3A//www.lyoness.ag/internal/CustomerCenter/OnlineShops/Redirect%3Fhid%3D109000006%26s
$(window).error(function(e) {
//alert(e);
});
*/

var Public_onlineShops = {
	onlineShops_open: function(obj, loggedIn, loginUrl, defaults) {

		var url = $(obj).attr("href");
		
		if (!url) return true;
		if (loggedIn) {
			var popup = window.open(url, '');
			return (popup) ? false : true;
		}
		else {


			var title = TransByMember("OnlineshoppingLoginDialogTitle", "JSArea.DealerSearchArea")
			//var url = "/" + CountryID + "/t_login_dialog.aspx?referrer=" + escape(url);
			//var url = "/" + CountryID + "/login_form.aspx?referrer=" + escape(url);
			var url = loginUrl+"?referrer=" + escape(url);

			
			var defaults = {
				InitUrl: url,
				title: title,
				Size: {
					Height: 468,
					Width: 440
				},
				OnClosed: Public_onlineShops.onlineShopsDialogClose
			};
			var parentWin = new LyoGenericWindow(url, defaults);
			parentWin.ShowDlg();
			return false;

		}

	}
}
	

// Schneidet bestimmte Zeichen am Anfang eines Strings weg
function LTrim(str, chars) {
	chars = chars || "\\s";
	return str.replace(new RegExp("^[" + chars + "]+", "g"), "");
}

// Schneidet bestimmte Zeichen am Ende Eines Strings weg
function RTrim(str, chars) {
	chars = chars || "\\s";
	return str.replace(new RegExp("[" + chars + "]+$", "g"), "");
}

// Schneidet bestimmte Zeichen am Anfang und Ende des Strings weg
function Trim(str, chars) {
	return LTrim(RTrim(str, chars), chars);
}

// Schneidet alle Sonderzeichen ausser Zahlen aus dem String.
function NumTrim(str) {

	if (str == null) return null;
	var vNewStr = "";

	for (var vcnt = 0; vcnt < str.length; vcnt++) {
		if (!isNaN(str.charAt(vcnt))) {
			vNewStr = vNewStr + str.charAt(vcnt);
		}
	}

	return vNewStr;
}

// Prüft ob ein String leer ist oder Null
function IsNullOrEmpty(str) {
	if (str == null || str == "" || str == undefined) {
		return true;
	}
	return false;
}

function IsNullOrUndefined(obj) {

	if (obj == null || obj == undefined)
		return true;

	return false;
}

// Prüfungen für Zahlen (Javascriptprüfung und Länderprüfung)
function IsNumber(value) {

	if (IsNullOrEmpty(value))
		return false;
	if(!isNaN(value)) 
		return true;
	
	value = value.replace(new RegExp(/\s+/g), '');

	var regex = '^-?(?:\\d+|\\d{1,3}(?:' + _thousandSeparator.replace('.', '\\.') + '\\d{3})+)(?:' + _decimalSeparator.replace('.', '\\.') + '\\d+)?$';
	var re = new RegExp(regex);
	
	return !isNaN(value) || re.test(value);
}

// Wandelt länderspezifische Zahl in javascriptfähige Zahl um
function NumberDefaultToNumber(value) {
	
	value = value + '';
	if (IsNumber(value)) {
		var thSeparator = _thousandSeparator.replace('.', '\\.');
		var deciSeparator = _decimalSeparator.replace('.', '\\.');

		return parseFloat(value.replace(new RegExp(/\s+/g), '').replace(new RegExp(thSeparator, 'g'), '').replace(new RegExp(deciSeparator), '.'));
	}

	return value;
}

// Wandelt javascriptfähige Zahl in länderspezifische Zahl um
function NumberToNumberDefault(value) {
	value = value + '';
	var start = value.indexOf('-') != -1 ? 4 : 3;
	if (value.indexOf('.') > start || (value.indexOf('.') == -1 && value.length > (start + 1))) {
		var index = value.indexOf('.') - 3;
		if (index < 1) index = value.length - 3;
		do {
			value = value.substring(0, index) + ',' + value.substring(index);
			index = index - 3;
		} while (index > 0 && (value.indexOf('-') == -1 || index > 1));
	}

	return value.replace(/\./g, '#').replace(/,/g, _thousandSeparator).replace(/#/, _decimalSeparator);
}

// Wandelt einen String in eine Kundennummer um
function toCustomerNumber(custnumvalue) {
	
	var vOrigValue = NumTrim(custnumvalue);

	var vTempValue = "";
	var vNewValue = "";

	var vCharCount = 0;
	var vPointCount = 0;
	
	if (vOrigValue.length < 7 || vOrigValue.length > 12) {
		return "";
	}
	
	if (vOrigValue.length >= 7 && vOrigValue.length <= 15) {

		// Punkte setzen
		for (var vMax = vOrigValue.length - 1; vMax >= 0; --vMax) {

			if (vCharCount == 3) {
				vTempValue = vTempValue + ".";
				vCharCount = 0;
				vPointCount++;
			}

			vTempValue = vTempValue + vOrigValue.charAt(vMax);
			vCharCount = vCharCount + 1;
		}

		var vTempNulls = "";
		// mit führenden Nullen auffüllen
		for (var noex = vCharCount; noex < 3; noex++) {
			vTempNulls = vTempNulls + "0";
		}

		vNewValue = vTempNulls;

		// jetzt nochmal deas Ganze umdrehen.
		for (var vMax2 = vTempValue.length - 1; vMax2 >= 0; --vMax2) {
			vNewValue = vNewValue + vTempValue.charAt(vMax2);
		}


		// wir befüllen den zweiten Block mit drei Nullen wenn notwendig.
		if (vPointCount == 2) {
			var vCols = vNewValue.split(".");
			if (vCols.length == 3) {
				vNewValue = vCols[0] + ".000." + vCols[1] + "." + vCols[2];
			}
		}	
	}
	
	return vNewValue;
}

// Wandelt einen String in eine Dealernummer um
function toDealerNumber(dealernumvalue) {
	return dealernumvalue;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Allgemeine Handler
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Allgemeine Handler
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


LyonessErrorHandler = function() {
this.self = this;
	//ToDo vorübergehen ausgeschaltet
	return;
	if (DebugMode != undefined && DebugMode == false) {

		// Alle nicht von uns geworfenen bzw. abgefangen Javascript Fehler werden hier klient und serverseitig gemeldet
		window.onerror = function(nachricht, datei, zeile) {

			if (window.disableErrorCatching == undefined || window.disableErrorCatching == null || window.disableErrorCatching == false) {

				var errMsg = "" +
					LyonessErrorHandler.MessagePrefix + "\n\n" +
					"Error: " + nachricht + " \n" +
					"File: " + datei + " \n" +
					"Row: " + zeile + " \n\n" +
					"You will be forwarded automatically. The error will be logged on the server! ";

				alert(errMsg);
				LyonessErrorHandler.SendAndRedirectToErrorPage(errMsg);

				return true;

			} else {

				return false;
			}
		}
	}
}

LyonessErrorHandler.MessagePrefix = "JavaScriptError: ";

LyonessErrorHandler.prototype.SendError = function(message) {
	LyonessErrorHandler.SendAndRedirectToErrorPage(LyonessErrorHandler.MessagePrefix + message);
}

LyonessErrorHandler.prototype.SendAjaxError = function(xhr, ajaxOptions, thrownError) {

	var errMsg = "" +
		LyonessErrorHandler.MessagePrefix + "\n\n" +
		"xhr: " + xhr + " \n" +
		"ajaxOptions: " + ajaxOptions + " \n" +
		"thrownError: " + thrownError + "";

	LyonessErrorHandler.SendAndRedirectToErrorPage(errMsg);
}

LyonessErrorHandler.SendAndRedirectToErrorPage = function(errMsg) {

	var logError = false;

	try {
		
		if (DebugMode == true) {
			$.ajax({
				url: HttpRootPath + 'public/Home/LogError',
				cache: false,
				type: 'POST',
				async: false,
				data: { msg: errMsg },
				dataType: 'text',
				success: function(response) {
					if (response == 'OK') {
						logError = false;
					} else {
						logError = true;
					}
				},
				error: function(xhr, ajaxOptions, thrownError) {
					logError = true;
				}
			});

			window.document.location.href = HttpRootPath + 'public/Home/error';
		}

	} catch (e) {
		logError = true;
	}

	if (logError == true) {
		alert("Your error could not be logged! Contact DataService!");
	}
}

var LyoErrorHandler = new LyonessErrorHandler();

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// KLASSE URL (utf8 encode und decode von strings)
//
// Beispiel:
//
//      var newstring = Url.decode("ein utf encodierter string");
//      var oldstring = Url.encode(newstring);
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Klasse FUNCTION DELAYER
// Verzögert einen Funktionsaufruf so lange bis kein Trigger Event innerhalb der ms aufgetreten ist
//
// Beispiel:
//
//      var fctdelay = new FunctionDelayer(
//                          [Name des FunktionDelayers],
//                          [Die Funktion die aufgerufen werden soll],
//                          [Ein Objekt das der Funktion als Parameter übergeben werden soll],
//                          [Anzahl der Millisekunden die bis zum Aufruf gewartet werden soll]
//                      );
//
//      fctdelay.Trigger();
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

FunctionDelayer = function(name, successfunction, obj, ms) {

	this.name = name;
	this.succobject = obj;
	this.succfunction = successfunction;
	this.ms = ms;

	this.triggered = null;
	this.aborted = false;

	this.CheckWait = function(objectname) {

		if (window["fctdelayer_" + objectname].aborted == false) {

			if (window["fctdelayer_" + objectname].triggered == false) {
				// funktion aufrufen
				window["fctdelayer_" + objectname].triggered = null;
				window["fctdelayer_" + objectname].succfunction(this.succobject);
			} else {
				// es folgt ein weiterer aufruf
				window["fctdelayer_" + objectname].triggered = false;
				window.setTimeout("window[\"fctdelayer_" + objectname + "\"].CheckWait(\"" + objectname + "\")", window["fctdelayer_" + objectname].ms);
			}

		} else {
			window["fctdelayer_" + objectname].triggered = null;
		}
	}
}

FunctionDelayer.prototype.Trigger = function() {

	if (this.triggered == false) {

		this.triggered = true;

	} else if (this.triggered == null) {

		this.triggered = false;
		window["fctdelayer_" + name] = this;
		window.setTimeout("window[\"fctdelayer_" + name + "\"].CheckWait(\"" + name + "\")", this.ms);
	}
}

FunctionDelayer.prototype.Abort = function() {

	this.aborted = true;
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Klasse OFFICE-MENU
// DropDown Menü für die Office - Webseite
//
// Beispiel:
//
//       $(document).ready(function() { 
//              $('ul.sf-menu').superfish();
//       });
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

; (function($) {

	$.fn.superfish = function(op) {

		var sf = $.fn.superfish,
			c = sf.c,
			$arrow = $(['<span class="', c.arrowClass, '"> &#187;</span>'].join('')),
			over = function() {
				var $$ = $(this), menu = getMenu($$);
				clearTimeout(menu.sfTimer);
				$$.showSuperfishUl().siblings().hideSuperfishUl();
			},
			out = function() {

				var $$ = $(this), menu = getMenu($$), o = sf.op;

				clearTimeout(menu.sfTimer);

				menu.sfTimer = setTimeout(function() {
					o.retainPath = ($.inArray($$[0], o.$path) > -1);
					$$.hideSuperfishUl();
					if (o.$path.length && $$.parents(['li.', o.hoverClass].join('')).length < 1) { over.call(o.$path); }
				}, o.delay);
			},
			getMenu = function($menu) {
				var menu = $menu.parents(['ul.', c.menuClass, ':first'].join(''))[0];
				sf.op = sf.o[menu.serial];
				return menu;
			},
			addArrow = function($a) { $a.addClass(c.anchorClass).append($arrow.clone()); };

		return this.each(function() {
			var s = this.serial = sf.o.length;
			var o = $.extend({}, sf.defaults, op);
			o.$path = $('li.' + o.pathClass, this).slice(0, o.pathLevels).each(function() {
				$(this).addClass([o.hoverClass, c.bcClass].join(' '))
					.filter('li:has(ul)').removeClass(o.pathClass);
			});
			sf.o[s] = sf.op = o;

			$('li:has(ul)', this)[($.fn.hoverIntent && !o.disableHI) ? 'hoverIntent' : 'hover'](over, out).each(function() {
			})
			.not('.' + c.bcClass)
				.hideSuperfishUl();


			$('li li:has(ul)', this)[($.fn.hoverIntent && !o.disableHI) ? 'hoverIntent' : 'hover'](over, out).each(function() {
				if (o.autoArrows) addArrow($('>a:first-child', this));
			})
			.not('.' + c.bcClass)
				.hideSuperfishUl();


			var $a = $('a', this);
			$a.each(function(i) {
				var $li = $a.eq(i).parents('li');
				$a.eq(i).focus(function() { over.call($li); }).blur(function() { out.call($li); });
			});
			o.onInit.call(this);

		}).each(function() {
			var menuClasses = [c.menuClass];
			if (sf.op.dropShadows && !($.browser.msie && $.browser.version < 7)) menuClasses.push(c.shadowClass);
			$(this).addClass(menuClasses.join(' '));
		});
	};

	var sf = $.fn.superfish;
	sf.o = [];
	sf.op = {};
	sf.IE7fix = function() {
		var o = sf.op;
		if ($.browser.msie && $.browser.version > 6 && o.dropShadows && o.animation.opacity != undefined)
			this.toggleClass(sf.c.shadowClass + '-off');
	};
	sf.c = {
		bcClass: 'sf-breadcrumb',
		menuClass: 'sf-js-enabled',
		anchorClass: 'sf-with-ul',
		arrowClass: 'sf-sub-indicator',
		shadowClass: 'sf-shadow'
	};
	sf.defaults = {
		hoverClass: 'sfHover',
		pathClass: 'overideThisToUse',
		pathLevels: 1,
		delay: 100, /*800 = default */
		animation: { opacity: 'show' },
		speed: 'fast',
		autoArrows: true,
		dropShadows: true,
		disableHI: false, 	// true disables hoverIntent detection
		onInit: function() { }, // callback functions
		onBeforeShow: function() { },
		onShow: function() { },
		onHide: function() { }
	};
	$.fn.extend({
		hideSuperfishUl: function() {
			var o = sf.op,
				not = (o.retainPath === true) ? o.$path : '';
			o.retainPath = false;
			var $ul = $(['li.', o.hoverClass].join(''), this).add(this).not(not).removeClass(o.hoverClass)
					.find('>ul').hide().css('visibility', 'hidden');
			o.onHide.call($ul);
			return this;
		},
		showSuperfishUl: function() {
			var o = sf.op,
				sh = sf.c.shadowClass + '-off',
				$ul = this.addClass(o.hoverClass)
					.find('>ul:hidden').css('visibility', 'visible');
			sf.IE7fix.call($ul);
			o.onBeforeShow.call($ul);
			$ul.animate(o.animation, o.speed, function() { sf.IE7fix.call($ul); o.onShow.call($ul); });
			return this;
		}
	});

})(jQuery);



//////////////////////////////////////////////////////////////////////////////////////////////////////////
// KLASSE LYONESS FILEUPLOAD DIALOG
// Erzeugt aus einen input type="file" ein schönes Konstrukt das mit CSS belegt werden kann.
//////////////////////////////////////////////////////////////////////////////////////////////////////////
(function($) {

	$.fn.lyofileupload = function(defaults) {

		var self = this;

		/* übernimmt die settings in das eingabefeld (oder anderes objekt)
		** und erstellt den kern der komponente mit oder ohne jquery ui - datepicker
		*/
		this._attach_defaults = function(obj, attdefaults) {

			var fileuploaddefaults = {
				EnableInputFieldClick: true
			};

			if (attdefaults != null) $.extend(fileuploaddefaults, attdefaults);
			$(obj).context.lyofileuploaddefaults = fileuploaddefaults;
		};

		/* Schaltet den eigentlichen FileUpload Dialog invisible und baut ein
		** schönes CSS formatierbares Konstrukt herum
		*/
		this._build_new = function(obj) {

			$(obj).css("opacity", "0.5");

			$(obj).parent().html(
				"<div style='position:absolute;'>" +
				"<div style='z-index:1; position:absolute; top: 0; left: 0;'>" +
				"	<table cellpadding='0' cellspacing='0' border='0' class='lyofileupload'>" +
				"		<tr>" +
				"			<td><input type='text' id='" + $(obj).attr('id') + "_input_field' name='" + $(obj).attr('name') + "_input_field' /></td>" +
				"			<td><input id='" + $(obj).attr('id') + '_browse_button' + "' type='button' value='Browse' /></td>" +
				"		</tr>" +
				"	</table>" +
				"</div>" +
				"<div  style='z-index:100; position:absolute; top:0; left: 0;' id='" + $(obj).attr('id') + "_original_field_div'></div>" +
				"</div>"
			);

			$('#' + $(obj).attr('id') + '_original_field_div').append($(obj));


			$(obj).context.lyofileupload_do_original_object_handling = function(origobj) {
				alert($(obj));
			}

			// Callback für Browse Button
			$('#' + $(obj).attr('id') + '_browse_button').click(function() {
				$(obj).context.lyofileupload_do_original_object_handling(obj);
			});

			// Browsen beim Klick auf Eingabefeld
			if ($(obj).context.lyofileuploaddefaults.EnableInputFieldClick) {
				$('#' + $(obj).attr('id') + '_input_field').click(function() {
					$(obj).context.lyofileupload_do_original_object_handling(obj);
				});
			}
		}



		/* die einzelnen funktionen auf die entsprechenden edit fields
		** legen. (anhand einer klasse, einer id usw.)
		*/
		this.each(function(i, obj) {

			self._attach_defaults(obj, defaults);
			self._build_new(obj);
		});
	}

})(jQuery);

//////////////////////////////////////////////////////////////////////////////////////////////////////////
// KLASSE CUSTOMERIDFORMATTER
// Lyoness KundenID Formatierung
// Formatiert eine KundenID nach Eingabe beim Verlassen des Eingabefeldes
//
// Beispiele für Eingabeformate:
//
//		043.000.000.123
//		 43.000.000.123
//			043.000.123
//			 43.000.123
//		   043000000123
//			43000000123
//			  043000123
//			   43000123
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////


(function($) {

	$.fn.lyocustomeridformat = function(defaults) {

		var self = this;


		/* OnBlur event hinzufügen
		*/
		this._attach_on_blur = function(obj) {

			obj._original_on_blur_fct = obj.onblur;

			// neue, überschriebene Funktion
			obj.onblur = function(event) {

				if (obj.value != null) {
					var vNewValue = toCustomerNumber(obj.value);
					obj.value = vNewValue;
				}

				// original on blur wieder aufrufen
				if (obj._original_on_blur_fct != null) {
					obj._original_on_blur_fct();
				}
			}
		}


		/* übernimmt die settings in das eingabefeld (oder anderes objekt)
		** und erstellt den kern der komponente mit oder ohne jquery ui - datepicker
		*/
		this._attach_defaults = function(obj, attdefaults) {

			// Defaults überschreiben
			for (var attrName in attdefaults) {
				obj[attrName] = attdefaults[attrName];
			}

			this._attach_on_blur(obj);
		};

		/* die einzelnen funktionen auf die entsprechenden edit fields
		** legen. (anhand einer klasse, einer id usw.)
		*/
		this.each(function(i, obj) {
			self._attach_defaults(obj, defaults);
		});
	}

})(jQuery);


//////////////////////////////////////////////////////////////////////////////////////////////////////////
// KLASSE DEALERIDFORMATTER
// Lyoness HändlerID Formatierung
// Formatiert eine HändlerID nach Eingabe beim Verlassen des Eingabefeldes
//
// Beispiele für Eingabeformate:
//
//		Zur Zeit ist nur eine Eingabe Möglich (z.B. 10109)
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////

(function($) {

	$.fn.lyodealeridformat = function(defaults) {

		var self = this;


		/* OnBlur event hinzufügen
		*/
		this._attach_on_blur = function(obj) {

			obj._original_on_blur_fct = obj.onblur;

			// neue, überschriebene Funktion
			obj.onblur = function(event) {

				if (obj.value != null) {

					var vOrigValue = NumTrim(obj.value);
					obj.value = vOrigValue;
				}

				// original on blur wieder aufrufen
				if (obj._original_on_blur_fct != null) {
					obj._original_on_blur_fct();
				}
			}
		}


		/* übernimmt die settings in das eingabefeld (oder anderes objekt)
		** und erstellt den kern der komponente mit oder ohne jquery ui - datepicker
		*/
		this._attach_defaults = function(obj, attdefaults) {

			// Defaults überschreiben
			for (var attrName in attdefaults) {
				obj[attrName] = attdefaults[attrName];
			}

			this._attach_on_blur(obj);
		};

		/* die einzelnen funktionen auf die entsprechenden edit fields
		** legen. (anhand einer klasse, einer id usw.)
		*/
		this.each(function(i, obj) {
			self._attach_defaults(obj, defaults);
		});
	}

})(jQuery);





//////////////////////////////////////////////////////////////////////////////////////////////////////////
// KLASSE FIELDRUBBER
// Löscht den Wert aus allen übergebenen Eingabefelder
//////////////////////////////////////////////////////////////////////////////////////////////////////////

LyoFieldRubber = function() {
	this.self = this;
}

LyoFieldRubber.prototype.Clean = function(fields) {

	if (fields == null || fields == undefined) return;

	var vIds = fields.split(",");
	if (vIds != null && vIds.length > 0) {

		for (var cnt = 0; cnt < vIds.length; cnt++) {
			var aktfield = $('#' + (Trim(vIds[cnt], " ")));
			if (aktfield.attr('name') == '__RequestVerificationToken') continue;
			if (!IsNullOrEmpty(aktfield.val())) aktfield.val('');

			// Brauchen wir für die onChangeBlur Felder die eventuell auch geleert werden.
			if (aktfield[0] != null && aktfield[0] != undefined && aktfield[0].SetOldValue != null && aktfield[0].SetOldValue != undefined) {
				aktfield[0].SetOldValue('');
			}
		}
	}
}

LyoFieldRubber.prototype.CleanArea = function(areaid, ignorefieldids) {

	var area = document.getElementById(areaid);
	if (area == null) return;

	var igfields = null;
	if (ignorefieldids != null) {
		igfields = ignorefieldids.split(",");
	}

	var aInputs = $(area).find('input,textarea,select,radio');

	var ignore = false;
	for (var i in aInputs) {

		if (typeof (aInputs[parseInt(i)]) != 'undefined') {

			ignore = false;

			if (igfields != null) {
				for (var idx = 0; idx < igfields.length; idx++) {
					//alert(aInputs[parseInt(i)].id + ' ' + Trim(igfields[idx], " "));
					if (aInputs[parseInt(i)].id == Trim(igfields[idx], " ") || aInputs[parseInt(i)].name == '__RequestVerificationToken') {
						ignore = true;
						break;
					}
				}
				if (ignore == true) continue;
			}
			if (aInputs[parseInt(i)].type != "submit" && aInputs[parseInt(i)].type != "button" &&
				aInputs[parseInt(i)].type != "radio" && aInputs[parseInt(i)].type != "checkbox") {

				aInputs[parseInt(i)].value = "";

				// Brauchen wir für die onChangeBlur Felder die eventuell auch geleert werden.
				if (aInputs[parseInt(i)] != null && aInputs[parseInt(i)] != undefined && aInputs[parseInt(i)].SetOldValue != null && aInputs[parseInt(i)].SetOldValue != undefined) {
					aInputs[parseInt(i)].SetOldValue('');
				}
			}

			if (aInputs[parseInt(i)].type == "radio" || aInputs[parseInt(i)].type == "checkbox") aInputs[parseInt(i)].checked = "";
		}
	}
}

LyoFieldRubber.prototype.CleanForm = function(formid, ignorefieldids) {

	var form = document.getElementById(formid);
	if (form == null) return;

	var igfields = null;
	if (ignorefieldids != null) {
		igfields = ignorefieldids.split(",");
	}

	var ignore = false;
	for (var i = 0; i < form.elements.length; i++) {

		ignore = false;
		if (igfields != null) {
			for (var idx = 0; idx < igfields.length; idx++) {
				if (form.elements[i].id == Trim(igfields[idx])) {
					ignore = true;
					break;
				}
			}
			if (ignore == true) continue;
		}
		if (form.elements[i].type != "submit" && form.elements[i].type != "button" &&
			form.elements[i].type != "radio" && form.elements[i].type != "checkbox") {

			form.elements[i].value = "";

			// Brauchen wir für die onChangeBlur Felder die eventuell auch geleert werden.
			if (form.elements[i] != null && form.elements[i] != undefined && form.elements[i].SetOldValue != null && form.elements[i].SetOldValue != undefined) {
				form.elements[i].SetOldValue('');
			}
		}

		if (form.elements[i].type == "radio" || form.elements[i].type == "checkbox") form.elements[i].checked = "";
	}
}

var FieldRubber = new LyoFieldRubber();



//////////////////////////////////////////////////////////////////////////////////////////////////////////
// KLASSE onchangeblur
// funktion wird aufgerufen wenn sich der Wert im Eingabefeld verändert hat, 
// und onblur aufgerufen wird.
//////////////////////////////////////////////////////////////////////////////////////////////////////////

(function($) {

	$.fn.onchangeblur = function(fct, ignoreemptynow) {


		var self = this;

		// Startet das Handling
		this.doHandling = function(self, obj) {

			if (fct == null || fct == undefined) {
				$(obj).blur();
				return;
			}

			obj._old_onchangeblur_onblur = obj.onblur;

			$(obj).blur(

				function() {

					// Alte onblur wieder aufrufen
					if (obj._old_onchangeblur_onblur != null) obj._old_onchangeblur_onblur();

					var ignorecheck = false;
					if (ignoreemptynow == true && IsNullOrEmpty(obj.value)) {
						ignorecheck = true;
					}

					if (ignorecheck == false) {

						if (obj._onchangeblur_old_value == null || obj._onchangeblur_old_value == undefined) obj._onchangeblur_old_value = "";

						if (obj.value != obj._onchangeblur_old_value) {
							if (fct != null) fct();
						}
					}

					obj._onchangeblur_old_value = obj.value;
				}
			);

			obj.SetOldValue = function(valuein) {

				obj._onchangeblur_old_value = valuein;
			}
		}

		/* die einzelnen funktionen auf die entsprechenden edit fields
		** legen. (anhand einer klasse, einer id usw.)
		*/
		this.each(function(i, obj) {
			self.doHandling(self, obj);
		});
	}

})(jQuery);


//////////////////////////////////////////////////////////////////////////////////////////////////////////
// LyoPleaseWaitBox
// Bitte warten Box neben Mauszeiger
/////////////////////////////////////////////////////////////////////////////////////////////////////////


PleaseWaitBox = function() {
PleaseWaitBox.PleaseWaitDivName = '__pleaseWaitBox__';
	PleaseWaitBox.PleaseWaitShown = '__isShown__';
}
PleaseWaitBox.prototype._FollowCursor = function(e) {

	var pwBox = document.getElementById(PleaseWaitBox.PleaseWaitDivName);

	if ($("div#" + PleaseWaitBox.PleaseWaitDivName).data(PleaseWaitBox.PleaseWaitShown) == 1) {

		pwBox.style.top = e.pageY + 'px';
		pwBox.style.left = e.pageX + 5 + 'px'
			
		if (pwBox.style.display != 'block') {

			pwBox.style.display = 'block';
		}
	} else {
		if (pwBox.style.display != 'none') pwBox.style.display = 'none';
	}

	//$("#tt").text($("div#" + PleaseWaitBox.PleaseWaitDivName).data(PleaseWaitBox.PleaseWaitShown));
}
PleaseWaitBox.prototype._ShowCursor = function() {
	$("div#" + PleaseWaitBox.PleaseWaitDivName).data(PleaseWaitBox.PleaseWaitShown, 1);
	var pwBox = document.getElementById(PleaseWaitBox.PleaseWaitDivName);
	pwBox.style.display = 'block';

}
PleaseWaitBox.prototype._HideCursor = function() {
	$("div#" + PleaseWaitBox.PleaseWaitDivName).data(PleaseWaitBox.PleaseWaitShown, 0);
	var pwBox = document.getElementById(PleaseWaitBox.PleaseWaitDivName);
	pwBox.style.display = 'none';

}

PleaseWaitBox.prototype.Init = function() {
	// Please Wait DIV
	var pleaseWaitDiv = document.createElement('div');
	pleaseWaitDiv.style.display = "none";
	pleaseWaitDiv.className = "pleasewaiticon";
	pleaseWaitDiv.style.position = 'absolute'; 
	pleaseWaitDiv.id = PleaseWaitBox.PleaseWaitDivName;
	//pleaseWaitDiv.style.border = "1px solid red";
	pleaseWaitDiv.style.zIndex = 9999;

	document.body.appendChild(pleaseWaitDiv);
	// Please Wait DIV Text
	var pleaseWaitDivText = document.createElement('div');
	pleaseWaitDivText.style.marginLeft = "20px";
	pleaseWaitDivText.innerHTML = TransByMember("PleaseWait", "JS.Global");
	pleaseWaitDiv.appendChild(pleaseWaitDivText);

	$(document).bind("mousemove", this._FollowCursor);

	$(document).bind("mouseleave", function() {
		if ($("div#" + PleaseWaitBox.PleaseWaitDivName).data(PleaseWaitBox.PleaseWaitShown) == 1)
			document.getElementById(PleaseWaitBox.PleaseWaitDivName).style.display = 'none';
	});
	$(document).bind("mouseenter", function() {
		if ($("div#" + PleaseWaitBox.PleaseWaitDivName).data(PleaseWaitBox.PleaseWaitShown) == 1)
			document.getElementById(PleaseWaitBox.PleaseWaitDivName).style.display = 'block';
	});
}


var __PleaseWaitBox = new PleaseWaitBox();

$(document).ready(function() {
	__PleaseWaitBox.Init();
});



$.showPleaseWaitBox = function() {
	__PleaseWaitBox._ShowCursor();
}
$.hidePleaseWaitBox = function() {
	__PleaseWaitBox._HideCursor();
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Ruft eine einfache Serverseitige Funktion via Ajax auf und schreibt den returnierten Wert in das
// angegebene Feld
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

function lyonessAjaxCallValueFiller(fieldid, ajaxurl) {

	$.ajax({
		url: ajaxurl,
		cache: false,
		type: 'GET',
		async: true,
		dataType: 'text',
		success: function(response) {
			$('#' + fieldid).attr('value', response);
		},
		error: function(xhr, ajaxOptions, thrownError) {
			LyoErrorHandler.SendAjaxError(xhr, ajaxOptions, thrownError);
		}
	});
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkt sich Formular eingabe Felder
// Es kann somit geprüft werden ob sich beim Verlassen Felder geändert haben ohne zu speichern.
//
// Beispiel:
//		FormFieldReminder.TakeShnapshot('meineformularid');
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

_FormFieldReminder = function() {

	this.self = this;
	this.myForm = null;

	this.alSavedElements = new Array();
	this.bCheckForm = true;

	// Speichert die Formularelemente in das Array
	this.saveFormElements = function(self, form) {

		for (var i = 0; i < form.elements.length; i++) {
			if ("select-one" == form.elements[i].type) {
				self.alSavedElements.push(form.elements[i].selectedIndex);
				continue;
			}
			if ("radio" == form.elements[i].type || "checkbox" == form.elements[i].type) {
				self.alSavedElements.push(form.elements[i].checked);
				continue;
			}
			self.alSavedElements.push(form.elements[i].value);
		}
	}


	this.isFormChanged = function(self, form) {

		//alert(form.elements.length + "##" + self.alSavedElements.length);

		var bChanged = false;
		if (form.elements.length != self.alSavedElements.length) {
			bChanged = true;
			return bChanged;
		}


		for (var i = 0; i < form.elements.length; i++) {
			if ("submit" != form.elements[i].type && "button" != form.elements[i].type && "reset" != form.elements[i].type && "hidden" != form.elements[i].type && "radio" != form.elements[i].type && "checkbox" != form.elements[i].type && "select-one" != form.elements[i].type && form.elements[i].value != self.alSavedElements[i]) {
				//alert("#1" + form.elements[i].type + " --> " + form.elements[i].id + " --> old: " + self.alSavedElements[i] + " --> new: " + self.alSavedElements[i].value);
				bChanged = true;
				break;
			}
			if ("select-one" == form.elements[i].type && form.elements[i].selectedIndex != self.alSavedElements[i]) {
				//alert("#2" + form.elements[i].type);
				bChanged = true;
				break;
			}
			if (("radio" == form.elements[i].type || "checkbox" == form.elements[i].type) && form.elements[i].checked != self.alSavedElements[i]) {
				//alert("#3" + form.elements[i].type);
				bChanged = true;
				break;
			}
		}

		return bChanged;
	}


	this.checkFormOnUnload = function(self, form) {

		var bFormStatus = self.isFormChanged(self, form);

		if (self.bCheckForm && bFormStatus) {
			return true;
		}
		return false;
	}
}

_FormFieldReminder.prototype.TakeShnapshot = function(formId) {
	this.myForm = document.getElementById(formId);
	this.saveFormElements(this, this.myForm);
}

_FormFieldReminder.prototype.CheckChanges = function() {
	if (this.myForm == null) { alert('NO FORMULAR DEFINED!') };
	return this.checkFormOnUnload(this, this.myForm);
}

var FormFieldReminder = new _FormFieldReminder();




//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Merkt sich Formular eingabe Felder
// Es kann somit geprüft werden ob sich beim Verlassen Felder geändert haben ohne zu speichern.
//
// Beispiel:
//		FormFieldReminder.TakeShnapshot('meineformularid');
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
_FieldChecker = function(defaults) {

	this.self = this;
	this.defaults = defaults;

	this.parseIgnoreFields = function(ignorefieldids) {

		var igfields = null;
		if (ignorefieldids != null) {
			igfields = ignorefieldids.split(",");
		}

		return igfields;
	}
}

_FieldChecker.prototype.CheckAllEmpty = function(containerelementid, ignorefieldids) {


	var aInputs = $('#' + containerelementid).find('input[type!=hidden]');
	var igfarray = this.parseIgnoreFields(ignorefieldids);

	var ignorefield;

	for (var i in aInputs) {

		ignorefield = false;

		if (typeof (aInputs[parseInt(i)]) != 'undefined') {
			if (igfarray != null) {
				for (var igfldidx = 0; igfldidx < igfarray.length; igfldidx++) {
					if (Trim(igfarray[igfldidx], " ") == aInputs[parseInt(i)].id) {
						ignorefield = true;
						break;
					}
				}
			}

			if (ignorefield == true) continue;

			var val = aInputs[parseInt(i)].value
			if (val != null && val != undefined && val != "") {
				return false;
			}
		}
	}

	return true;
}

var FieldChecker = new _FieldChecker(null);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Session & Cookiemanagement
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
var Session = {
	SessionID: null,
	Cookies: {
		IsHistoryCookieName: "ishistory",

		Set: function(name, value) {
			$.cookie(Session.SessionID + '_' + name, value);
		},

		SetHistoryCookie: function(state) {
			this.Set(this.IsHistoryCookieName, state);
		},

		IsHistory: function() {
			if (this.Get(this.IsHistoryCookieName) == "true") {
				return true;
			}
			else {
				return false;
			}
		},

		Get: function(name) {
			return $.cookie(Session.SessionID + '_' + name);
		},

		Delete: function(name) {
			$.cookie(Session.SessionID + '_' + name, null);
		}
	}
};