//	------------------------------------------------------------------------------------------
//	------------------------------------------------------------------------------------------
//
//	extended javascript-api-methods		:
//	* jsApi-extension-name / file-name	: "jsApi.NumberString.flexibleConverting.light.js"
//	* original download-location		: "http://www.pseliger.de/jsExtendedApi/"
//
//	last revision		: march 2003	- code of all methods, I belief, is on its edge now;
//
function forceToNumber() {[native code]}

String.prototype.forceToNumber = forceToNumber;	// - wird nur auf Strings angewandt - versucht, einen formatierten dezimalzahl-string in einen zahlenwert umzuwandeln	 - liefert diesen wert oder NaN zurueck;
												// - to be used with Strings only	- tries to convert a formatted string that represents a decimal-number into a number - returns this value or returns NaN;
//
//	------------------------------------------------------------------------------------------
//	------------------------------------------------------------------------------------------


//	------------------------------------------------------------------------------------------
//	------------------------------------------------------------------------------------------
//
//	extended javascript-api-methods		:
//	* jsApi-extension-name / file-name	: "jsApi.ObjectArray.clone.js"
//	* original download-location		: "http://www.pseliger.de/jsExtendedApi/"
//
//	last revision		: april 28-2003 - methods(prototype-functions), global and anonymous
//										  functions now get identified by the "clone"-method;
//										- functions get assigned if they exist at clone-time
//										  and also have  a valid  name that is understood by
//										  the "window"-instance that runs all this stuff;
//										- functions need to be cloned if they got constructed
//										  by this term "new Function(arg1,arg2, .. ,fctBody)"
//										  since their names remain hidden to the js-engine;
//										- functions also get cloned  if assigned to a variable
//										  by the keyword "function()" only since the variables
//										  name remains hidden to the js-engine in this case as
//										  well;
//										! object-method "getConstructorName()" was born !
//
//	first revision		: april 23-2003 - code is shorter now since arrays get cloned by the
//										  same method that already does handle objects - why:
//										  * "Array" just is a development/offspring of "Object";
//										  * arrays differ from objects only by specific arguments ("length") and methods ("push()", "pop()", "join()", ...);
//										  * arrays vary in their appearance  -  "pure": reference by integerTypeIndex - "associative": reference by stringTypeIndex (this variation is almost object-like but also features all array-specifications) - "mixed": this variation is the most complex one;
//										  * myArray["someName"] == myArray.someName (common knowledge - ok) - but: myArray[0] == myArray["0"] is also true (I never did think of it and never tried this so far);
//										  * arrays can be uniquely identified from objects by their constructors only ([array].constructor.toString() = "function Array() {[native code]}" vs. [object].constructor.toString() = "function Object() {[native code]}");
//										  ( now it is much more obvious why both arrays and objects return "object" when called with the operator "typeof"; )
//	first public release: april 17-2003	- clones every js-object whose constructor is "array"
//										  or "object" regardless of its level of complexity;
//
function clone() {[native code]}
	/*	(01)	-	EN: applies to every js-object that features a constructor	- ["Boolean()", "Number()", "String()", "Array()", "Function()", "RegExp()", "Date()"];
					DE: ist auf jedes js-objekt mit einem konstruktor anwendbar	- ["Boolean()", "Number()", "String()", "Array()", "Function()", "RegExp()", "Date()"];
		(02)	-	EN: an optional integer-type parameter >= 1 is allowed that represents the limit of the depth an objects will be duplicated to - without or with nonsense parameters the method always returns a full clone;
					DE: ein optionaler parameter vom typ "integer", welcher mindestens 1 sein muss ist erlaubt - er markiert die tiefe, bis zu welcher ein objekt dupliziert wird - ohne parameter oder bei sinnlosen angaben liefert die methode stets eine vollstaendige kopie des objekts zurueck;
		(03)	-	EN: object-types get cloned RECURSIVELY;
					DE: object-typen werden REKURSIV geklont;
		(04)	-	EN: if functions can't be referenced they will be duplicated;
					DE: falls funktionen nicht referenzierbar sind, werden diese dupliziert;
		(05)	-	EN: primitive types simply get assigned;
					DE: primitive typen werden einfach zugewiesen;
		(06)	-	EN: leaves all prototype-properties untouched  -  "clone" for example already is a prototype of "Object" and therefore doesn't need to be duplicated anymore;
					DE: prototyp-eigenschaften werden uebergangen  -  "clone" z.b. ist schon ein prototyp von "Object" und muss deshalb nicht noch einmal dupliziert werden;

		[ps]	-	no idea how to avoid using the evil "eval"-operator;
				-	the problem is the unknown number of potential arguments;
				-	every function has limited arguments, but how to transform this fact into a solution that uses the "Function"-constructor, that is short and elegant as well and that doesn't endanger the 100%-duplication-ability of the "clone"-method ???
	*/
