//--------------------------------------------------------------------------------------------------
/*
	String Prototypen
*/
//--------------------------------------------------------------------------------------------------
/**
 * Prototyp schließt einen String in zwei Unicode Zeichen ein, in der Regel ""
 * @param {Integer} intCharNum
 * @param {String} strEntry
 */
String.prototype.EnClose = function( intCharNum )
	{ return String.fromCharCode( intCharNum ) + this + String.fromCharCode( intCharNum ); }

/**
 * Prototyp tauscht Zeichen aus den TS Dokumentennamen, zur Umwandlung in Pfadangaben
 * @param {Object} strDocumentName
 */
String.prototype.FormatDocumentName = function()
	{
		var strNewDocumentName = this;
		if( strNewDocumentName.indexOf(".") > -1 ) { strNewDocumentName = strNewDocumentName.replace( /\./g, "_"); }
		if( strNewDocumentName.indexOf("/") > -1 ) { strNewDocumentName = strNewDocumentName.replace( /\//g, "_"); }
		return strNewDocumentName;
	}

/**
 * Stellt die Methode Contains zur Verfügung.
 * @param {Object} strSearch
 */
String.prototype.Contains = function( strSearch )
	{
		var strTemp = this;
		var boolResult = false;
		
		if( strTemp.indexOf( strSearch ) != -1 ) { boolResult = true; }
		return boolResult;
	}

/*
	Die Methode entfernt Zeichen aus einem String, die in einem Array übergeben werden.
	Damit kann eine Liste einzelner Zeichen oder ganzer Strings aus dem Quellstring entfernt werden.
*/
String.prototype.RemoveStrings = function( collChars )
	{
		var strSource = new String(this);
		
		for( var numCounter = 0; numCounter < collChars.length; numCounter ++ )
			{
				var strChar = collChars[numCounter];
				if( strSource.Contains( strChar ) )
					{ strSource = strSource.replace(strChar, ""); }
			}
		
		return strSource;
	}

/*
	Die Methode erzeugt aus einem String, der die Quellenangabe eines Bildes
	enthält, ein Tag für das BackgroundImage Style Tag eines Elements. Damit kann ich auf
	zwischen DOM und Style Operationen wechseln.
*/
String.prototype.GenerateBackgroundImageStyleTag = function()
	{
		var strSource = new String(this);
		return "url(" + strSource + ")";
	}

/*
	Die Methode extrahiert den Index aus der ID eines Elements.
	Mit dem Index kann zum Beispiel der TabManager die Styleangaben aus einem Array lesen.
*/
String.prototype.GetIndexFromID = function()
	{
		var strName = this;
		var arrStrings = strName.split( "_" );
		var strIndex = arrStrings[arrStrings.length-1];
		return strIndex * 1;		
	}
//---------------------------------------------------------------------------------------------------------
/*
	Array Prototypen 
*/
//--------------------------------------------------------------------------------------------------
/**
 * Prototyp durchsucht ein Array nach eine String und liefert Bool zurück
 * @param {Array} arrSearch
 * @param {String} strMatch
 */
Array.prototype.SearchArray = function( strMatch )
	{
		var boolFound = false;
		for( var iter = 0; iter < this.length; iter ++ )
			{ 
				var strSearch = this[iter];
				if( strSearch.indexOf( strMatch ) != -1 ) { boolFound = true; }
				if ( boolFound ) break
			}
		return boolFound;
	}

/**
 * Methode vergleicht ein Array, mit einem zweiten Array und liefert True, wenn beide den gleichn Inhalt haben
 * @param {Object} arrCompare
 */
Array.prototype.CheckIfIdentically = function( arrCompare )
	{
		var boolIdentically = true;
		if( this.length != arrCompare.length ) { boolIdentically = false; }
		return boolIdentically;
	}

/**
 * Prototyp erzeugt einen String aus einem Array
 * @param {Array} arrList Array, aus dem der String erstellt werden soll
 * @param {String} strPre Einführender String für eine Headerzeile
 * @param {String} stringSep Trennzeichen oder Zeilenumbruch
 */
Array.prototype.StringFromList = function( strPre, strSep )
	{
		var strOutput = new String();
		strOutput += strPre
		for( var iter = 0; iter < this.length; iter ++ )
			{ 
				if (iter == 0) { strOutput += this[iter]; }
				else { strOutput += strSep + this[iter]; }
			}
		return strOutput;
	}

/**
 * Prototyp, h�ngt ein Array an ein bestehendes Array an
 * method
 * @param {Object} arrToAppend
 */
Array.prototype.AppendArray = function( arrToAppend )
	{
		var maxLength = arrToAppend.length;
		for( var iter = 0; iter < arrToAppend.length; iter ++ )
			{ this[this.length] = arrToAppend[iter]; }
	}

/*Fügt ein neues Arrayelement an das Array an.*/
Array.prototype.Append = function( objAppend )
	{ this[this.length] = objAppend; }


/**
 * Stellt ein Assoziatives Array bereit
 * @classDescription 
 * @constructor
 */
function ProArray()
	{
		var arrObjects = new Array();
		var arrNames = new Array();
		
		/**
		 * Fügt ein Object mit Assiziation in die Struktur ein
		 * @method Append()
		 * @param {String} Name des Elements, dass eingefügt wird
		 * @param {Object} Objekt, das eingefügt wird
		 */
		this.Append = function( strElementName, objElement )
			{
				if( strElementName != null && objElement != null )
					{
						arrNames[arrNames.length] = strElementName;
						arrObjects[arrObjects.length] = objElement;
					}
			}
		
		/**
		 * Methode hängt ein Proarray an das bestehende Array an
		 * @method AppendProArray()
		 * @param {Object} arrNewList
		 */
		this.AppendProArray = function( arrNewList )
			{
				for( var iter = 0; iter < arrNewList.GetLength(); iter ++ )
					{
						var strElementName = arrNewList.GetNameByIndex( iter );
						var objObject = arrNewList.GetObjectByName( strElementName );
						this.Append( strElementName, objObject );
					}
			}
		
		/**
		 * Entfernt ein Object, an Hand der Assoziation
		 * @method Remove()
		 * @param {String} Name des Elements, das entfernt werden soll
		 */
		this.Remove = function( strElementName )
			{
				var intIndex = GetIndex( strElementName );
				if( intIndex > -1 )
					{
						arrObjects.splice( intIndex, intIndex );
						arrNames.splice( intIndex, intIndex );
					}
			}
		
		/**
		 * Liest ein Object an Hand der Assiziation
		 * @Method GetObjectByName()
		 * @param {String} Name des Elements, dessen Objekt gelesen werden soll
		 */
		this.GetObjectByName = function( strElementName )
			 {
			 	var objReturn;
				var intIndex = GetIndexByName( strElementName );
				
				if( intIndex > -1 ) { objReturn = arrObjects[intIndex]; }
				else { objReturn = false; }
				return objReturn;
			 }
		
		/**
		 * Liest ein Object an Hand des Index
		 * @method GetObjectByIndex()
		 * @param {Integer} intIndex
		 */
		this.GetObjectByIndex = function( intIndex ) { return arrObjects[ intIndex ]; }
		
		/**
		 * Methode schreibt ein verändertes Objekt zurück ins Array
		 * @method RefreshObjectByIndex
		 * @param {Object} refObject
		 * @param {Object} intIndex
		 */
		this.RefreshObjectByIndex = function( refObject, intIndex ) { arrObjects[ intIndex ] = refObject; }
		
		/**
		 * Liest den Namen, an Hand eines Index
		 * @method GetNameByIndex()
		 * @param {Object} intIndex
		 */
		this.GetNameByIndex = function( intIndex ) { return arrNames[ intIndex ]; }
		
		/**
		 * Ermittelt den Index eines Objekts, an Hand der Assoziation 
		 * @method GetIndexByName()
		 * @param {String} Name des Elements, dessen Index ermittelt werden soll
		 */	
		function GetIndexByName( strElementName )
			{
				var intIndex = -1;
				for( var iter = 0; iter < arrObjects.length; iter ++ )
					{ if( arrNames[iter] == strElementName ) { intIndex = iter; } }
				return intIndex;
			}
		
		/**
		 * Liest die Anzahl der Elemente aus
		 * @method GetLength()
		 */
		this.GetLength = function() 
			{ 
				try
					{
						var intLength = arrObjects.length;
						return intLength;
					}
				catch( e )
					{ return 0; }
			}
		
		/**
		 * Liefert einen formatierten String, der allen Assiziationen des Arrays enthält
		 * @method GetListByName()
		 */
		this.GetListByName = function()
			{ 
				var strOutput = arrNames.StringFromList( ""," - " );
				return strOutput;
			}
		
		/**
		 * Methode liefert das ARray mit den Namen nach außen
		 * @method GetNames()
		 */
		this.GetNames = function() { return arrNames; }
		
		/**
		 * Methode liefert das Array mit den Objekten nach außen
		 * @method GetObjects()
		 */
		this.GetObjects = function() { return arrObjects; }
		
		/**
		 * Methode löscht beide Arrays
		 * @method Clear
		 */
		this.Clear = function()
			{
				arrObjects.length = 0;
				arrNames.length = 0;
			}
		
		/**
		 * Methode vergleicht das übergebene Array, mit Inhalt des aufrufenden und liefert
		 * die nicht vorhandenen Elemente als ProArray zurück
		 * @method Compare
		 * @param {Object} objCompareArray
		 */
		this.Compare = function( objCompareArray )
			{
				var objTrashArray = new ProArray();
				var strCompare;
				for( intCounter = 0; intCounter < objCompareArray.GetLength; intCounter ++ )
					{
						strCompare = objCompareArray.GetNameByIndex( intCounter );
						if( arrNames.SearchArray( strCompare ) == false )
							{ objTrashArray.Append(strCompare, objCompareArray.GetObjectByIndex( intCounter ) ) }
					}
				return objTrashArray;
			}
	}