<script type="text/javascript">
<!--
//	--------------------------------------------//
//	CONSTRUCTOR: "Table" ---------------begin---//


//	constructor	  : "Table"		- methods: "Table.isDefaultProperty()"		---//
//	subConstructor: "TableRow"	- methods: "TableRow.isDefaultProperty()"	---//
//	subConstructor: "TableCell"	- methods: "TableCell.isDefaultProperty()"	---//
function tableIsDefaultProperty(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]
}
	// 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]
}
//	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]
}
//	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 = tableIsDefaultProperty; // tableRowIsDefaultProperty;
TableRow.prototype.refreshArguments = tableRefreshArguments; // tableRowRefreshArguments;
TableRow.prototype.removeArguments = tableRemoveArguments; // tableRowRemoveArguments;
TableRow.prototype.setArguments = tableSetArguments; // 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 = tableIsDefaultProperty; // tableCellIsDefaultProperty;
TableCell.prototype.refreshArguments = tableRefreshArguments; // tableCellRefreshArguments;
TableCell.prototype.removeArguments = tableRemoveArguments; // tableCellRemoveArguments;
TableCell.prototype.setArguments = tableSetArguments; // tableCellSetArguments;
/*
	TableCell.inherits(TableRow); // bei einer direkten referenzierung der funktionen im quellcode laeuft das script schneller;
*/
//	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" ---------------begin---//
//	--------------------------------------------//