Object.prototype.clone = clone;

function getConstructorName() {[native code]}
	/*	(01)	-	EN: returns the name of an objects constructor (like "className");
					DE: liefert den namen des objekt-konstruktors zurueck (bei einem oo-klassenkonzept entspraeche dies dem klassennamen);
	*/
Object.prototype.getConstructorName = getConstructorName;
//
//	------------------------------------------------------------------------------------------
//	------------------------------------------------------------------------------------------


//	------------------------------------------------------------------------------------------
//	------------------------------------------------------------------------------------------
//
//	extended javascript-api-methods		:
//	* jsApi-extension-name / file-name	: "jsApi.ObjectArray.getScanLog.js"
//	* original download-location		: "http://www.pseliger.de/jsExtendedApi/"
//
//	first public release: april 2003	- scans every js-object whose constructor is "array"
//										  or "object" regardless of its level of complexity;
//										  returns a tab-formatted log; the log comments and
//										  visualizes the complete structure of the js-object;
//										  (properties: methods,arguments)
//
function arrayGetScanLog(tabulators) {[native code]}
	/*	(01)	-	EN:	array-types get scanned RECURSIVELY  - object-types get explored by the method "Object.getScanLog()";
					DE: array-typen werden REKURSIV gescannt - object-typen werden mit der methode "Object.getScanLog()" erforscht;
		(02)	-	EN: the bodies of function-types will not be logged;
					DE: die bodies der function-typen werden nicht mitgeschrieben;
		(03)	-	EN: information regarding primitive types simply gets logged;
					DE: informationen zu primitiven typen werden einfach mitgeschrieben;
	*/
function objectGetScanLog(tabulators) {[native code]}
	/*	(01)	-	EN: object-types get scanned RECURSIVELY  - array-types get explored by the method "Array.getScanLog()";
					DE: object-typen werden REKURSIV gescannt - array-typen werden mit der methode "Array.getScanLog()" erforscht;
		(02)	-	EN: the bodies of function-types will not be logged;
					DE: die bodies der function-typen werden nicht mitgeschrieben;
		(03)	-	EN: information regarding primitive types simply gets logged;
					DE: informationen zu primitiven typen werden einfach mitgeschrieben;
	*/
Array.prototype.getScanLog = arrayGetScanLog;
Object.prototype.getScanLog = objectGetScanLog;
//
	/*	[ps]	-	EN: if you are going to use the method "getScanLog()" make sure that method "getConstructorName()" is part of the jsApi as well - right now "getConstructorName()" is provided together with the jsApi-package "jsApi.ObjectArray.clone.js" - alternatively you could enable line [40] and line [44];
				-	DE: bevor auf die methode "getScanLog()" zurueckgegriffen wird, sollte sichergestellt sein, dass die methode "getConstructorName()" ebenfalls bestandteil der jsApi ist - im moment wird diese methode zusammen mit dem jsApi-package "jsApi.ObjectArray.clone.js" ausgeliefert - alternativ koennen die zeilen [40] und [44] auskommentiert werden;
	*/
//function getConstructorName() {var thisConstructor=((this.constructor)?(this.constructor):(null));if(thisConstructor){new RegExp("^\\s*function\\s+([a-zA-Z0-9_\\(]{2,}[^\\)])\\)","").exec(this.constructor.toString());return(RegExp.$1+")");}else{return null;}}
	/*	(01)	-	EN: returns the name of an objects constructor (like "className");
					DE: liefert den namen des objekt-konstruktors zurueck (bei einem oo-klassenkonzept entspraeche dies dem klassennamen);
	*/
//Object.prototype.getConstructorName = getConstructorName;
//
//	------------------------------------------------------------------------------------------
//	------------------------------------------------------------------------------------------


//	--------------------------------------------//
//	CONSTRUCTOR: "Table" ---------------begin---//


//	constructor	  : "Table"		- methods: "Table.isDefaultProperty()"		---//
//	subConstructor: "TableRow"	- methods: "TableRow.isDefaultProperty()"	---//
//	subConstructor: "TableCell"	- methods: "TableCell.isDefaultProperty()"	---//
function tableIsDefaultProperty(propertyName) {
	[native code]
}
function tableRowIsDefaultProperty(propertyName) {
	[native code]
}
function tableCellIsDefaultProperty(propertyName) {
	[native code]
}
	// hilfsfunktion - vereint den quellcode aller drei "Object.isDefaultProperty()"-methoden;
function tableGetPropertyStatus(tableObject,propertyName) {
	[native code]
}
//	subConstructor: "TableCell"	- methods: "TableCell.isDefaultProperty()"	---//
//	subConstructor: "TableRow"	- methods: "TableRow.isDefaultProperty()"	---//
//	constructor	  : "Table"		- methods: "Table.isDefaultProperty()"		---//


//	constructor	  : "Table"		- methods: "Table.refreshArguments()"		---//
//	subConstructor: "TableRow"	- methods: "TableRow.refreshArguments()"	---//
//	subConstructor: "TableCell"	- methods: "TableCell.refreshArguments()"	---//
function tableRefreshArguments() {
	[native code]
}
function tableRowRefreshArguments() {
	[native code]
}
function tableCellRefreshArguments() {
	[native code]
}
	// hilfsfunktion - vereint den quellcode aller drei "Object.refreshArguments()"-methoden;
function tableGetCurrentArguments(tableObject) {
	[native code]
}
//	subConstructor: "TableCell"	- methods: "TableCell.refreshArguments()"	---//
//	subConstructor: "TableRow"	- methods: "TableRow.refreshArguments()"	---//
//	constructor	  : "Table"		- methods: "Table.refreshArguments()"		---//


//	constructor	  : "Table"		- methods: "Table.removeArguments()"		---//
//	subConstructor: "TableRow"	- methods: "TableRow.removeArguments()"		---//
//	subConstructor: "TableCell"	- methods: "TableCell.removeArguments()"	---//
function tableRemoveArguments() {
	[native code]
}
function tableRowRemoveArguments() {
	[native code]
}
function tableCellRemoveArguments() {
	[native code]
}
//	subConstructor: "TableCell"	- methods: "TableCell.removeArguments()"	---//
//	subConstructor: "TableRow"	- methods: "TableRow.removeArguments()"		---//
//	constructor	  : "Table"		- methods: "Table.removeArguments()"		---//


//	constructor	  : "Table"		- methods: "Table.setArguments()"		---//
//	subConstructor: "TableRow"	- methods: "TableRow.setArguments()"	---//
//	subConstructor: "TableCell"	- methods: "TableCell.setArguments()"	---//
function tableSetArguments() {
	[native code]
}
function tableRowSetArguments() {
	[native code]
}
function tableCellSetArguments() {
	[native code]
}
//	subConstructor: "TableCell"	- methods: "TableCell.setArguments()"	---//
//	subConstructor: "TableRow"	- methods: "TableRow.setArguments()"	---//
//	constructor	  : "Table"		- methods: "Table.setArguments()"		---//

//	constructor: "Table" - method: "Table.getCode()"	---//
function tableGetCode() {
	[native code]
}
	// die hilfsfunktion "tableGetSpanMap" liefert die zweidimensionale boolsche "ansicht" der row- und colspan- gebiete eines jeden Table-objekts zurueck;
function tableGetSpanMap(tableObject) {
	[native code]
}
//	constructor: "Table" - method: "Table.getCode()"	---//


//	constructor: "Table" - method: "Table.insertRows()"	---//
//	constructor: "Table" - method: "Table.appendRows()"	---//
function tableInsertRows(rowsAmount,rowNumber) { // (amountOfRowsToBeInserted[mandatory], positionOfRowWhereInsertingShallTakePlace[default:alwaysFirstRow]);
	[native code]
}
function tableAppendRows(rowsAmount,rowNumber) { // (amountOfRowsToBeAppended[mandatory], positionOfRowWhereAppendingShallTakePlace[default:alwaysLastRow]);
	[native code]
}
	// hilfsfunktion fuer die methoden "Table.insertRows()" und "Table.appendRows()";
function tableAddRows(tableObject,rowsAmount,rowNumber,addMethod) { // (tableObjectItself, amountOfRowsToBeAdded, positionOfRowWhereAdditionShallTakePlace, keywordThatIdentifiesTheMethodOfAddition:["insert" or "append"]);
	[native code]
}
//	constructor: "Table" - method: "Table.appendRows()"	---//
//	constructor: "Table" - method: "Table.insertRows()"	---//


//	constructor: "Table" - method: "Table.insertCols()"	---//
//	constructor: "Table" - method: "Table.appendCols()"	---//
function tableInsertCols(colsAmount,colNumber) { // (amountOfColumnsToBeInserted[mandatory], positionOfColumnWhereInsertingShallTakePlace[default:alwaysFirstColumn]);
	[native code]
}
function tableAppendCols(colsAmount,colNumber) { // (amountOfColumnsToBeAppended[mandatory], positionOfColumnWhereAppendingShallTakePlace[default:alwaysLastColumn]);
	[native code]
}
	// hilfsfunktion fuer die methoden "Table.insertCols()" und "Table.appendCols()";
function tableAddCols(tableObject,colsAmount,colNumber,addMethod) { // (tableObjectItself, amountOfColumnsToBeAdded, positionOfColumnWhereAdditionShallTakePlace, keywordThatIdentifiesTheMethodOfAddition:["insert" or "append"]);
	[native code]
}
//	constructor: "Table" - method: "Table.appendCols()"	---//
//	constructor: "Table" - method: "Table.insertCols()"	---//


//	constructor: "Table" - method: "Table.removeRows()"	---//
function tableRemoveRows() {
	[native code]
}
//	constructor: "Table" - method: "Table.removeRows()"	---//


//	constructor: "Table" - method: "Table.removeCols()"	---//
function tableRemoveCols() {
	[native code]
}
//	constructor: "Table" - method: "Table.removeCols()"	---//


//	constructor: "Table" - properties: "Table.rows[].cols[]"	---//
//	CONSTRUCTOR: "TableRow" --------------begin---//
function TableRow(tableCols) {
//	die 3 standardmaessigen (und finalen) argumente eines "TableRow"-objekts;
	this.defaults = null; // liste alle per default definierten "TableRow"-argumente und -methoden;
	this.arguments = null; // liste aller defaultmaessigen und aller noch zu vereinbarenden "TableRow"-argumente (wird vor jeder tabellen-internen berechnung ueber die methode "TableRow.refreshArguments()" auf den neuesten stand gebracht);
	this.cols = null;
	this.defaults = tableGetDefaultProperties(this); // siehe erklaerungen zur hilfsfunktion "tableGetDefaultProperties" und kommentar 3 zeilen hoeher;
	this.cols = tableGetDefaultCols(tableCols); // siehe hilfsfunktion "tableGetDefaultCols";
}
// die 4 standardmaessigen (und finalen prototypen-)methoden eines "TableRow"-objekts;
TableRow.prototype.isDefaultProperty = tableRowIsDefaultProperty;
TableRow.prototype.refreshArguments = tableRowRefreshArguments;
TableRow.prototype.removeArguments = tableRowRemoveArguments;
TableRow.prototype.setArguments = tableRowSetArguments;
//	CONSTRUCTOR: "TableRow" --------------end-----//

//	CONSTRUCTOR: "TableCell" -------------begin---//
function TableCell() {
//	die 3 standardmaessigen (und finalen) argumente eines "TableCell"-objekts;
	this.defaults = null; // liste alle per default definierten "TableCell"-argumente und -methoden;
	this.arguments = null; // liste aller defaultmaessigen und aller noch zu vereinbarenden "TableCell"-argumente (wird vor jeder tabellen-internen berechnung ueber die methode "TableCell.refreshArguments()" auf den neuesten stand gebracht);
	this.value = " "; // default-zuweisung von "TableCell"-inhalten;
	this.defaults = tableGetDefaultProperties(this); // siehe erklaerungen zur hilfsfunktion "tableGetDefaultProperties" und kommentar 3 zeilen hoeher;
}
// die 4 standardmaessigen (und finalen prototypen-)methoden eines "TableCell"-objekts;
TableCell.prototype.isDefaultProperty = tableCellIsDefaultProperty;
TableCell.prototype.refreshArguments = tableCellRefreshArguments;
TableCell.prototype.removeArguments = tableCellRemoveArguments;
TableCell.prototype.setArguments = tableCellSetArguments;
//	CONSTRUCTOR: "TableCell" -------------end-----//

	//die hilfsfunktion "tableGetDefaultRows" gibt der eigenschaft "Table.rows" ein array komplexer zeilen- und zellen-objekte zurueck;
function tableGetDefaultRows(tableRows,tableCols) {
	var rowsArray = new Array();
	for (var i=0;i<tableRows;i++) {
		rowsArray[i] = new TableRow(tableCols); // vorbereitung fuer die initialisierung von spalten/zellen;
	}
	return rowsArray ;
}
	//die hilfsfunktion "tableGetDefaultCols" gibt der eigenschaft "TableRow.cols" ein array von zellen-objekten zurueck;
function tableGetDefaultCols(tableCols) {
	var colsArray = new Array();
	for (var i=0;i<tableCols;i++) {
		colsArray[i] = new TableCell(); // initialisierung von zellen-eigenschaften;
	}
	return colsArray;
}
//	constructor: "Table" - properties: "Table.rows[].cols[]"	---//


//	constructor: "Table" - "CONSTRUCTOR" --//
//	constructor: "Table" - "CONSTRUCTOR" --//
function Table() {
	var constructorArguments = Table.arguments;
	var constructorArgumentsLength = constructorArguments.length;
	var argumentName = "";
	var tableRows = 1;
	var tableCols = 1;
	var argumentsObject = null;
//	die 3 standardmaessigen (und finalen) argumente eines "Table"-objekts;
	this.defaults = null; // liste alle per default definierten "Table"-argumente und -methoden;
	this.arguments = null; // liste aller defaultmaessigen und aller initialisierten "Table"-argumente (wird vor jeder tabellen-internen berechnung ueber die methode "Table.refreshArguments()" auf den neuesten stand gebracht);
	this.rows = null; // die hilfsfunktion "tableGetDefaultRows" weist im weiteren initialisierungsprozess diesem element ein array komplexer zeilen- und zellen-objekte zu;
	this.defaults = tableGetDefaultProperties(this); // siehe erklaerungen zur hilfsfunktion "tableGetDefaultProperties" und kommentar 3 zeilen hoeher;
	if ((constructorArgumentsLength == 1) && (typeof(constructorArguments[0]) == "string")) {
		constructorArguments = constructorArguments.split(",");
		constructorArgumentsLength = constructorArguments.length;
	}
	for (var i=0;i<constructorArgumentsLength;i++) {
		if (constructorArguments[i].getConstructorName() == "Object()") { // because typeof(new Array()) returns "object" as well;
			// akzeptiert ein objektliteral oder mehrere objektliterale als argumente des klassen-konstruktors;
			argumentsObject = constructorArguments[i];
			for (argumentName in argumentsObject) {
				if (argumentName == "rows") {
					tableRows = argumentsObject["rows"].toString().forceToNumber();
				} else if (argumentName == "cols") {
					tableCols = argumentsObject["cols"].toString().forceToNumber();
				} else {
					this[argumentName] = argumentsObject[argumentName]; // ueberschreiben einer existierenden oder initilisieren einer neuen "Table"-eigenschaft;
					this[argumentName] = this[argumentName].toString();
				}
			}
		} else if (typeof(constructorArguments[i]) == "string") {
			// akzeptiert ein stringliteral oder mehrere stringliterale als argumente des klassen-konstruktors;
			argumentName = ((constructorArguments[i].indexOf("=") >= 1) ? (constructorArguments[i].split("=")[0]) : (null));
			if ((argumentName) && (argumentName.search(/\s/) == -1)) {
				if (argumentName == "rows") {
					tableRows = constructorArguments[i].split("=")[1].forceToNumber();
					tableRows = ((isNaN(tableRows)) ? (1) : (tableRows));
				} else if (argumentName == "cols") {
					tableCols = constructorArguments[i].split("=")[1].forceToNumber();
					tableCols = ((isNaN(tableCols)) ? (1) : (tableCols));
				} else {
					eval("this." + constructorArguments[i]); // ueberschreiben einer existierenden oder initilisieren einer neuen "Table"-eigenschaft;
					this[argumentName] = this[argumentName].toString();
				}
			}
		}
	}
	this.rows = tableGetDefaultRows(tableRows,tableCols); // hilfsfunktion zum generieren der zeilen- und spalten- defaults eines neuen "Table"-objekts;
}
// die 11 standardmaessigen (und finalen prototypen-)methoden eines "Table-objekts;
Table.prototype.isDefaultProperty = tableIsDefaultProperty;
Table.prototype.refreshArguments = tableRefreshArguments;
Table.prototype.removeArguments = tableRemoveArguments;
Table.prototype.setArguments = tableSetArguments;
Table.prototype.getCode = tableGetCode;
Table.prototype.insertRows = tableInsertRows;
Table.prototype.appendRows = tableAppendRows;
Table.prototype.removeRows = tableRemoveRows;
Table.prototype.insertCols = tableInsertCols;
Table.prototype.appendCols = tableAppendCols;
Table.prototype.removeCols = tableRemoveCols;
//Table.prototype.sortByCols = tableSortByCols;
//Table.prototype.sortByRows = tableSortByRows;

	// die hilfsfunktion "tableGetDefaultProperties" gibt der eigenschaft "Table.defaults" ("TableRow.defaults", "TableCell.defaults")
	// ein array aller standardmaessigen eigenschaften der gerade initialisierten tabelle
	// zurueck - in dieser liste stehen alle methoden und argumente einer tabelle, die im
	// nachhinein nicht mehr veraendert oder geloescht werden duerfen (js kennt eben kein
	// abgestuftes sicherheits-/oeffentlichkeits-protokoll fuer datentypen mit schluessel-
	// woertern wie z.b. "public", "privat" oder "final") - die liste wiederum kann nicht
	// schon statisch  vordefiniert sein, da eine js-tabelle ja immer  ein objekt ist und
	// bedingt durch das  prototypenkonzept von javascript auch  prototypen-eigenschaften
	// von "Object" enthaelt welche jetzt noch nicht bekannt sind, die aber ohne weiteres
	// zur laufzeit ausgelesen werden koennen  -  bsp.:  ein benutzer verwendet den table-
	// konstruktor in einer  js-umgebung,  in der dem "Object"-prototypen die eigenschaft
	// "xyz" zugewiesen wurde ("Object.prototype.xyz = whatever;")  -  in dieser umgebung
	// besitzt jetzt jedes table-object auch die prototypen-eigenschaft "xyz" zusaetzlich
	// zu den schon bekannten nativen prototypen-methoden und tabellen-eigenen argumenten;
function tableGetDefaultProperties(rawObject) {
	var defaultsArray = new Array();
	var propertyName = "";
	for (propertyName in rawObject) { // findet sowohl alle prototypen-eigenschaften als auch alle bis zum aufruf dieser funktion vereinbarten internen eigenschaften des uebergebenen constructor-objects "rawObject" ("Table", "TableRow", "TableCell");
		defaultsArray[defaultsArray.length] = propertyName;
	}
	return defaultsArray;
}
//	constructor: "Table" - "CONSTRUCTOR" --//
//	constructor: "Table" - "CONSTRUCTOR" --//


//	CONSTRUCTOR: "Table" ---------------end-----//
//	--------------------------------------------//