// © 2014 Daniel Schulz

function Ajax(obj, file, postData, func) {
	var req, formData, method, key;
	
	if (postData) {
		method = "POST";
		formData = new FormData();
		for (key in postData) {
			formData.append(key, postData[key]);
		}
	} else {
		method = "GET";
		formData = false;
	}
	
	req = new XMLHttpRequest();
	req._callbackContext = obj;
	req._callbackFunc = func;
	req.open("POST", file, true);
	req.addEventListener(
		"load",
		function(eve) {
			var data;
			if (this._callbackFunc) {
				//alert(this.getResponseHeader("Content-Type"));
				switch (this.getResponseHeader("Content-Type")) {
					case "application/json":
						data = JSON.parse(this.responseText);
						break;
					default:
						data = this.responseText;
						break;
				}
				return this._callbackFunc.call(this._callbackContext, data);					
			} else {
				return true;
			}
		},
		false
	);
	if (formData) {
		req.send(formData);
	} else {
		req.send();
	}
	
	/*
	var http;
	if (window.XMLHttpRequest) {
		http = new XMLHttpRequest();
	} else {
		if (window.ActiveXObject) {
			http = new ActiveXObject("Microsoft.XMLHTTP");
		}
	}
	if (http) {
		if (postData) {
			http.open("POST", file, true);
		} else {
			http.open("GET", file, true);
		}
		http.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
		http.onreadystatechange = function() {
			var data;
			if (http.readyState == 4) {
				if (func) {
					//alert(http.getResponseHeader("Content-Type"));
					switch (http.getResponseHeader("Content-Type")) {
						case "application/json":
							data = JSON.parse(http.responseText);
							break;
						default:
							data = http.responseText;
							break;
					}
					return func.call(obj, data);					
				} else
					return true;
			}
			return false;
		};
		var str = [];
		for (var key in postData) {
			str.push(key + "=" + postData[key]);
		}
		str = str.join("&");
		http.send(str);
	}
	//*/
}



/*******************************************************************************
 * DOM v1.01 08.04.2014 © Daniel Schulz
 * 
 * 	Changelog:
 *		v1.01 08.04.2014
 *			console.log
 * 		v1.00 12.09.2012
 * 			initial release
 ******************************************************************************/

var DOM = {
	logActivity : true,
	documentCache : {},
	loadDocument : function(uri, callback) {
		var retDoc, req, fileURI, sync;
		try {
			fileURI = uri;
			sync = !callback;
			if (uri.indexOf("?") === -1) {
				//uri += "?";
			}
			if (this.documentCache[fileURI]) {
				retDoc = this.documentCache[fileURI];
				if (this.logActivity) {
					console.log("DOM.loadDocument served from internal cache! 0ms - %o", fileURI);
				}
				if (callback) {
					callback.call(window);
				}
			} else {
				req = new XMLHttpRequest();
				req.open("GET", uri, !sync);
				req.setRequestHeader("Accept", "application/xslt+xml,application/xhtml+xml,application/xml,*/*");
				req.setRequestHeader("Cache-Control", "max-age=0, must-revalidate");
				req._domParam = {
					dom : this,
					fileURI : fileURI,
					callback : callback,
					startTime : new Date(),
				};
				
				if (sync) {
					req.send();
					retDoc = this._loadDocumentAnswer(req);
				} else {
					req.addEventListener(
						"load",
						function(eve) {
							this._domParam.dom._loadDocumentAnswer(this);
						},
						false
					);
					req.send();
					retDoc = null;
				}
			}
		} catch(e) {
			console.log("Could not load XML ressource: %o", uri);
			console.log("	Exception: %o", e);
			retDoc = false;
		}
		return retDoc;
	},
	_loadDocumentAnswer : function(req) {
		var retDoc, startTime, endTime, timeDiff;
		startTime = req._domParam.startTime;
		endTime = new Date();
		timeDiff = endTime - startTime;
		
		retDoc = req.responseXML;
		if (!retDoc) {
			throw req.responseText;
		}
		retDoc.fileURI = req._domParam.fileURI;
				
		if (this.logActivity) {
			if (timeDiff < 25) {
				console.log("DOM.loadDocument served from browser cache! %oms - %o", timeDiff, retDoc.fileURI);
			} else {
				console.log("DOM.loadDocument served from server! %oms - %o", timeDiff, retDoc.fileURI);
			}
		}
				
		this.documentCache[retDoc.fileURI] = retDoc;
		
		if (this.logActivity) {
			console.log(retDoc);
		}
		
		if (req._domParam.callback) {
			req._domParam.callback.call(window);
		}
		return retDoc;
	},
	saveDocument : function(uri, doc) {
		var retDoc, req;
		try {
			req = new XMLHttpRequest();
			req.open("POST", uri, false);
			//req.setRequestHeader("Content-Type", "application/xml");
			req.send(doc);
			retDoc = req.responseXML;
			//retDoc = this.sanitizeDocument(retDoc);
			if (this.logActivity) {
				console.log("DOM.saveDocument: %o", uri);
				console.log(req.responseText);
			}
		} catch(e) {
			console.log("Could not save XML ressource: %o", uri);
			console.log("	Exception: %o", e);
			retDoc = false;
		}
		return retDoc;
	},
	jsonCache : {},
	loadJSON : function(uri) {
		var retObj, req;
		var startTime, endTime, timeDiff;
		try {
			if (uri.indexOf("?") === -1) {
				uri += "?";
			}
			if (this.jsonCache[uri]) {
				retObj = this.jsonCache[uri];
				if (this.logActivity) {
					console.log("DOM.loadJSON served from internal cache! 0ms - %o", uri);
				}
			} else {
				req = new XMLHttpRequest();
				req.open("GET", uri, false);
				req.setRequestHeader("Accept", "application/xslt+xml,application/xhtml+xml,application/xml,*/*");
				req.setRequestHeader("Cache-Control", "max-age=0, must-revalidate");
				startTime = new Date();
				req.send();
				endTime = new Date();
				timeDiff = endTime - startTime;
				retObj = JSON.parse(req.responseText);
				if (!retObj) {
					throw req.responseText;
				}
				
				if (this.logActivity) {
					if (timeDiff < 25) {
						console.log("DOM.loadJSON served from browser cache! %oms - %o", timeDiff, uri);
					} else {
						console.log("DOM.loadJSON served from server! %oms - %o", timeDiff, uri);
					}
				}
				
				this.jsonCache[uri] = retObj;
			}
		} catch(e) {
			console.log("Could not load XML ressource: %o", uri);
			console.log("	Exception: %o", e);
			retObj = false;
		}
		if (this.logActivity) {
			console.log(retObj);
		}
		return retObj;
	},
	loadXML : function(xml) {
		var doc, parser;
		parser = new DOMParser();
		doc = parser.parseFromString(xml, "application/xml");
		if (doc.documentElement.namespaceURI === NS.MOZ_ERR_PARSE) {
			throw ""+doc.documentElement.textContent;
		}
		//doc = this.sanitizeDocument(doc);
		return doc;
	},
	saveXML : function(doc) {
		var xml, serializer;
		serializer = new XMLSerializer();
		xml = serializer.serializeToString(doc);
		return xml;
	},
	//makes sure doc is an XPath-compatible Document
	sanitizeDocument : function(dataDoc) {
		if (!dataDoc || dataDoc.evaluate) {
			return dataDoc;
		}
		var retDoc;
		retDoc = document.cloneNode(false);
		while (retDoc.hasChildNodes()) {
			retDoc.removeChild(retDoc.lastChild);
		}
		for (var i = 0; i < dataDoc.childNodes.length; i++) {
			retDoc.appendChild(retDoc.importNode(dataDoc.childNodes[i], true));
		}
		return retDoc;
	},
};


// htmlArea v3.0 - Copyright (c) 2003-2004 interactivetools.com, inc.
// This copyright notice MUST stay intact for use (see license.txt).
//
// Portions (c) dynarch.com, 2003-2004
//
// A free WYSIWYG editor replacement for <textarea> fields.
// For full source code and docs, visit http://www.interactivetools.com/
//
// Version 3.0 developed by Mihai Bazon.
//   http://dynarch.com/mishoo
//
// $Id: dialog.js,v 1.4 2004/01/28 09:42:55 mishoo Exp $

// Though "Dialog" looks like an object, it isn't really an object.  Instead
// it's just namespace for protecting global symbols.

function Dialog(url, action, init, editor) {
	if (typeof init == "undefined") {
		init = window;	// pass this window object by default
	}
	Dialog._geckoOpenModal(url, action, init, editor);
};

Dialog._parentEvent = function(ev) {
	if (Dialog._modal && !Dialog._modal.closed) {
		Dialog._modal.focus();
		//HTMLArea._stopEvent(ev);
	}
};

// should be a function, the return handler of the currently opened dialog.
Dialog._return = null;

// constant, the currently opened dialog
Dialog._modal = null;

// the dialog will read it's args from this variable
Dialog._arguments = null;

// neuer Container, der den aktuellen editor hält.
Dialog._editor = null;

Dialog._geckoOpenModal = function(url, action, init, editor) {
	var dlg = window.open(url, "hadialog",
			      "toolbar=no,menubar=no,personalbar=no,width=10,height=10," +
			      "scrollbars=no,resizable=yes,status=no");
	Dialog._modal = dlg;
	Dialog._arguments = init;
	if (editor) Dialog._editor = editor;

	// capture some window's events
	function capwin(w) {
		//HTMLArea._addEvent(w, "click", Dialog._parentEvent);
		//HTMLArea._addEvent(w, "mousedown", Dialog._parentEvent);
		//HTMLArea._addEvent(w, "focus", Dialog._parentEvent);
	};
	// release the captured events
	function relwin(w) {
		//HTMLArea._removeEvent(w, "click", Dialog._parentEvent);
		//HTMLArea._removeEvent(w, "mousedown", Dialog._parentEvent);
		//HTMLArea._removeEvent(w, "focus", Dialog._parentEvent);
	};
	capwin(window);
	// capture other frames
	for (var i = 0; i < window.frames.length; capwin(window.frames[i++]));
	// make up a function to be called when the Dialog ends.
	Dialog._return = function (val) {
		
		if (val && action) {
			action(val);
		}
		relwin(window);
		// capture other frames
		for (var i = 0; i < window.frames.length; relwin(window.frames[i++]));
		Dialog._modal = null;
	};
};



// © 2010 Daniel Schulz

var HTML = {
	LANG : {
	},
	status_div : null,
	makeElement : function(tagName, attributeKeys, attributeVals, innerText, obj) {	//innertext kann sein: number (ID), string (innerHTML), nodeObject (innerNode), array(nodeObject, nodeObject, ...)
		var i, node = document.createElement(tagName);
		//if (this.stoop2stupidity) {
		//	this.stoop2stupidity(node);
		//}
		for (i=0; i < attributeKeys.length; i++) {
			switch (typeof attributeVals[i]) {
				case "function":
					//$(node).bind(attributeKeys[i], attributeVals[i]);
					node.addEventListener(attributeKeys[i], attributeVals[i], false);
					break;
				case "string":
					node.setAttribute(attributeKeys[i], attributeVals[i]);
					break;
				default:
					node.setAttribute(attributeKeys[i], attributeKeys[i]);
					break;	
			}
		}
		switch (typeof innerText) {
			case "number":
				node.obj_id = innerText;
				break;
			case "string":
				try {
					node.innerHTML = innerText;
				} catch(e) {
					node.appendChild(node.ownerDocument.createTextNode(innerText));
					//node.appendChild(this.makeElement("p", [], [], "Syntaxfehler im HTML-Quellcode, Parsen fehlgeschlagen."));
					//node.appendChild(this.makeElement("pre", [], [], node.ownerDocument.createTextNode(e)));
					//node.appendChild(this.makeElement("pre", [], [], node.ownerDocument.createTextNode(innerText)));
					//alert("ERROR parsing HTML:\n"+e);
				}
				break;
			case "object":
				if (innerText instanceof Array) {
					for (i = 0; i < innerText.length; i++) {
						node.appendChild(innerText[i]);
					}
				} else {
					node.appendChild(innerText);
				}
				break;
			default:
				
				break;
		}
		
		if (node.className) {
			node.classes = node.className.split(" ");
		} else {
			node.classes = [];
		}
		if (obj) {
			node.self = obj;
		}
		return node;
	},
	hasClass : function(node, className) {
		var i;
		HTML.chkClass(node);
		for (i = 0; i < node.classes.length; i++) {
			if (node.classes[i] == className) {
				node.className = node.classes.join(" ");
				return true;
			}
		}	
		return false;
	},
	addClass : function(node, className) {
		HTML.chkClass(node);
		if (HTML.hasClass(node, className)) {
			
			return true;
		} else {
			node.classes.push(className); 
			node.className = node.classes.join(" ");
			return HTML.hasClass(node, className);
		}
	},
	setClass : function(node, className) {
		HTML.chkClass(node);
		node.classes = [className];
		node.className = node.classes.join(" ");
	},
	removeClass : function(node, className) {
		HTML.chkClass(node);
		for (i = 0; i < node.classes.length; i++) {
			if (node.classes[i] == className) {
				node.classes[i] = null;
				node.className = node.classes.join(" ");
				return true;
			}
		}
		return false;
	},
	chkClass : function(node) {
		if (typeof node !== "undefined" && typeof node.classes === "undefined") {
			if (node.className) {
				node.classes = node.className.split(" ");
			} else {
				node.classes = [];
			}
		}
	},
	getInputVal : function(node) {	//holt einen intelligenten wert zur beschreibung einer input box
		var i,tmp,ret = "";
		switch (node.getAttribute("type")) {
			case "text":
			case "password":
				ret = node.value;
				break;
			case "radio":
			case "checkbox":
				if (node.checked == "checked" || node.checked == true || node.checked == 1)
					ret = 1;
				else	
					ret = 0;
				break;
			case "select":
				for (i = 0; i < node.childNodes.length; i++) {
					tmp = node.childNodes[i];
					if (tmp.selected == "selected" || tmp.selected == true || tmp.selected == 1) {
						ret = tmp.value;
					}
				}
				break;
			case "textarea":
				ret = node.value;
				break;
			default:break;
		}
		return ret;
	},
	setInputVal : function(node, val) {	//setzt intelligent den wert einer input box
		var i,tmp;
		switch (node.getAttribute("type")) {
			case "text":
			case "password":
				node.value = val;
				break;
			case "radio":
			case "checkbox":
				if (val == 1 || val == true || val == "checked")
					node.checked = "checked";
				else	
					node.checked = null;
				break;
			case "select":
				for (i = 0; i < node.childNodes.length; i++) {
					tmp = node.childNodes[i];						
					if (tmp.value == val) {
						tmp.selected = "selected";
						break;
					}
				}
				break;

			default:break;
		}
	},
	setInputCorrect : function(node, bool) {
		var tmp;
		switch (node.getAttribute("type")) {
			case "text":
			case "password":
			case "select":
				tmp = node;
				break;
			case "radio":
				tmp = node.parentNode.parentNode;
				break;
			case "checkbox":
				tmp = node.parentNode;
				break;
			default:return;
		}
		if (bool) {
			HTML.removeClass(tmp, "InputWrong");
			HTML.addClass(tmp, "InputCorrect");
		} else {
			HTML.removeClass(tmp, "InputCorrect");
			HTML.addClass(tmp, "InputWrong");
		}
	},
	setStatus : function(statusNode) {
		if (this.status_div || this.make_status_div()) {
			this.status_div.appendChild(statusNode);
		}
	},
	removeStatus : function(statusNode) {
		if (statusNode && statusNode.parentNode && statusNode.parentNode == this.status_div) {
			this.status_div.removeChild(statusNode);
		}
	},
	make_status_div : function() {
		this.status_div = this.makeElement(
							"div",
							Array("class"),
							Array("StatusBar"));
		document.getElementsByTagName("body")[0].appendChild(this.status_div);
		return true;
	},
	setDictionary : function(arr) {
		this.LANG = arr;
	},
	getDictionary : function() {
		var i,str = "";
		for (i in this.LANG) {
			str += '"' + i + '" : "' + this.LANG[i] + '",' + "\n"; 
		}
		alert(str);
	},
	lookup : function(word) {
		if ((typeof this.LANG[word]) !== "undefined") {
			return this.LANG[word];
		} else {
			//this.LANG[word] = word;
			return word;
		}
	}	
};



var _html5 = function() {
	try {
		if (!('open' in document.createElement('details'))) {
			var nodeList, node, i;
			
			//wait until document is actually ready...
			node = document.createTextNode("");
			document.body.appendChild(node);
			document.body.removeChild(node);
			
			nodeList = document.getElementsByTagName("summary");
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				if (!node._init) {
					node._init = true;
					node.addEventListener(
						"click",
						function(eve) {
							if (this.parentNode.hasAttribute("open")) {
								this.parentNode.removeAttribute("open");
							} else {
								this.parentNode.setAttribute("open", "open");
							}
							
							if (this.parentNode.hasAttribute("open")) {
								//this.nextSibling.style.removeProperty("display");
							} else {
								//this.nextSibling.style.setProperty("display", "none");
							}
						},
						false
					);
					if (!node.parentNode.hasAttribute("open")) {
						//node.nextSibling.style.setProperty("display", "none");
					}
				}
			}
		}
	} catch(e) {
	}
};

_html5.call();

window.addEventListener(
	"DOMContentLoaded",
	_html5,
	false
);
window.addEventListener(
	"load",
	_html5,
	false
);


// © 2013 Daniel Schulz

var NS = {
	XML				: "http://www.w3.org/XML/1998/namespace",
	HTML 			: "http://www.w3.org/1999/xhtml",
	SVG 			: "http://www.w3.org/2000/svg",
	XLINK 			: "http://www.w3.org/1999/xlink",
	XSL 			: "http://www.w3.org/1999/XSL/Transform",
	MOZ_ERR_PARSE 	: "http://www.mozilla.org/newlayout/xml/parsererror.xml",
	IBP				: "http://www.ibp-dresden.de",
	LODB			: "http://schema.ibp-dresden.de/lodb",
	resolver : function(prefix) {
		//console.log("NS xmlns:%o=%o", prefix, NS[prefix.toUpperCase()]);
		return NS[prefix.toUpperCase()];
	},
	prefixer : function(uri) {
		var prefix, ret = "";
		for (prefix in NS) {
			if (NS[prefix] === uri) {
				ret = prefix;
				break;
			}
		}
		return ret.toLowerCase();
	},
};


// © 2009 Daniel Schulz

function ProgressBar(obj, text) {
	this.end=0;
	this.progress=0;
	this.progress_float=0;
	this.node=0;
	this.callback=null;	
	this.obj=obj;
	this.text=text;
}
ProgressBar.div = null;
ProgressBar.running = 0;
ProgressBar.nodeCount = 0; 
ProgressBar.clear = function () {
	document.body.style.cursor = "auto";
	ProgressBar.div.style.display="none";
	//alert(ProgressBar.div.innerHTML);
	//ProgressBar.div.innerHTML="";
	//$(ProgressBar.div).html("");
	ProgressBar.div.textContent = "";
	if (ProgressBar.uponClearing && ProgressBar.uponClearing.call) {
		ProgressBar.uponClearing.call();
	}
};
ProgressBar.uponClearing = null;
ProgressBar.setFinalFunction = function (func) {
	ProgressBar.uponClearing = func;
};
ProgressBar.prototype.start = function (i, callback) {
	//alert(ProgressBar.div);
	if (ProgressBar.div || ProgressBar.construct()) {
		ProgressBar.running++;
		this.node=ProgressBar.nodeCount++;
		document.body.style.cursor = "wait";
		ProgressBar.div.style.display="";
		var str='<tr><th>' + this.text + '</th>', j;
		for (j=0;j<10;j++) {
			str+='<td></td>';
		}
		str+='</tr>';
		//alert("<table>" + str + "</table>");
		//alert(ProgressBar.div);
		//ProgressBar.div.innerHTML += str;
		//$(ProgressBar.div).html(str);
		ProgressBar.div.innerHTML = str;
		this.end=i;
		this.progress=0;
		this.callback=callback;
	} else alert("error");
};
ProgressBar.prototype.finish = function () {
	if (this.callback && this.callback.call)
		this.callback.call(this.obj);
	this.end=this.progress=this.progress_float=0;
	this.callback=null;
	ProgressBar.running--;
	//alert(ProgressBar.running);
	if (ProgressBar.running == 0)
		setTimeout(ProgressBar.clear, 500);
};
ProgressBar.prototype.increment = function() {
	var i, j, k, nodeList;
	if (ProgressBar.div && ProgressBar.div.getElementsByTagName("tr") && ProgressBar.div.getElementsByTagName("tr")[this.node]) {		
		//alert(this.motherNode.innerHTML);
		j = this.progress_float + 10.0 / this.end;
		for (k = 0; k < 10; k++) {
			nodeList = ProgressBar.div.getElementsByTagName("tr")[this.node].getElementsByTagName("td");
			if (nodeList[k]) {
				if (k < parseInt(j,10)) {
					nodeList[k].setAttribute("data-progressbar", "1");
				} else {
					nodeList[k].setAttribute("data-progressbar", "0");
				}
			}
		}
		this.progress_float = j;
		this.progress++;
		if (this.progress==this.end) {
			this.finish();		
		}
	}
};
ProgressBar.construct = function() {
	//alert("test");
	
	ProgressBar.div = HTML.makeElement(
							"table",
							["class"],
							["ProgressBarTable"]);
	
	document.body.appendChild(ProgressBar.div);
	return true;
};


//© 2010 Daniel Schulz

var Renderer = {
	currentObject : null,	//das aktuelle objekt
	allObjects : {			//alle objekte, zwecks kreisreferenzen
		//pool : { id : renderCount }
	},
	maxRenderCount : 3,		//wie oft ein objekt rausgerendert werden soll (falls es mehrmals/kreis referenziert wird)
	dom : undefined,
	user : {
		displayname : "unknown",
		username : "unknown",
		email : "unknown",
		language : "0",
	},
	init : function() {
		if (!this.loading) {
			this.initDOM();
			ProgressBar.setFinalFunction(
				function() {
					if (Renderer.currentObject) {
						Renderer.displayObject(Renderer.currentObject.getFirstContent());
						Renderer.setLoading(false);
						//Renderer.currentObject.showNavi();
					}
				});
			this.loading = new ProgressBar(this, HTML.lookup("Learning Object is being downloaded..."));
			this.loading.start(0);
		}
	},
	initDOM : function() {
		var node;
		this.dom = {};
		
		//<head>
		node = document.getElementsByTagName("head")[0];
		if (!node) {
			node = document.createElement("head");
			document.documentElement.appendChild(node);
		}
		this.dom.head = node;
		
		//<title>
		node = document.getElementsByTagName("title")[0];
		if (!node) {
			node = document.createElement("title");
			this.dom.head.appendChild(node);
		}
		this.dom.title = node;
		
		//<body>
		node = document.getElementsByTagName("body")[0];
		if (!node) {
			node = document.createElement("body");
			document.documentElement.appendChild(node);
		}
		this.dom.body = node;
		
		//<div>
		node = document.createElement("div");
		node.setAttribute("class", "Renderer");
		this.dom.body.appendChild(node);
		this.dom.renderer = node;
		
		//<nav>
		node = document.createElement("nav");
		node.innerHTML = "<details><summary><i class='fa fa-bars'/></summary></details>";
		this.dom.renderer.appendChild(node);
		this.dom.navi = node.lastChild;
		
		//<user>
		node = document.createElement("address");
		node.innerHTML = "<i class='fa fa-user'></i> <span></span>";
		this.dom.navi.firstChild.appendChild(node);
		this.dom.user = node.lastChild;
		
		//<main>
		node = document.createElement("main");
		this.dom.renderer.appendChild(node);
		this.dom.content = node;
		
		//<header>
		node = document.createElement("header");
		node.innerHTML = "<div class='help'><a href='http://red.lodb.log-in-projekt.eu/sites/www/help/index.xhtml' target='_blank' title='Help'><i class='fa fa-question-circle'/></a> <a href='http://red.lodb.log-in-projekt.eu' target='_blank' title='Login'><i class='fa fa-home'/></a></div>";
		this.dom.content.appendChild(node);
		this.dom.header = node;
		
		//<div> breadcrumb
		node = document.createElement("div");
		node.setAttribute("class", "NaviBreadcrumb");
		this.dom.header.appendChild(node);
		this.dom.breadcrumb = node;
		
		//<h1> breadcrumb
		node = document.createElement("h1");
		this.dom.header.appendChild(node);
		this.dom.headline = node;
		
		if (window._html5) {
			window._html5();
		}
	},
	filterObjects : function(list) {	//checkt, ob objekt renderfähig ist
		var i, ret = [];
		for (i = 0; i < list.length; i++) {
			switch (list[i]["type"]) {
				case "container":
				case "exercise":
				case "exercise_container":
				case "lo_audio":
				//case "lo_img":
				case "lo":
				case "lo_question":
				case "lo_text":
				case "lo_glossary":
				case "lo_exercise":
				case "lo_session_log":
				case "lo_container":
				case "lo_course":
				case "page":
					ret.push(list[i]);
					break;
				default:
					break;
			}
		}
		return ret;
	},
	setUser : function(user) {
		for (var key in this.user) {
			if (user[key]) {
				this.user[key] = user[key];
			}
		}
		this.dom.user.textContent = this.user.displayname;
	},
	getUser : function() {
		return this.user;
	},
	getObject : function(struc, parent) {	//erstellt neues objekt
		var ret,
			id = struc["id"],
			pool = struc["pool"],
			type = struc["type"],
			sid = parent["sid"],
			ajaxScript = parent["ajaxScript"];
		if (parent.user) {
			this.setUser(parent.user);
		}
		if (this.allObjects[pool] && this.allObjects[pool][id]) {
			this.allObjects[pool][id]++;
			if (this.allObjects[pool][id] > this.maxRenderCount) {
				return null;
			}
		}
		switch (type) {
			case "container":
				ret = new this.Container(sid, ajaxScript, id, pool);
				break;
			case "lo_audio":
				ret = new this.LearningObjectAudio(sid, ajaxScript, id, pool);
				break;
			case "lo_img":
				ret = new this.LearningObjectImage(sid, ajaxScript, id, pool);
				break;
			case "exercise":
				ret = new this.Exercise(sid, ajaxScript, id, pool);
				break;
			case "exercise_container":
				ret = new this.ExerciseContainer(sid, ajaxScript, id, pool);
				break;
			case "lo_exercise":
				ret = new this.LearningObjectExercise(sid, ajaxScript, id, pool);
				break;
			case "lo_session_log":
				ret = new this.LearningObjectSessionLog(sid, ajaxScript, id, pool);
				break;
			case "lo":
			case "lo_question":
			case "lo_text":
			case "lo_glossary":
			case "page":
				ret = new this.LearningObject(sid, ajaxScript, id, pool);
				break;
			case "lo_container":
				ret = new this.LearningObjectContainer(sid, ajaxScript, id, pool);
				break;
			case "lo_course":
				ret = new this.LearningObjectCourse(sid, ajaxScript, id, pool);
				break;
			default:
				ret = null;
				break;
		}
		if (parent instanceof Renderer.abstractObject) {
			parent.appendObject(ret);
			//ret.parentObject = parent;
			ret.rootObject = parent.rootObject;
		} else {
			ret.parentObject = null;
			ret.rootObject = ret;
		}
		
		if (!this.allObjects[pool]) {
			this.allObjects[pool] = {};
		}
		this.allObjects[pool][id] = 1;
		return ret;
	},
	loadCount : 0,
	loading : null,
	setLoading : function(isLoading) {
		if (isLoading) {
			HTML.addClass(this.dom.body, "RendererLoading");
		} else {
			HTML.removeClass(this.dom.body, "RendererLoading");
		}
	},
	addLoad : function(obj) {
		this.setLoading(true);
		this.loadCount++;
		if (!this.loading) {
			this.loading = new ProgressBar(this, HTML.lookup("Learning Object is being downloaded..."));
			ProgressBar.setFinalFunction(
				function() {
					if (Renderer.currentObject) {
						Renderer.displayObject(Renderer.currentObject.getFirstContent());
						Renderer.setLoading(false);
						//Renderer.currentObject.showNavi();
					}
				});
			
			this.loading.start(1);
		} else {
			this.loading.end++;
		}
	},
	doneLoad : function(obj) {
		this.loadCount--;
		this.loading.increment();
		/*
		if (this.loadCount === 0) {
			if (Renderer.currentObject) {
				this.displayObject();
				HTML.removeClass(document.body, "RendererLoading");
				//Renderer.currentObject.showNavi();
			}
		}
		*/
	},
	abstractObject : function(sid, ajaxScript, id, pool) {
		this.sid = sid;
		this.ajaxScript = ajaxScript;
		this.id = id;
		this.pool = pool;
		
		this.div = null;	//CONTENT <div this.div>		
		this.navi = null;	//NAVIGATIONS <div this.navi> <span this.navi_title> </span> <ul this.navi_list> <li> this.naviTree[1] </li> <li> ...
		this.navi_title = null;	//TITEL <span>
		this.navi_list = null;	//CONTENT <ul>
		this.status = null;	//STATUS <p>
		
		this.visible = false;
		this.isContent = false;
		this.isContainer = false;
		
		this.parentObject = undefined;
		this.childObjects = [];
		
		this.__class__ = "Object";
		
		this.data = {
			"_title" : "Object Title",
			"_type" : "card",
			"_icon" : "",
			"_ref" : "",
			"_objects" : [],
		};
		this.naviTree = [];			//navi domTree HTML Elemente			<li>
		this.objectTree = [];		//unterobjekte domTree HTML Elemente	<p>
		this.domTree = {		//content domTree HTML Elemente		ALLE Elemente hier drin werden der Reihe nach in den content des objektes gehangen!
			//_anchor	Wenn vorhanden, an dieser Stelle Anker setzen
			//_title	Wenn vorhanden, an dieser Stelle Titel anzeigen
			//_object	Wenn vorhanden, an dieser Stelle Unterobjekte anzeigen
		};
		this.buttonTree = {		//button domTree HTML Elemente		ALLE Elemente hier drin werden der Reihe nach in den content des objektes gehangen (nach domTree)
		};
		
		this.onloadFunc = null;		//mit setOnload() funktion für nach dem laden speichern
		this.onsubmitFunc = null;	//mit setOnsubmit() funktion für nach dem bestätigen speichern
		this.onloadObj  = {};
		this.onsubmitObj  = {};	
	},
	displayObject : function(object) {
		if (object && object instanceof Renderer.abstractObject) {
			if (object.isContent) {
				if (this.currentObject && this.currentObject == object) {
					//this.currentObject.setActive(true);
					this.currentObject.toggleNavi();		
				} else {
					//hide current navi+content
					if (this.currentObject && this.currentObject.setInactive) {
						this.currentObject.setInactive();
						/*
						if (this.currentObject.visible) {
							this.currentObject.setInactive();
							this.currentObject.showNavi();
						} else {
							this.currentObject.setInactive();
						}
						//*/
					}
					
					this.currentObject = object;
					this.currentObject.setActive(true);
					
					//generate breadcrumb
					while (this.dom.breadcrumb.hasChildNodes()) {
						this.dom.breadcrumb.removeChild(this.dom.breadcrumb.lastChild);
					}
					for (object = this.currentObject; object; object = object.parentObject) {
						this.dom.breadcrumb.insertBefore(
							object.navi_title.cloneNode(true),
							this.dom.breadcrumb.firstChild
						);
					}
					/*
					this.currentObject.rootObject.div.insertBefore(
						this.dom.breadcrumb,
						this.currentObject.rootObject.div.lastChild
					);
					//*/
				}
			} else {
				object.toggleNavi();
			}
		} else {
			this.currentObject.setActive(true);
		}
		
		//build <title>
		var titleList = [], current;
		for (current = this.currentObject; current; current = current.parentObject) {
			titleList.push(current.data._title);
		}
		this.dom.title.textContent = titleList.join(" - ");
	}
};
Renderer.abstractObject.prototype.init = function(ContentNode, NaviNode) {
	if (NaviNode) {
		this.makeNavi(NaviNode);
	} else {
		this.makeNavi();
	}
	if (ContentNode) {
		this.makeDiv(ContentNode);
	} else {
		this.makeDiv();
	}
	this.requestObject();
	//this.init = function(ContentNode, NaviNode) {};
};
Renderer.abstractObject.prototype.requestObject = function() {
	var data = {};
	data["sid"] = this.sid;
	data["mode"] = "reqobj";
	data["id"] = this.id;
	data["pool"] = this.pool;
	if (this.rootObject instanceof Renderer.LearningObjectCourse) {
		if (this.rootObject.data._ref) {
			data["courseRef"] = this.rootObject.data._ref;
		}
	}
	
	Renderer.addLoad();
	//this.setStatus(HTML.lookup(this.__class__ + " is beeing requested..."));
	//new Ajax(this, this.ajaxScript, "sid=" + this.sid + "&mode=reqobj&id=" + this.id + "&pool=" + this.pool, this.onrequestFunc);
	new Ajax(this, this.ajaxScript, data, this.onrequestFunc);
};
Renderer.abstractObject.prototype.onrequestFunc = function(arr) {
	var i;	
	this.data = arr;
	this.data._objects = Renderer.filterObjects(this.data._objects);
	
	//this.clearStatus();		
	this.setTitle(this.data["_title"], this.data["_icon"]);
	delete this.domTree["_anchor"];	//ANKER DEAKTIVIERT
	if (typeof this.domTree["_anchor"] !== "undefined") {
		this.domTree["_anchor"] = HTML.makeElement(
			"span",
			[],
			[],
			"".anchor("Anker" + this.id)
		);
	}
	if (typeof this.domTree["_title"] !== "undefined") {
		this.domTree["_title"] = HTML.makeElement(
			"h1",
			["class"],
			["RendererTitle"],
			this.data["_title"]
		);
	}
	this.prepareObject();
	if (this.data._objects.length) {
		this.isContainer = true;
		this.prepareContainer();
	}
	this.showContent();
	this.hideNavi();
	this.setInactive();
	this.checkOnload();
	if (!Renderer.currentObject || !Renderer.currentObject.isContent) {
		//Renderer.currentObject = this;
	}
	if (!Renderer.currentObject) {
		Renderer.currentObject = this;
	}
	Renderer.doneLoad();
};
Renderer.abstractObject.prototype.makeDiv = function(node) {
	if (typeof node === "object") {
		this.div = HTML.makeElement(
			"div",
			["class"],
			["RendererContent RendererInvisible"]
		);
		return node.appendChild(this.div);
	} else {
		this.div = HTML.makeElement(
			"div",
			["class"],
			["RendererOuterContent"]
		);
		return Renderer.dom.content.appendChild(this.div);
	}
};
Renderer.abstractObject.prototype.makeNavi = function(node) {
	this.navi_title = HTML.makeElement(
		"span",
		["class"],
		["RendererNavi"]
	);
	this.navi_list = HTML.makeElement(
		"ul",
		["class"],
		["RendererNavi"]	//"RendererNavi RendererInvisible" 05.08.2013 -D.S.
	);
	this.navi = HTML.makeElement(
		"div",
		["click"],
		[
			function(e) {													
				Renderer.displayObject(this.self);
				//window.location.hash = "#Anker" + this.obj_id;
				e.stopPropagation();
			},
		],
		parseInt(this.id),
		this
	);
	
	if (typeof node === "object") {
		HTML.addClass(this.navi, "RendererNavi");
		HTML.addClass(this.navi, "Navi-" + this.__class__);
		if (this.isContent) {
			HTML.addClass(this.navi, "NaviContent");
		}
		if (this.isContainer) {
			HTML.addClass(this.navi, "NaviContainer");
		}
		return node.appendChild(this.navi);
	} else {
		HTML.addClass(this.navi, "RendererOuterNavi");
		return Renderer.dom.navi.appendChild(this.navi);		
	}											
};
Renderer.abstractObject.prototype.setTitle = function(text, icon) {
	if (this.navi /* || this.makeNavi() */) {
		while (this.navi_title.hasChildNodes()) {
			this.navi_title.removeChild(this.navi_title.firstChild);
		}
		if (icon) {
			this.navi_title.appendChild(
				HTML.makeElement(
					"img",
					["class", "src", "alt"],
					["RendererIcon", icon, ""]
				)
			);
		}
		this.navi_title.appendChild(document.createTextNode(text));
		return true;
	}
	return false;
};
Renderer.abstractObject.prototype.setActive = function(showContent) {
	this.showNavi();
	if (this.navi) {
		HTML.addClass(this.navi, "RendererHrefActive");
		HTML.removeClass(this.navi, "RendererHrefInactive");	
	}
	this.prepareContent();
	if (this.div) {
		HTML.removeClass(this.div, "RendererInvisible");
	}
	if (this.domTree._title) {
		if (showContent) {
			Renderer.dom.headline.textContent = this.domTree._title.textContent;
		}
	}
	if (this.domTree.loRoot) {
		if (showContent) {
			HTML.removeClass(this.domTree.loRoot, "RendererInvisible");
		} else {
			HTML.addClass(this.domTree.loRoot, "RendererInvisible");
		}
	}
	if (this.parentObject && this.parentObject.setActive) {
		//alert(this.data._title);
		this.parentObject.setActive(false);
	}
};
Renderer.abstractObject.prototype.setInactive = function() {	
	this.hideNavi();
	if (this.navi) {
		HTML.addClass(this.navi, "RendererHrefInactive");
		HTML.removeClass(this.navi, "RendererHrefActive");		
	}
	if (this.div) {
		HTML.addClass(this.div, "RendererInvisible");
	}
	if (this.parentObject && this.parentObject.setInactive) {
		this.parentObject.setInactive();
	}
};
Renderer.abstractObject.prototype.toggleNavi = function() {
	if (this.visible == true) {
		this.hideNavi();
	} else {
		this.showNavi();
	}
}
Renderer.abstractObject.prototype.showNavi = function() {	//klappt die <ul> liste eines objektes auf
	if (this.navi_list) {
		HTML.removeClass(this.navi_list, "RendererInvisible");
	}
	this.visible = true;
}
Renderer.abstractObject.prototype.hideNavi = function() {	//klappt die <ul> liste eines objektes zu
	if (this.navi_list) {
		//HTML.addClass(this.navi_list, "RendererInvisible");
	}
	this.visible = false;
}
Renderer.abstractObject.prototype.setOnload = function(func, obj) {
	this.onloadFunc = func;
	this.onloadObj = obj;
};
Renderer.abstractObject.prototype.checkOnload = function() {
	if (typeof this.onloadFunc === "function")
		this.onloadFunc(this.onloadObj);
};
Renderer.abstractObject.prototype.setOnsubmit = function(func, obj) {
	this.onsubmitFunc = func;
	this.onsubmitObj = obj;
};
Renderer.abstractObject.prototype.checkOnsubmit = function() {
	if (typeof this.onsubmitFunc === "function")
		this.onsubmitFunc(this.onsubmitObj);
};

Renderer.abstractObject.prototype.showContent = function() {
	var id, i;
	while (this.navi.hasChildNodes()) {
		this.navi.removeChild(this.navi.lastChild);
	}
	while (this.div.hasChildNodes()) {
		this.div.removeChild(this.div.lastChild);
	}
	this.navi.appendChild(this.navi_title);
	
	for (i = 0; i < this.naviTree.length; i++) {
		this.navi_list.appendChild(this.naviTree[i]);
	}
	if (this.navi_list.hasChildNodes()) {
		this.navi.appendChild(this.navi_list);
	}
	for (id in this.domTree) {
		switch (typeof this.domTree[id]) {
			case "function":
			case "object":
				if (this.domTree[id]) {
					this.domTree[id].self = this;
					this.div.appendChild(this.domTree[id]);
				}
				break;
			case "string":
			case "number":
				for (i = 0; i < this.objectTree.length; i++) {
					if (this.objectTree[i].id === id) {
						this.domTree[id] = this.objectTree[i].div;
						this.domTree[id].self = this;
						this.div.appendChild(this.domTree[id]);
					}
				}
				break;
			default:
				break;
		}
	}
};
Renderer.abstractObject.prototype.prepareContainer = function() {
	var content, id, i, node, obj;
	if ((this.div ||  this.makeDiv()) && (this.navi /* || this.makeNavi() */)) {
		content = HTML.makeElement(
							"div",
							[],
							[]);
		switch (this.data["_type"]) {
			case "multi":
				/*
				this.isContent = true;				
				for (i = 0; i < this.data._objects.length; i++) {
					id = this.data._objects[i].id;
					
					this.objectTree[id] =  Renderer.getObject(this.data._objects[i], this);
					if (this.objectTree[id]) {
						this.naviTree[id] = HTML.makeElement(
												"li",
												Array("class"),
												Array("RendererNavi RendererMultiHead RendererHref"));
						this.objectTree[id].init(content, this.naviTree[id]);
						this.objectTree[id].setOnload( function() { HTML.addClass(this.div, "RendererVisible"); } );
					}
					//this.objectTree[id].showNavi();
				}
				HTML.addClass(content, "RendererMultiContent");
				HTML.addClass(this.div, "RendererMulti");
				//*/
				break;				
			case "step":
				/* bis auf weiteres deaktiviert
				this.isContent = true;
				if (typeof this.curr_object === "undefined")
					this.curr_object = null;
				if (this.curr_object === null) {
					if (this.data._objects.length) {
						this.curr_object = this.data._objects[0];
					}
				} else {
					//this.div.removeChild(this.buttonTree["next"]);
					while (this.div.hasChildNodes())
						this.div.removeChild(this.div.firstChild);
					id = this.curr_object;
				}
				this.naviTree[id] = HTML.makeElement(
										"li",
										Array("class", "click", "mouseover", "mouseout"),
										Array("RendererNavi RendererMultiHead RendererHref RendererHrefInactive",
												function(e) {													
													//this.self.displayObject(this.obj_id);
													e.stopPropagation();
												},
												function(e) {
													HTML.addClass(this, "RendererHrefMouseover");
													e.stopPropagation();
												},
												function(e) {
													HTML.removeClass(this, "RendererHrefMouseover");
													e.stopPropagation();
												}),
										parseInt(id,10),
										this);
				this.objectTree[id] = Renderer.getObject(this.data._objects[i], this);
				this.objectTree[id].setOnsubmit(function(container) {
															container.buttonTree["next"].removeAttribute("disabled");
														},
														this);
				this.objectTree[id].init(content, this.naviTree[id]);
				
				this.buttonTree["next"] = HTML.makeElement(
										"button",
										Array("class", "click", "disabled"),
										Array("RendererButton", function(e) { this.self.nextStep(); }),
										HTML.lookup("Weiter"),
										this);
				
				this.domTree["next"] = this.buttonTree["next"];
				HTML.addClass(content, "RendererStepContent");
				HTML.addClass(this.div, "RendererStep");
				break;
				*/
			case "card":
				
				for (i = 0; i < this.data._objects.length; i++) {
					id = this.data._objects[i].id;
					if (obj = Renderer.getObject(this.data._objects[i], this)) {
						node = HTML.makeElement(
							"li",
							["class", "click", "data-renderer-ref"],
							[
								"RendererNavi RendererCardHead RendererHref",
								function(e) {													
									Renderer.displayObject(this.self);
									e.stopPropagation();
								},
								this.data._ref,
							],
							parseInt(id),
							this
						);
						this.naviTree.push(node);
						this.objectTree.push(obj);
						
						obj.setOnload(function() { this.hideNavi(); });
						obj.init(content, node);
					}
					
					/*
					if (Renderer.currentObject && Renderer.currentObject.isContent) {						
						this.objectTree[id].setInactive();
						this.objectTree[id].hideNavi();
					} else {
						Renderer.currentObject = this.objectTree[id];
					}
					*/
				}		
				HTML.addClass(content, "RendererCardContent");
				HTML.addClass(this.div, "RendererCard");
				break;
			default:
				break;
		}//endswitch
		this.domTree["_object"] = content;
	}
};
Renderer.abstractObject.prototype.prepareContent = function() {
};
Renderer.abstractObject.prototype.setStatus = function(text) {
	this.clearStatus();
	this.status = HTML.makeElement(
						"p",
						["class"],
						["StatusBar"],
						text);
	HTML.setStatus(this.status);
};
Renderer.abstractObject.prototype.clearStatus = function() {
	HTML.removeStatus(this.status);
};
Renderer.abstractObject.prototype.appendObject = function(object) {
	this.childObjects.push(object);
	object.parentObject = this;
};
Renderer.abstractObject.prototype.getFirstContent = function() {
	var ret, obj, i;
	if (this.isContent) {
		ret = this;
	} else {
		ret = false;
		for (i = 0; i < this.childObjects.length; i++) {
			obj = this.childObjects[i];
			obj = obj.getFirstContent();
			if (obj) {
				ret = obj;
				break;
			}
		}
	}
	return ret;
};
/*
Renderer.abstractObject.prototype.nextStep = function() {
	var id, i, bool = false;
	for (i = 0; i < this.data._objects.length; i++) {
		id = this.data._objects[i].id;
		if (bool == true) {
			break;
		}
		if (this.curr_object == id) {
			bool = true;
		}
	}
	if (this.curr_object != id) {
		this.curr_object = id;
		this.prepareObject();
		this.showContent();
	} else {
		//this.div.removeChild(this.buttonTree["next"]);
		while (this.div.hasChildNodes())
			this.div.removeChild(this.div.firstChild);
		if (this.showResults)
			this.showResults();
		else this.div.appendChild(HTML.makeElement(
									"p",
									[],
									[],
									HTML.lookup("Der Container wurde vollständig bearbeitet!")));
	}
};
*/


//© 2010 Daniel Schulz

Renderer.Container = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "Container";
				
	this.domTree = {
		//_title : "",
		_object : null
	};
	this.buttonTree = {
		"next" : null
	};
	
	this.isContent = false;
	this.isContainer = true;
}
Renderer.Container.prototype = new Renderer.abstractObject();

Renderer.Container.prototype.prepareObject = function() {


};


// © 2012 Daniel Schulz

var Trait = {
	use : function(targetObject, traitName) {
		var i,
			traitObject = this[traitName];
		if (traitObject.uses) {
			for (i = 0; i < traitObject.uses.length; i++) {
				this.use(targetObject, traitObject.uses[i]);
			}
		}
		targetObject.prototype[traitName] = traitObject.construct
			? traitObject.construct
			: function() {};
		if (traitObject.vars) {
			for (i in traitObject.vars) {
				targetObject.prototype[i] = traitObject.vars[i];
			}
		}
		if (traitObject.methods) {
			for (i in traitObject.methods) {
				targetObject.prototype[i] = traitObject.methods[i];
				targetObject.prototype[traitName + i[0].toUpperCase() + i.substr(1)] = traitObject.methods[i];
			}
		}
	},
	build : function(traitObject) {
		var i, targetObject;
		targetObject = traitObject.construct
			? traitObject.construct
			: function() {};
		if (traitObject.uses) {
			for (i = 0; i < traitObject.uses.length; i++) {
				this.use(targetObject, traitObject.uses[i]);
			}
		}
		if (traitObject.vars) {
			for (i in traitObject.vars) {
				targetObject.prototype[i] = traitObject.vars[i];
			}
		}
		if (traitObject.methods) {
			for (i in traitObject.methods) {
				targetObject.prototype[i] = traitObject.methods[i];
			}
		}
		return targetObject;
	}
};

/*
Trait.Example = {
	uses : [
	],
	construct : function() {
		this.data += " welt";
	},
	vars : {
		data : "hallo",
	},
	methods : {
		init : function() {
		}
	}
};

var ProjectClass = Trait.build({
	uses : [
	],
	construct : function() {
	},
	vars : {
	},
	methods : {
	}
});
//*/


// © 2012 Daniel Schulz

Trait.ControllerCommand = {
	uses : [
	],
	construct : function() {
	},
	vars : {
		controllerCommand : {
			events : {
				click : function(eve) {
					var i, nodeList, node, param, attr, key, val;
					attr = "data-command-param-";
					param = {};
					nodeList = XPath.evaluate("@*[starts-with(name(), '"+attr+"')]", this);
					for (i = 0; i < nodeList.length; i++) {
						node = nodeList[i];
						key = XPath.evaluate("substring-after(name(), '"+attr+"')", node);
						val = XPath.evaluate("normalize-space(.)", node);
						if (key.length) {
							param[key] = val;
						}
					}
					this.ownerController.parseCommand(this.getAttribute("data-command"), this, param);
				},
			},
		}
	},
	methods : {
		draw : function() {
			var nodeList, i;
			if (this.drawFragment) {
				nodeList = XPath.evaluate(".//html:button[@data-command]", this.drawFragment);
				for (i = 0; i < nodeList.length; i++) {
					nodeList[i].ownerController = this;
					nodeList[i].addEventListener(
						"click",
						this.controllerCommand.events.click,
						false
					);
				}
				nodeList = XPath.evaluate(".//html:select[@data-command]", this.drawFragment);
				for (i = 0; i < nodeList.length; i++) {
					nodeList[i].ownerController = this;
					nodeList[i].addEventListener(
						"change",
						this.controllerCommand.events.click,
						false
					);
				}
				nodeList = XPath.evaluate("//*[@data-tab = 'parent']", this.drawFragment);
				for (i = 0; i < nodeList.length; i++) {
					LearningObject.Tab.build(nodeList[i]);
				}
			}
		},
		parseCommand : function(name, targetNode, param) {
			if (!param) {
				param = {};
			}
		},
	}
};


Trait.ControllerMoveable = {
	uses : [
	],
	construct : function() {
	},
	vars : {
		controllerMoveable : {
			events : {
				dragstart : function(eve) {
					try {
						this.setAttribute("data-status", "inuse");
						eve.dataTransfer.setData("text", this.getAttribute("data-model-path"));
					} catch(e) {
					}
				},
				dragend : function(eve) {	
					try {
						this.removeAttribute("data-status");
					} catch(e) {
					}
				},
				dragover : function(eve) {
					eve.preventDefault();
					eve.dataTransfer.dropEffect = "move";
				},
				dragoverInput : function(eve) {
					eve.preventDefault();
					eve.dataTransfer.dropEffect = "copy";
				},
				drop : function(eve) {
					eve.preventDefault();
					
					try {
						var targetSocketPath, targetItemPath, sourceSocketPath, sourceItemPath;
	
						targetSocketPath = this.getAttribute("data-model-path");
						targetItemPath = XPath.evaluate("string(*/@data-model-path)", this);
						sourceItemPath = eve.dataTransfer.getData("text");
						sourceSocketPath = sourceItemPath + "/..";
						if (targetItemPath) {
							this.ownerController.switchItems(targetItemPath, sourceItemPath);
						} else {
							this.ownerController.moveItem(targetSocketPath, sourceItemPath);
						}
					} catch(e) {
					}
				},
				dropInput : function(eve) {
					eve.preventDefault();
					
					try {
						var sourceItemPath;
						sourceItemPath = eve.dataTransfer.getData("text");
						this.ownerController.setInput(this, sourceItemPath);
					} catch(e) {
					}
				},
			}
		}
	},
	methods : {
		draw : function() {
			var nodeList, node, i, func, isDisabled, type;
			nodeList = XPath.evaluate(".//*[@data-moveable]", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.ownerController = this;
				type = node.getAttribute("data-moveable");
				isDisabled = node.hasAttribute("data-moveable-disabled");
				
				if (isDisabled) {
					switch (type) {
						case "item":
							node.setAttribute("draggable", "false");
							break;
						case "socket":
							break;
					}
				} else {
					switch (type) {
						case "item":
							node.setAttribute("draggable", "true");
							node.addEventListener(
								"dragstart",
								this.controllerMoveable.events.dragstart,
								false
							);
							node.addEventListener(
								"dragend",
								this.controllerMoveable.events.dragend,
								false
							);
							break;
						case "socket":
							node.addEventListener(
								"dragover",
								this.controllerMoveable.events.dragover,
								false
							);
							node.addEventListener(
								"drop",
								this.controllerMoveable.events.drop,
								false
							);
							break;
					}
				}
			}
			nodeList = XPath.evaluate(".//html:input | .//html:select", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.ownerController = this;
				node.addEventListener(
					"dragover",
					this.controllerMoveable.events.dragoverInput,
					false
				);
				node.addEventListener(
					"drop",
					this.controllerMoveable.events.dropInput,
					false
				);
			}
		},
		moveItem : function(socketPath, itemPath) {
			if (this.updateInput) {
				this.updateInput();
			}
			this.ownerView.model.data.moveItemsByPath(socketPath, itemPath);
			this.ownerView.model.sendMessage(ACTION.VIEW_REDRAW);
		},
		switchItems : function(sourcePath, targetPath) {
			var sourceNode, sourceParentNode, targetNode, targetParentNode;
			
			sourceNode = this.ownerView.model.data.getItemByPath(sourcePath);
			sourceParentNode = this.ownerView.model.data.getItemByPath(sourcePath + "/..");
			targetNode = this.ownerView.model.data.getItemByPath(targetPath);
			targetParentNode = this.ownerView.model.data.getItemByPath(targetPath + "/..");
			if (sourceParentNode && targetNode) {
				sourceParentNode.appendChild(targetNode);
			}
			if (targetParentNode && sourceNode) {
				targetParentNode.appendChild(sourceNode);
			}
			this.ownerView.model.sendMessage(ACTION.VIEW_REDRAW);
		},
		setInput : function(inputNode, sourcePath) {
			var sourceNode;
			
			sourceNode = this.ownerView.model.data.getItemByPath(sourcePath);
			inputNode.value = sourceNode.getAttribute("input-value");
		},
	}
};


// © 2012 Daniel Schulz

Trait.LOEditor = {
	uses : [
		"ViewElement",
		"ControllerCommand",
		"ControllerMoveable",
	],
	construct : function(ownerView, viewId, templateDoc) {
		this.ViewElement(ownerView, viewId, templateDoc);
		this.ControllerCommand();
		this.widgets = {};
		this.ownerView.controller.loadView("obj-mediaPicker", this, function(childView) { this.widgets["mediaPicker"] = childView; });
		this.ownerView.controller.loadView("obj-stylePicker", this, function(childView) { this.widgets["stylePicker"] = childView; });
		this.ownerView.controller.loadView("obj-tablePicker", this, function(childView) { this.widgets["tablePicker"] = childView; });
		this.ownerView.controller.requestDraw();
		this.clearClipboard();
		
		this.ownerDocument.documentElement.setAttribute("style", "margin-top: 5em;"); //<header data-editor-toolbox>
	},
	vars : {
		editorNodeList : undefined,
		inputNodeList : undefined,
		selectNodeList : undefined,
		imageNodeList : undefined,
		tableNodeList : undefined,
		widgets : undefined,
		currentTextarea 	: undefined,
		currentSelection 	: undefined,
		currentRange 		: undefined,
		currentCursorBackup : undefined,
		currentImagePath	: undefined,
		currentTablePath	: undefined,
		clipboardData		: undefined,
		LOEditorEvents : {
			editorClick : function(eve) {
				//this.ownerView.updateCursor();
			},
			editorBlur : function(eve) {
				//this.ownerView.updateCursor();
				console.log("this.ownerView.updateEditorNodes");
				this.ownerView.updateEditorNodes();
				//this.ownerView.parseCommand("draw");
			},
			inputBlur : function(eve) {
				//this.ownerView.updateCursor();
				this.ownerView.updateInputNodes();
				this.ownerView.parseCommand("draw");
			},
			selectBlur : function(eve) {
				//this.ownerView.updateCursor();
				this.ownerView.updateSelectNodes();
				this.ownerView.parseCommand("draw");
			},
			imageFocus : function(eve) {
				console.log("Focusing on image %o", this);
				//this.ownerView.updateCursor();
				this.ownerView.setCurrentImageNode(this);
			},
			tableFocus : function(eve) {
				console.log("Focusing on table %o", this);
				//this.ownerView.updateCursor();
				this.ownerView.setCurrentTableNode(this);
			},
			cursorChange : function(eve) {
				this.ownerView.updateCursor();
			},
		},
	},
	methods : {
		draw : function() {
			var nodeList, viewName, i, j;
			this.ViewElementDraw();
			if (this.widgets) {
				for (viewName in this.widgets) {
					if (nodeList = XPath.evaluate(".//*[@data-lo-id = '"+viewName+"']", this.drawFragment)) {
						//for (i = 0; i < nodeList.length; i++) {
							this.widgets[viewName].setDrawParent(nodeList);
							this.widgets[viewName].draw();
						//}
					} else {
						//alert(".//*[@data-lo-id = '"+viewName+"']");
					}
				}
			}
			if (this.getClipboard("html")) {
				nodeList = XPath.evaluate(".//*[@data-command='html-paste']", this.drawFragment);
				for (i = 0; i < nodeList.length; i++) {
					nodeList[i].disabled = false;
				}
			}
			
			this.ControllerMoveableDraw();
			this.ControllerCommandDraw();
			this.restoreCursor();
			
			this.editorNodeList = XPath.evaluate(".//*[@contenteditable][@data-model-path]", this.drawFragment);
			this.inputNodeList = XPath.evaluate(".//html:input[@data-model-path]", this.drawFragment);
			this.selectNodeList = XPath.evaluate(".//html:select[@data-model-path]", this.drawFragment);
			
			this.imageNodeList = XPath.evaluate(".//html:img | .//html:audio | .//html:video", this.editorNodeList);
			this.tableNodeList = XPath.evaluate(".//html:table", this.editorNodeList);
			
			/*
			this.dropzoneNodeList = XPath.evaluate(".//*[@dropzone]", this.drawFragment);
			this.draggableNodeList = XPath.evaluate(".//*[@dropzone]//*[@data-media-type]", this.drawFragment);
			for (i = 0; i < this.dropzoneNodeList.length; i++) {
				this.dropzoneNodeList[i].ownerView = this;
				this.dropzoneNodeList[i].addEventListener(
					"drop",
					function(eve) {
						eve.preventDefault();
						//alert(eve.dataTransfer.getData("text/html"));//getData("application/xml"));
						//eve.dataTransfer.dropEffect = "copy";
						//alert(eve.dataTransfer.dropEffect);
						//eve.preventDefault();
						//alert(eve.originalEvent.target);
					},
					false
				);
			}
			for (i = 0; i < this.draggableNodeList.length; i++) {
				this.draggableNodeList[i].ownerView = this;
				this.draggableNodeList[i].draggable = true;
				this.draggableNodeList[i].contentEditable = "false";
				this.dropzoneNodeList[i].addEventListener(
					"dragstart",
					function(eve) {
						eve.dataTransfer.setData("application/xml", DOM.saveXML(this));
						//eve.dataTransfer.dropEffect = "copy";
					},
					false
				);
				nodeList = XPath.evaluate(".//*", this.draggableNodeList[i]);
				for (j = 0; j < nodeList.length; j++) {
					nodeList[j].draggable = false;
					nodeList[j].contentEditable = "false";
				}
			}
			//*/
			for (i = 0; i < this.editorNodeList.length; i++) {
				this.editorNodeList[i].ownerView = this;
				this.editorNodeList[i].addEventListener(
					"blur",
					this.LOEditorEvents.editorBlur,
					false
				);
				this.editorNodeList[i].addEventListener(
					"click",
					this.LOEditorEvents.editorClick,
					false
				);
				this.editorNodeList[i].addEventListener(
					"mousemove",
					this.LOEditorEvents.cursorChange,
					false
				);
			}
			for (i = 0; i < this.inputNodeList.length; i++) {
				this.inputNodeList[i].ownerView = this;
				this.inputNodeList[i].addEventListener(
					"change",
					this.LOEditorEvents.inputBlur,
					false
				);
			}
			for (i = 0; i < this.selectNodeList.length; i++) {
				this.selectNodeList[i].ownerView = this;
				this.selectNodeList[i].addEventListener(
					"change",
					this.LOEditorEvents.selectBlur,
					false
				);
			}
			for (i = 0; i < this.imageNodeList.length; i++) {
				this.imageNodeList[i].ownerView = this;
				this.imageNodeList[i].setAttribute("tabindex", "0");
				this.imageNodeList[i].addEventListener(
					"focus",
					this.LOEditorEvents.imageFocus,
					false
				);
			}
			for (i = 0; i < this.tableNodeList.length; i++) {
				this.tableNodeList[i].ownerView = this;
				this.tableNodeList[i].setAttribute("tabindex", "0");
				this.tableNodeList[i].addEventListener(
					"focus",
					this.LOEditorEvents.tableFocus,
					false
				);
			}
			
			this.clearError();
			
			//console.log("LOEditor finished drawing!");
			
			if (this.widgets) {
				if (this.widgets.mediaPicker) {
					this.widgets.mediaPicker.setCurrentNode(this.getCurrentImageNode());
				}
				if (this.widgets.tablePicker) {
					this.widgets.tablePicker.setCurrentNode(this.getCurrentTableNode());
				}
			}
		},
		getCurrentTextarea : function() {
			return this.currentTextarea;
		},
		getCurrentSelection : function() {
			return this.currentSelection;
		},
		getCurrentRange : function() {
			return this.currentRange;
		},
		getCurrentImageNode : function() {
			var ret = false, node;
			if (this.currentImagePath) {
				//alert("getting image:\n" + this.currentImagePath);
				if (node = XPath.evaluate(this.currentImagePath, document)) {
					if (node = node[0]) {
						ret = node;
					}
				}
			}
			return ret;
		},
		setCurrentImageNode : function(node) {
			//alert("setting image:\n" + XPath.createPath(node));
			//console.log("setting image: %o", XPath.createPath(node));
			this.currentImagePath = XPath.createPath(node);
			if (this.widgets && this.widgets.mediaPicker) {
				this.widgets.mediaPicker.setCurrentNode(node);
			}
		},
		getCurrentTableNode : function() {
			var ret = false, node;
			if (this.currentTablePath) {
				//alert("getting table:\n" + this.currentTablePath);
				if (node = XPath.evaluate(this.currentTablePath, document)) {
					if (node = node[0]) {
						ret = node;
					}
				}
			}
			return ret;
		},
		setCurrentTableNode : function(node) {
			//alert("setting image:\n" + XPath.createPath(node));
			//console.log("setting image: %o", XPath.createPath(node));
			this.currentTablePath = XPath.createPath(node);
			if (this.widgets && this.widgets.tablePicker) {
				this.widgets.tablePicker.setCurrentNode(node);
			}
		},
		clearCurrentTableNode : function() {
			this.currentTablePath = "";
			if (this.widgets && this.widgets.tablePicker) {
				this.widgets.tablePicker.setCurrentNode(null);
			}
		},
		parseCommand : function(name, targetNode, param) {
			var node, nodeList, i, dataPath, dataNode, 
				currentTextarea, currentSelection, currentRange,
				currentStyledBlock, currentStyledInline,
				currentStyledTable, currentStyledTableRow, currentStyledTableCell,
				skipDraw = false;
			if (!param) {
				param = {};
			}
			this.clearError();
			
			this.updateCursor();
			
			currentTextarea = this.getCurrentTextarea();
			currentSelection = this.getCurrentSelection();
			currentRange = this.getCurrentRange();
			
			currentStyledBlock = null;
			currentStyledInline = null;
			if (currentRange) {
				try {
					/*
					if (currentTextarea) {
						testRange = document.createRange();
						testRange.selectNodeContents(currentTextarea);
						alert([currentRange.compareBoundaryPoints(Range.START_TO_START, testRange), currentRange.compareBoundaryPoints(Range.END_TO_END, testRange)]);
					}
					//*/
					
					/*
					alert([
					XPath.evaluate("string(ancestor-or-self::*[starts-with(@data-style, 'block-')][1]/@data-style)", currentRange.commonAncestorContainer),
					XPath.evaluate("string(ancestor-or-self::*[starts-with(@data-style, 'block-')][2]/@data-style)", currentRange.commonAncestorContainer),
					XPath.evaluate("string(ancestor-or-self::*[starts-with(@data-style, 'block-')][3]/@data-style)", currentRange.commonAncestorContainer),
					]);
					//*/
					if (node = XPath.evaluate("ancestor-or-self::*[ancestor::*[@contenteditable]][last()]", currentRange.commonAncestorContainer)[0]) {
						currentStyledBlock = node;
					}
					if (node = XPath.evaluate("ancestor-or-self::*[starts-with(@data-style, 'block-')][1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledBlock = node;
					}
					if (node = XPath.evaluate("descendant-or-self::*[starts-with(@data-style, 'block-')][1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledBlock = node;
					}
					if (node = XPath.evaluate("ancestor-or-self::*[starts-with(@data-style, 'inline-')][1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledInline = node;
					}
					if (node = XPath.evaluate("descendant-or-self::*[starts-with(@data-style, 'inline-')][1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledInline = node;
					}
					if (node = XPath.evaluate("ancestor-or-self::*[parent::html:tr][1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledTableCell = node;
					}
					if (node = XPath.evaluate("ancestor-or-self::html:tr[1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledTableRow = node;
					}
					if (node = XPath.evaluate("ancestor-or-self::html:table[1]", currentRange.commonAncestorContainer)[0]) {
						currentStyledTable = node;
					}
				} catch(e) {
					this.setError(e, "parseCommand.currentRange");
				}
			}
			
			
			if (targetNode) {
				dataPath = XPath.evaluate("string(ancestor-or-self::*[@data-model-path][1]/@data-model-path)", targetNode);
				if (dataPath.length) {
					dataNode = XPath.evaluate(dataPath, this.data.dataDoc)[0];
				}
				if (!dataNode) {
					console.log("Data node not found?! %o", dataPath);
					console.log(targetNode);
					console.log(XPath.evaluate("//lodb:exercise", this.data.dataDoc));
				}
			}
			try {
				switch (name) {
					case "reset":
						loadLearningObject(this.ownerView.model.data.id, "editor", this.ownerView.langId);
						this.ownerView.controller.exit();
						return;
					case "draw":
						break;
					case "apply":
					case "update":
						this.updateEditorNodes();
						this.updateInputNodes();
						this.updateSelectNodes();
						break;
					case "save":
						this.updateEditorNodes();
						this.updateInputNodes();
						this.updateSelectNodes();
						
						this.ownerView.sendMessage(ACTION.CONTROLLER_DATA_SAVE);
						/*
						//wait to let the updating complete (öhhh)
						window.setTimeout(
							function() {
								//console.log("this.ownerView.model.parseMessage(ACTION.MODEL_DATA_SAVE);");
								this.ownerView.model.parseMessage(ACTION.MODEL_DATA_SAVE);
							}.bind(this)
						);
						//*/
						break;
					case "stylePicker-cleanse":
						skipDraw = true;
						if (currentRange) {
							if (currentRange.collapsed) {
								var node = currentRange.commonAncestorContainer.parentNode;
								if (!node.hasAttribute("contenteditable")) {
									while (node.hasChildNodes()) {
										node.parentNode.insertBefore(node.firstChild, node);
									}
									node.parentNode.removeChild(node);
									this.updateCursor();
									this.updateEditorNodes();
									skipDraw = false;
								}
							} else {
								var node = currentRange.extractContents();
								node = document.createTextNode(node.textContent);
								currentRange.insertNode(node);
								this.updateCursor();
								this.updateEditorNodes();
								skipDraw = false;
							}
						}
						break;
					case "stylePicker-remove-inline":
						skipDraw = true;
						if (currentStyledInline && currentStyledInline.parentNode) {
							while (currentStyledInline.hasChildNodes()) {
								currentStyledInline.parentNode.insertBefore(currentStyledInline.firstChild, currentStyledInline);
							}
							currentStyledInline.parentNode.removeChild(currentStyledInline);
							this.updateEditorNodes();
							skipDraw = false;
						}
						break;
					case "stylePicker-remove-block":
						skipDraw = true;
						if (currentStyledBlock && currentStyledBlock.parentNode) {
							//alert(currentStyledBlock.getAttribute("data-style"));
							while (currentStyledBlock.hasChildNodes()) {
								currentStyledBlock.parentNode.insertBefore(currentStyledBlock.firstChild, currentStyledBlock);
							}
							currentStyledBlock.parentNode.removeChild(currentStyledBlock);
							this.updateCursor();
							this.updateEditorNodes();
							skipDraw = false;
						}
						break;
					case "stylePicker-remove-inline-unused":
						if (currentStyledInline && currentStyledInline.parentNode) {
							while (currentStyledInline.hasChildNodes()) {
								currentStyledInline.parentNode.insertBefore(currentStyledInline.firstChild, currentStyledInline);
							}
							currentStyledInline.parentNode.removeChild(currentStyledInline);
							this.updateEditorNodes();
						}
						break;
					case "stylePicker-insert":
						if (currentRange && param.parentNode) {
							node = param.parentNode;
							//currentRange.surroundContents(node);
							node.appendChild(currentRange.extractContents());
							currentRange.insertNode(node);
							this.updateCursor();
							this.updateEditorNodes();
						}
						break;
					case "mediaPicker-append-image":
						var tmp;
						nodeList = targetNode.getElementsByTagName("img");
						for (i = 0; i < nodeList.length; i++) {
							tmp = {};
							tmp.objType = "lo_img";
							tmp.mediaURI = nodeList[i].getAttribute("src");
							tmp.objRef = nodeList[i].getAttribute("data-obj-ref");
							node = this.widgets.mediaPicker.createMediaNode(tmp);
							if (currentRange && node) {
								currentRange.insertNode(node);
								
								this.setCurrentCursor(node, false);
								this.setCurrentImageNode(node);
							
								this.updateCursor();
								this.updateEditorNodes();
							}
						}
						skipDraw = true;
						break;
					case "mediaPicker-append-audio":
						var tmp;
						nodeList = targetNode.getElementsByTagName("audio");
						for (i = 0; i < nodeList.length; i++) {
							tmp = {};
							tmp.objType = "lo_audio";
							tmp.mediaURI = nodeList[i].getAttribute("src");
							tmp.objRef = nodeList[i].getAttribute("data-obj-ref");
							node = this.widgets.mediaPicker.createMediaNode(tmp);
							if (currentRange && node) {
								currentRange.insertNode(node);
								
								this.setCurrentCursor(node, false);
								this.setCurrentImageNode(node);
							
								this.updateCursor();
								this.updateEditorNodes();
							}
						}
						skipDraw = true;
						break;
					case "mediaPicker-append-video":
						var tmp;
						nodeList = targetNode.getElementsByTagName("video");
						for (i = 0; i < nodeList.length; i++) {
							tmp = {};
							tmp.objType = "lo_video";
							tmp.mediaURI = nodeList[i].getAttribute("src");
							tmp.objRef = nodeList[i].getAttribute("data-obj-ref");
							node = this.widgets.mediaPicker.createMediaNode(tmp);
							if (currentRange && node) {
								currentRange.insertNode(node);
								
								this.setCurrentCursor(node, false);
								this.setCurrentImageNode(node);
							
								this.updateCursor();
								this.updateEditorNodes();
							}
						}
						skipDraw = true;
						break;
					case "mediaPicker-append":
						throw "deprecated command: mediaPicker-append";
					case "text-bold":
						document.execCommand("bold", false, null);
						this.updateEditorNodes();
						return;
					case "text-italic":
						document.execCommand("italic", false, null);
						this.updateEditorNodes();
						return;
					case "text-underline":
						document.execCommand("underline", false, null);
						this.updateEditorNodes();
						return;
					case "html-cut":
						skipDraw = true;
						if (currentRange) {
							var fragment = currentRange.extractContents();
							currentRange.collapse();
							
							if (fragment.firstChild) {
								this.setClipboard("html", fragment);
								this.updateCursor();
								this.updateEditorNodes();
								skipDraw = false;
							}
						}
						break;
					case "html-copy":
						skipDraw = true;
						if (currentRange) {
							var fragment = currentRange.cloneContents();
							if (fragment.firstChild) {
								this.setClipboard("html", fragment);
								//this.updateCursor();
								//this.updateEditorNodes();
								skipDraw = false;
							}
						}
						break;
					case "html-paste":
						skipDraw = true;
						if (currentRange) {
							var fragment = this.getClipboard("html");
							if (fragment) {
								fragment = fragment.cloneNode(true);
								var startNode = fragment.firstChild;
								var endNode = fragment.lastChild;
								currentRange.extractContents();
								currentRange.insertNode(fragment);
								
								//currentRange.setStartBefore(startNode);
								currentRange.setStartAfter(endNode);
								currentRange.setEndAfter(endNode);
								
								//this.updateCursor();
								//this.updateEditorNodes();
								//skipDraw = false;
							}
						}
						break;
					case "html-delete":
						skipDraw = true;
						if (currentRange) {
							var fragment = currentRange.extractContents();
							if (fragment.firstChild) {
								this.updateCursor();
								this.updateEditorNodes();
								skipDraw = false;
							}
						}
						break;
					case "text-media-popup":
						if (currentStyledInline) {
							//this.widgets.mediaPicker.pickMedia(currentStyledInline);
						} else if (currentStyledBlock) {
							//this.widgets.mediaPicker.pickMedia(currentStyledBlock);
						}
						if (currentRange) {
							this.widgets.mediaPicker.pickMedia(currentRange, this);
							return;
						}
						break;
					case "text-image":
						var input;
						input = currentRange.toString().trim();
						if (!input.length) {
							try {
								input = prompt("Bild URL?").trim();
							} catch(e) {
								this.setError(e, "parseCommand.prompt");
								input = "";
							}
						}
						if (input.length && currentRange) {
							node = document.createElementNS(NS.HTML, "img");
							node.setAttribute("src", input);
							node.setAttribute("alt", input);
							
							currentRange.deleteContents();
							currentRange.insertNode(node);
							this.updateEditorNodes();
						}
						break;
					case "text-link":
						skipDraw = true;
						if (currentRange && !currentRange.collapsed) {
							var href;
							try {
								href = prompt("Link URL:").trim();
							} catch(e) {
								href = "";
								this.setError(e, "parseCommand.prompt");
							}
							if (href.length) {
								node = document.createElementNS(NS.HTML, "a");
								node.setAttribute("data-style", "inline-link");
								node.setAttribute("href", href);
								node.setAttribute("target", "_blank");
								
								node.appendChild(currentRange.extractContents());
								currentRange.insertNode(node);
								
								this.updateCursor();
								this.updateEditorNodes();
								skipDraw = false;
							}
						}
						break;
					case "text-dict":
						skipDraw = true;
						if (currentRange && !currentRange.collapsed) {
							var title;
							try {
								title = prompt("Tooltip:").trim();
							} catch(e) {
								title = "";
								this.setError(e, "parseCommand.prompt");
							}
							if (title.length) {
								node = document.createElementNS(NS.HTML, "abbr");
								node.setAttribute("data-style", "inline-dict");
								node.setAttribute("title", title);
								
								node.appendChild(currentRange.extractContents());
								currentRange.insertNode(node);
								
								this.updateCursor();
								this.updateEditorNodes();
								skipDraw = false;
							}
						}
						break;
					case "text-dict-clear":
						skipDraw = true;
						if (currentRange && !currentRange.collapsed) {
							var el = null;
							if(currentRange.commonAncestorContainer.parentElement.attributes[0].value == "inline-dict") {
								el = currentRange.startContainer.parentElement;
							}
							else if(currentSelection.focusNode.previousElementSibling !== null && currentSelection.focusNode.previousElementSibling.attributes[0].value == "inline-dict") {
								el = currentSelection.focusNode.previousElementSibling;
							}
							else if(currentRange.startOffset > currentRange.endOffset && currentRange.endOffset > 0) {
								alert("Firefox bug! Bitte nicht das ganze Wort markieren.");
							}
							
							if(el !== null) {
								var parent = el.parentNode;
								while (el.firstChild) {
									parent.insertBefore(el.firstChild, el);
								}
								parent.removeChild(el);
							}
						}
						break;
					case "text-audio":
						var input;
						input = currentRange.toString().trim();
						if (!input.length) {
							try {
								input = prompt(".ogg URL?").trim();
							} catch(e) {
								this.setError(e, "parseCommand.prompt");
								input = "";
							}
						}
						if (input.length && currentRange) {
							node = document.createElementNS(NS.HTML, "audio");
							node.setAttribute("src", input);
							node.setAttribute("controls", "controls");
							
							currentRange.deleteContents();
							currentRange.insertNode(node);
							this.updateEditorNodes();
						}
						break;
					case "text-video":
						var input;
						input = currentRange.toString().trim();
						if (!input.length) {
							try {
								input = prompt(".webm URL?").trim();
							} catch(e) {
								this.setError(e, "parseCommand.prompt");
								input = "";
							}
						}
						if (input.length && currentRange) {
							node = document.createElementNS(NS.HTML, "video");
							node.setAttribute("src", input);
							node.setAttribute("controls", "controls");
							
							currentRange.deleteContents();
							currentRange.insertNode(node);
							this.updateEditorNodes();
						}
						break;
					case "text-ul-create":
						if (currentRange) {
							node = document.createElementNS(NS.HTML, "ul");
							node.setAttribute("data-style", "block-list");
							var fragment = currentRange.extractContents();
							while (fragment.hasChildNodes()) {
								switch (fragment.firstChild.localName) {
									case "br":
										fragment.removeChild(fragment.firstChild);
										break;
									default:
										node.appendChild(document.createElementNS(NS.HTML, "li"));
										node.lastChild.appendChild(fragment.firstChild);
								}
							}
							currentRange.insertNode(node);
							this.updateEditorNodes();
						}
						break;
					case "text-ol-create":
						if (currentRange) {
							node = document.createElementNS(NS.HTML, "ol");
							node.setAttribute("data-style", "block-list");
							var fragment = currentRange.extractContents();
							while (fragment.hasChildNodes()) {
								switch (fragment.firstChild.localName) {
									case "br":
										fragment.removeChild(fragment.firstChild);
										break;
									default:
										node.appendChild(document.createElementNS(NS.HTML, "li"));
										node.lastChild.appendChild(fragment.firstChild);
								}
							}
							currentRange.insertNode(node);
							this.updateEditorNodes();
						}
						break;
					case "text-table-create":
						//var html = '<table data-style="block-table"><caption>undefined</caption><thead><tr><td>Heading Cell 1</td><td>Heading Cell 2</td></tr></thead><tfoot><tr><td>Footing Cell 1</td><td>Footing Cell 2</td></tr></tfoot><tbody><tr><td>Row 1 Column 1</td><td>Row 1 Column 2</td></tr><tr><td>Row 2 Column 1</td><td>Row 2 Column 2</td></tr></tbody></table>';
						var html = '<table data-style="block-table" data-table-border="collapse vertical horizontal"><tr><td>Row 1 Column 1</td><td>Row 1 Column 2</td></tr><tr><td>Row 2 Column 1</td><td>Row 2 Column 2</td></tr></table>';
						
						if (currentRange) {
							node = document.createElementNS(NS.HTML, "div");
							node.innerHTML = html;
							currentRange.insertNode(node);
							
							this.setCurrentTableNode(node.querySelector("table"));
							
							this.setCurrentCursor(node.querySelector("td"), true);
							
							this.updateCursor();
							this.updateEditorNodes();
						}
						break;
					case "text-table-remove":
						var newNode;
						if (currentStyledTable) {
							newNode = currentStyledTable.parentNode;
							
							currentStyledTable.parentNode.removeChild(currentStyledTable);
							this.clearCurrentTableNode();
							
							this.setCurrentCursor(newNode, false);
							
							this.updateCursor();
							this.updateEditorNodes();
						}
						skipDraw = true;
						break;
					case "text-row-create":
						var currentIndex;
						var newNode;
						if (currentStyledTable && currentStyledTableRow) {
							
							currentIndex = currentStyledTableRow.rowIndex;
							currentIndex++;
							node = currentStyledTable.insertRow(currentIndex);
							for (i = 0; i < currentStyledTableRow.cells.length; i++) {
								newNode = node.insertCell(i);
							}
							if (currentStyledTableCell) {
								newNode = currentStyledTable.rows[currentIndex].cells[currentStyledTableCell.cellIndex];
							}
							
							this.setCurrentCursor(newNode, true);
							
							this.updateCursor();
							this.updateEditorNodes();
						}
						skipDraw = true;
						break;
					case "text-row-remove":
						var currentIndex;
						var newNode;
						if (currentStyledTable && currentStyledTableRow) {
							newNode = currentStyledTableRow.nextSibling
								? currentStyledTableRow.nextSibling
								: currentStyledTableRow.previousSibling;
							if (newNode) {
								if (currentStyledTableCell && newNode.cells[currentStyledTableCell.cellIndex]) {
									newNode = newNode.cells[currentStyledTableCell.cellIndex];
								} else {
									newNode = newNode.lastChild;
								}
							}
							if (!newNode) {
								newNode = currentStyledTable;
							}
							
							currentIndex = currentStyledTableRow.rowIndex;
							currentStyledTable.deleteRow(currentIndex);
							
							if (!(currentStyledTable.rows.length && currentStyledTable.rows[0].cells.length)) {
								//Tabelle leer, löschen...
								return this.parseCommand("text-table-remove", targetNode, param);
							}
							
							this.setCurrentCursor(newNode, true);
							
							this.updateCursor();
							this.updateEditorNodes();
						}
						skipDraw = true;
						break;
					case "text-col-create":
						var currentIndex;
						var newNode;
						if (currentStyledTable && currentStyledTableCell) {
							currentIndex = currentStyledTableCell.cellIndex;
							currentIndex++;
							for (i = 0; i < currentStyledTable.rows.length; i++) {
								newNode = currentStyledTable.rows[i].insertCell(currentIndex);
							}
							if (currentStyledTableRow) {
								newNode = currentStyledTable.rows[currentStyledTableRow.rowIndex].cells[currentIndex];
							}
							
							this.setCurrentCursor(newNode, true);
							
							this.updateCursor();
							this.updateEditorNodes();
						}
						skipDraw = true;
						break;
					case "text-col-remove":
						var currentIndex;
						var newNode;
						if (currentStyledTable && currentStyledTableCell) {
							newNode = currentStyledTableCell.nextSibling
								? currentStyledTableCell.nextSibling
								: currentStyledTableCell.previousSibling;
							if (!newNode) {
								newNode = currentStyledTable;
							}
							
							currentIndex = currentStyledTableCell.cellIndex;
							for (i = 0; i < currentStyledTable.rows.length; i++) {
								currentStyledTable.rows[i].deleteCell(currentIndex);
							}
							if (!(currentStyledTable.rows.length && currentStyledTable.rows[0].cells.length)) {
								//Tabelle leer, löschen...
								return this.parseCommand("text-table-remove", targetNode, param);
							}
							
							this.setCurrentCursor(newNode, true);
							
							this.updateCursor();
							this.updateEditorNodes();
						}
						skipDraw = true;
						break;
					case "move-up":
						if (dataNode && dataNode.previousElementSibling) {
							dataNode.parentNode.insertBefore(dataNode, dataNode.previousElementSibling);
							if (XPath.evaluate("boolean(self::lodb:page)", dataNode)) {
								if (node = LearningObject.Tab.getTabByModelPath("/lodb:exercise")) {	//hack: unschön!
									node.setTab(node.currentTab - 1);
								}
							}
						}
						break;
					case "move-down":
						if (dataNode && dataNode.nextElementSibling) {
							dataNode.parentNode.insertBefore(dataNode.nextElementSibling, dataNode);
							if (XPath.evaluate("boolean(self::lodb:page)", dataNode)) {
								if (node = LearningObject.Tab.getTabByModelPath("/lodb:exercise")) {	//hack: unschön!
									node.setTab(node.currentTab + 1);
								}
							}
						}
						break;
					case "page-cut-task":
						if (dataNode) {
							this.setClipboard("lodb", dataNode);
						}
						break;
					case "page-copy-task":
						if (dataNode) {
							this.setClipboard("lodb", dataNode.cloneNode(true));
						}
						break;
					case "page-paste-task":
						var tmpNode;
						if (tmpNode = this.getClipboard("lodb")) {
							if (dataNode.ownerDocument === tmpNode.ownerDocument) {
								dataNode.appendChild(tmpNode);
								this.clearClipboard();
							}
						}
						break;
					//Tasks
					case "page-append-quiz":
						node = this.ownerView.model.data.createQuiz();
						dataNode.appendChild(node);
						break;
					case "page-append-itemMapping":
						node = this.ownerView.model.data.createItemMapping();
						dataNode.appendChild(node);
						break;
					case "page-append-categoryMapping":
						node = this.ownerView.model.data.createCategoryMapping();
						dataNode.appendChild(node);
						break;
					case "page-append-sentenceMapping":
						node = this.ownerView.model.data.createSentenceMapping();
						dataNode.appendChild(node);
						break;
					case "page-append-pictureMapping":
						node = this.ownerView.model.data.createPictureMapping();
						dataNode.appendChild(node);
						break;
					case "page-append-cloze":
						node = this.ownerView.model.data.createCloze();
						dataNode.appendChild(node);
						break;
					case "page-append-essay":
						node = this.ownerView.model.data.createEssay();
						dataNode.appendChild(node);
						break;
					case "page-append-text":
						node = this.ownerView.model.data.createText();
						dataNode.appendChild(node);
						break;
					//Games
					case "page-append-quizCapture":
						node = this.ownerView.model.data.createQuizCapture();
						dataNode.appendChild(node);
						break;
					case "page-append-quizUncover":
						node = this.ownerView.model.data.createQuizUncover();
						dataNode.appendChild(node);
						break;
					case "page-append-memory":
						node = this.ownerView.model.data.createMemory();
						dataNode.appendChild(node);
						break;
					case "page-append-crossword":
						node = this.ownerView.model.data.createCrossword();
						dataNode.appendChild(node);
						break;
					case "page-append-categoryCapture":
						node = this.ownerView.model.data.createCategoryCapture();
						dataNode.appendChild(node);
						break;
					case "page-append-marqueeCapture":
						node = this.ownerView.model.data.createMarqueeCapture();
						dataNode.appendChild(node);
						break;
					case "page-append-categoryUncover":
						node = this.ownerView.model.data.createCategoryUncover();
						dataNode.appendChild(node);
						break;
					case "page-append-clozeUncover":
						node = this.ownerView.model.data.createClozeUncover();
						dataNode.appendChild(node);
						break;
					case "memory-append-memoryMatch":
						node = this.ownerView.model.data.createMemoryMatch();
						dataNode.appendChild(node);
						break;
					case "crossword-append-crosswordMatch":
						node = this.ownerView.model.data.createCrosswordMatch();
						dataNode.appendChild(node);
						break;
					//task elements
					case "quiz-append-question":
					case "quizCapture-append-question":
					case "quizUncover-append-question":
						node = this.ownerView.model.data.createQuestion();
						dataNode.appendChild(node);
						break;
					case "quiz-append-question":
						node = this.ownerView.model.data.createQuestion();
						dataNode.appendChild(node);
						break;
					case "quiz-append-answer":
						node = this.ownerView.model.data.createAnswer("", false);
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break;
					case "exercise-append-hint":
						node = this.ownerView.model.data.createHint("");
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break
					case "quiz-change-type":
						if (dataNode.value !== targetNode.value) {
							dataNode.value = targetNode.value;
							switch (targetNode.value) {
								case "yes-no":
									dataNode = XPath.evaluate("lodb:answerList", dataNode.ownerElement)[0];
									if (dataNode) {
										var arr = [];
										arr.push(this.ownerView.translateString("##/lang/quiz/yes##"));
										arr.push(this.ownerView.translateString("##/lang/quiz/no##"));
										this.ownerView.model.data.setAnswerList(dataNode, arr);
									}
									break;
							}
						}
						break;
					case "cloze-append-answer":
						node = this.ownerView.model.data.createSimpleAnswer("", true);
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break;
					case "essay-append-answerSet":
						node = this.ownerView.model.data.createKeywordAnswerSet([""], true);
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break;
					case "essay-append-answer":
						node = this.ownerView.model.data.createKeywordAnswer("", true);
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break;
					case "mapping-append-answer":
						node = null;
						switch (dataNode.localName) {
							case "answerSet":
								node = this.ownerView.model.data.createAnswer("", true);
								break;
							case "simpleAnswerSet":
								node = this.ownerView.model.data.createSimpleAnswer("", true);
								break;
							default:
								alert("unknown mapping-append-answer: " + dataNode.localName);
								break;
						}
						if (node) {
							this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						}
						break;
					case "mapping-append-wronganswer":
						node = this.ownerView.model.data.createAnswer("", true);
						node.setAttribute("correct", "0");
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break;
					case "sentenceMapping-append-answer":
						node = this.ownerView.model.data.createAnswerSet([""]);
						this.ownerView.model.data.appendNodesByPath(dataPath, [node]);
						break;
					case "sentenceMapping-append-alternative":
						if (node = XPath.evaluate("lodb:answerSequence[1]", dataNode)[0]) {
							dataNode.appendChild(node.cloneNode(true));
						}
						break;
					case "exercise-append-page":
						node = this.ownerView.model.data.createPage();
						dataNode.appendChild(node);
						//ownerTab/headList/targetNode
						if (node = LearningObject.Tab.getTabByModelPath(dataPath)) {
							node.setTab(node.bodyList.length);
						}
						break;
					case "exercise-remove-page":
						if (window.confirm(this.ownerView.translateString("##/lang/remove/confirm##" + dataPath))) {
							this.ownerView.model.data.removeNodesByPath(dataPath);
							if (node = LearningObject.Tab.getTabByModelPath("/lodb:exercise")) {	//hack: unschön!
								node.setTab(node.currentTab - 1);
							}
						}
					break;
					case "exercise-remove-hint":
					case "quiz-remove-question":
					case "quiz-remove-answer":
					case "mapping-remove-match":
					case "mapping-remove-answer":
					case "mapping-remove-wronganswer":
					case "sentenceMapping-remove-answer":
					case "sentenceMapping-remove-alternative":
					case "cloze-remove-answer":
					case "page-remove-task":
					case "essay-remove-answerSet":
					case "essay-remove-answer":
						if (window.confirm(this.ownerView.translateString("##/lang/remove/confirm##" + dataPath))) {
							this.ownerView.model.data.removeNodesByPath(dataPath);
						}
						break;
					case "mapping-append-match":
						node = null;
						switch (dataNode.localName) {
							case "itemMapping":
								node = this.ownerView.model.data.createItemMatch();
								break;
							case "memory":
								node = this.ownerView.model.data.createMemoryMatch();
								break;
							case "crossword":
								node = this.ownerView.model.data.createCrosswordMatch();
								break;
							case "categoryMapping":
							case "categoryCapture":
							case "categoryUncover":
								node = this.ownerView.model.data.createCategoryMatch();
								break;
							case "marqueeCapture":
								node = this.ownerView.model.data.createMarqueeMatch();
								break;
							default:
								alert("unknown mapping-append-match: " + dataNode.localName);
								break;
						}
						if (node) {
							dataNode.appendChild(node);
						}
						break;
					case "mapping-append-answerReference":
						if (currentRange) {
							if (node = currentRange.startContainer) {
								if (XPath.evaluate("boolean(ancestor-or-self::*[@data-page-element='answerReferenceText'])", node)) {
									if (targetNode) {
										currentRange.deleteContents();
										node = this.ownerView.model.data.createAnswerReference(targetNode.getAttribute("data-argument"));
										node = document.importNode(node, true);
										currentRange.insertNode(node);
										this.updateEditorNodes();
									}
								}
							}
						}
						break;
					case "pictureMapping-append-match":
						node = targetNode.parentNode.nextElementSibling.firstChild;
						if (!node._loEditor) {
							node._loEditor = this;
							node._loData = null;
							node.setAttribute("data-editor-pictureMapping", "click");
							node.addEventListener(
								"click",
								function(eve) {
									if (this._loData) {
										var x1, x2, y1, y2;
										if (eve.offsetX < this._loData.x) {
											x1 = eve.offsetX;
											x2 = this._loData.x;
										} else {
											x2 = eve.offsetX;
											x1 = this._loData.x;
										}
										if (eve.offsetY < this._loData.y) {
											y1 = eve.offsetY;
											y2 = this._loData.y;
										} else {
											y2 = eve.offsetY;
											y1 = this._loData.y;
										}
										
										this._loData.x = x1;
										this._loData.y = y1;
										this._loData.width = x2 - x1;
										this._loData.height = y2 - y1;
										
										this._loEditor.parseCommand("pictureMapping-append-match-click", this, this._loData);
									} else {
										this._loData = {};
										this._loData.x = eve.offsetX;
										this._loData.y = eve.offsetY;
									}
								},
								false
							);
						}
						skipDraw = true;
						targetNode.disabled = true;
						break;
					case "pictureMapping-append-match-click":
						node = this.ownerView.model.data.createPictureMatch(param.x, param.y, param.width, param.height);
						dataNode.parentNode.appendChild(node);
						break;
					case "sentenceMapping-append-match":
						node = this.ownerView.model.data.createSentenceMatch();
						dataNode.appendChild(node);
						break;
					case "cloze-append-gap":
						var gapAnswer;
						if (currentRange) {
							if (node = currentRange.startContainer) {
								if (XPath.evaluate("boolean(ancestor-or-self::*[@data-page-element='clozeText'])", node)) {
									gapAnswer = currentRange.toString().trim();
									if (!gapAnswer.length) {
										try {
											gapAnswer = prompt("Antwort?").trim();
										} catch(e) {
											this.setError(e, "parseCommand.prompt");
											gapAnswer = "";
										}
									}
									if (gapAnswer.length) {
										currentRange.deleteContents();
										node = this.ownerView.model.data.createGap([gapAnswer]);
										node = document.importNode(node, true);
										currentRange.insertNode(node);
										this.updateEditorNodes();
									}
								}
							}
						}
						break;
					case "cloze-remove-gap":
						var gapAnswer;
						if (currentRange && currentRange.startContainer) {
							let startNodes = new Set(XPath.evaluate("ancestor-or-self::lodb:gap | following::lodb:gap", currentRange.startContainer));
							let endNodes = new Set(XPath.evaluate("ancestor-or-self::lodb:gap | preceding::lodb:gap", currentRange.endContainer));
							let commonNodes = [...startNodes].filter(x => endNodes.has(x));
							
							for (i = 0; i < commonNodes.length; i++) {
								node = commonNodes[i];
								gapAnswer = XPath.evaluate("string(lodb:simpleAnswerSet/lodb:simpleAnswer[@correct=1])", node);
								node.parentNode.replaceChild(node.ownerDocument.createTextNode(gapAnswer), node);
								this.updateEditorNodes();
							}
						}
						break;
					default:
						skipDraw = true;
						break;
				}
				if (!skipDraw) {
					this.ownerView.draw();
				}
			} catch(e) {
				this.setError(e, "parseCommand");
			}
		},
		dispatchMouseEvent : function(eveName, options) {
			var eve, defaultOptions, key;
			defaultOptions = {};
			defaultOptions.bubbles = true;
			defaultOptions.cancelable = true;
			defaultOptions.view = window;
			defaultOptions.detail = 1;
			defaultOptions.screenX = 0;
			defaultOptions.screenY = 0;
			defaultOptions.clientX = 0;
			defaultOptions.clientY = 0;
			defaultOptions.ctrlKey = false;
			defaultOptions.altKey = false;
			defaultOptions.shiftKey = false;
			defaultOptions.metaKey = false;
			defaultOptions.button = 0;
			defaultOptions.relatedTarget = null;
			defaultOptions.target = document;
			
			try {
				for (key in defaultOptions) {
					if (typeof options[key] === "undefined") {
						options[key] = defaultOptions[key];
					}
				}
				
				eve = document.createEvent("MouseEvents");
				eve.initMouseEvent(
					eveName,
					options.bubbles, options.cancelable, options.view, options.detail,
					options.screenX, options.screenY, options.clientX, options.clientY,
					options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
					options.button, options.relatedTarget
				);
				//console.log("Dispatching MouseEvent %o on Node %o", eve, options.target);
				options.target.dispatchEvent(eve);
			} catch(e) {
				console.log("ERROR dispatching MouseEvent: %o", e);
			}
		},
		updateEditorNodes : function() {
			var node, i, tmpNodeList, j, tmpNode, removeNodeList, removeAttrList, removeNodeIndex, removeNodeName;
			removeNodeList = ["comment()"];
			removeAttrList = ["style", "color", "class", "border"];	//, "bgcolor"
			for (i = 0; i < this.editorNodeList.length; i++) {
				node = this.editorNodeList[i];
				node.appendChild(node.ownerDocument.createTextNode(" "));
				while (true) {
					if (tmpNodeList = XPath.evaluate("descendant::node()", node)) {
						if (tmpNode = tmpNodeList.pop()) {
							//"self::html:br | self::text()[normalize-space(.) = '']"
							if (tmpNodeList = XPath.evaluate("self::html:br", tmpNode)) {
								if (tmpNode = tmpNodeList.pop()) {
									tmpNode.parentNode.removeChild(tmpNode);
									continue;
								}
							}
						}
					}
					break;
				}
				
				/*
				j = /[  ][  ]+/g;
				while (true) {
					if (tmpNodeList = XPath.evaluate("(descendant-or-self::text()[contains(., '  ')])[1]", node)) {
						if (tmpNode = tmpNodeList.pop()) {
							i = tmpNode.nodeValue;
							while (j.test(i)) {
								i = i.replace(j, " ");
							}
							tmpNode.nodeValue = i;
							continue;
						}
					}
					break;
				}
				//*/
				
				for (removeNodeIndex = 0; removeNodeIndex < removeNodeList.length; removeNodeIndex++) {
					removeNodeName = removeNodeList[removeNodeIndex];
					tmpNodeList = XPath.evaluate(".//"+removeNodeName, node);
					for (j = 0; j < tmpNodeList.length; j++) {
						if (tmpNodeList[j].parentNode) {
							tmpNodeList[j].parentNode.removeChild(tmpNodeList[j]);
						}
					}
				}
				for (removeNodeIndex = 0; removeNodeIndex < removeAttrList.length; removeNodeIndex++) {
					removeNodeName = removeAttrList[removeNodeIndex];
					tmpNodeList = XPath.evaluate(".//*[@"+removeNodeName+"]", node);
					for (j = 0; j < tmpNodeList.length; j++) {
						tmpNodeList[j].removeAttribute(removeNodeName);
					}
				}
				//*/
				this.ownerView.model.data.replaceChildNodesByPath(node.getAttribute("data-model-path"), node);
			}
		},
		updateInputNodes : function() {
			var node, i;
			for (i = 0; i < this.inputNodeList.length; i++) {
				node = this.inputNodeList[i];
				switch (node.getAttribute("type")) {
					case "number":
						this.ownerView.model.data.replaceAttributeByPath(node.getAttribute("data-model-path"), node.value);
						break;
					case "checkbox":
					case "radio":
						this.ownerView.model.data.replaceAttributeByPath(node.getAttribute("data-model-path"), 0+node.checked);
						break;
					default:
						if (node.getAttribute("value") !== node.value) {
							node.setAttribute("value", node.value);
							node.value = XPath.evaluate("normalize-space(@value)", node);
							if (node.getAttribute("value") !== node.value) {
								node.setAttribute("value", node.value);
							}
						}
						break;
				}
			}
		},
		updateSelectNodes : function() {
			var node, i;
			for (i = 0; i < this.selectNodeList.length; i++) {
				node = this.selectNodeList[i];
				this.ownerView.model.data.replaceAttributeByPath(node.getAttribute("data-model-path"), node.value);
				//alert([node.getAttribute("data-model-path"), node.value]);
			}
		},
		setCurrentCursor : function(newNode, selectContents) {
			var newSelection, newRange;
			if (newNode) {
				newSelection = window.getSelection();
				newSelection.removeAllRanges();
				newRange = document.createRange();
				if (selectContents) {
					newRange.selectNodeContents(newNode);
				} else {
					newRange.selectNode(newNode);
				}
				newSelection.addRange(newRange);
			}
		},
		updateCursor : function() {
			var newSelection, newRange, newTextarea, setCurrent, node;
			try {
				if (newSelection = window.getSelection()) {
					if (!newSelection.rangeCount) {
						//add custom Range
					}
					if ((newSelection.rangeCount > 0) && (newRange = newSelection.getRangeAt(0))) {
						//check if new selection is inside contenteditable
						if (node = newRange.commonAncestorContainer) {
							if (newTextarea = XPath.evaluate("ancestor-or-self::*[@contenteditable]", node)[0]) {
								this.currentTextarea = newTextarea;
								this.currentSelection = newSelection;
								this.currentRange = newRange;
								this.backupCursor();
								
							}
						}
					}
				}
			} catch(e) {
				this.setError(e, "updateCursor");
			}
		},
		backupCursor : function() {
			if (this.currentTextarea) {
				this.currentCursorBackup = {};
				this.currentCursorBackup.textarea = XPath.createPath(this.currentTextarea);
				this.currentCursorBackup.rangeStartContainer = XPath.createPath(this.currentRange.startContainer);
				this.currentCursorBackup.rangeStartOffset = this.currentRange.startOffset;
				this.currentCursorBackup.rangeEndContainer = XPath.createPath(this.currentRange.endContainer);
				this.currentCursorBackup.rangeEndOffset = this.currentRange.endOffset;
			}
		},
		restoreCursor : function() {
			var newSelection, newRange, newTextarea, setCurrent, startNode, endNode;
			if (this.currentCursorBackup) {
				try {
					newTextarea = XPath.evaluate(this.currentCursorBackup.textarea, document)[0];
					startNode = XPath.evaluate(this.currentCursorBackup.rangeStartContainer, document)[0];
					endNode = XPath.evaluate(this.currentCursorBackup.rangeEndContainer, document)[0];
					if (newTextarea && startNode && endNode) {
						newSelection = window.getSelection();
						newSelection.removeAllRanges();
						newRange = document.createRange();
						try {
							newRange.setStart(startNode, this.currentCursorBackup.rangeStartOffset);
							newRange.setEnd(endNode, this.currentCursorBackup.rangeEndOffset);
						} catch(e) {
							this.setError(e, "restoreCursor.setStart");
							newRange.selectNode(startNode);
						}
						newSelection.addRange(newRange);
						
						this.currentTextarea = newTextarea;
						this.currentSelection = newSelection;
						this.currentRange = newRange;
					}
				} catch(e) {
					this.setError(e, "restoreCursor.setStart");
				}
			}
		},
		getClipboard : function(key) {
			return this.clipboardData[key];
		},
		setClipboard : function(key, data) {
			this.clipboardData[key] = data;
		},
		clearClipboard : function() {
			this.clipboardData = {};
		},
		clearError: function() {
		},
		setError : function(text, func) {
			console.log("LOEditor Error!");
			if (func) {
				console.log("	Function: %o", func);
			}
			console.log("	Exception: %o", text);
		},
	}	
};


// © 2012 Daniel Schulz

Trait.ViewNode = {
	uses : [
	],
	construct : function(ownerView, viewId) {
		this.ownerView = ownerView;
		this.ownerDocument = ownerView.ownerDocument;
		this.viewId = viewId;
		this.childViews = [];
	},
	vars : {
		viewId				: undefined,	//int
		ownerView			: undefined,	//View Document
		parentView			: undefined,	//View Node
		childViews 			: undefined,	//View Elements
		ownerDocument 		: undefined,	//SVG DOM Document
		drawParent			: undefined,	//DOM Parent Node
		drawFragment 		: undefined,	//DOM Fragment
	},
	methods : {
		appendView : function(viewNode) {
			this.childViews.push(viewNode);
			viewNode.ownerView = this.ownerView;
			viewNode.parentView = this;
		},
		setDrawParent : function(node) {
			if (node instanceof Array) {
				node = node[0];
			}
			if (node) {
				this.drawParent = node;
				if (this.drawFragment) {
					this.drawParent.appendChild(this.drawFragment);
				}
			}
		},
		draw : function() {
			if (this.drawParent) {
				while (this.drawParent.hasChildNodes()) {
					this.drawParent.removeChild(this.drawParent.lastChild);
				}
			}
		},
	}	
};

Trait.ViewElement = {
	uses : [
		"ViewNode"
	],
	construct : function(ownerView, viewId, templateDoc) {
		this.templateDoc = templateDoc;
		this.dataDoc = this.templateDoc.implementation.createDocument(null, null, null);
		this.ViewNode(ownerView, viewId);
	},
	vars : {
		templateDoc			: undefined,	//XSL DOM Document
		dataDoc				: undefined,	//XML DOM Document
		data				: undefined,	//{}
	},
	methods : {
		setData : function(data) {
			this.data = data;
		},
		asNode : function(dataDoc) {
			alert("asNode not yet implemented for: " + this.constructor);
		},
		draw : function() {
			//this.ViewNodeDraw();
			var i, delList = [], audioListPre = [], audioListPost = [];
			if (this.drawParent) {
				delList = XPath.evaluate("node()", this.drawParent);
			}
			if (this.drawFragment) {
				audioListPre = XPath.evaluate(".//html:audio", this.drawFragment);
				//if (audioListPre[0]) alert("77: " + audioListPre[0].paused);
			}
			var node;
			try {
				while (this.dataDoc.hasChildNodes()) {
					this.dataDoc.removeChild(this.dataDoc.lastChild);
				}
				node = this.asNode(this.dataDoc);
				this.dataDoc.appendChild(node);
				this.drawFragment = XSLT.transformToNode(
					this.dataDoc,
					this.templateDoc,
					this.ownerDocument
				);
				this.drawFragment = this.ownerView.translate(this.drawFragment);
			} catch(e) {
				console.log("ViewElement.draw Error!");
				console.log("	Exception: %o", e);
				this.drawFragment = this.ownerDocument.createTextNode(e);
			}
			if (this.drawParent && this.drawFragment) {
				this.drawParent.appendChild(this.drawFragment);
			}
			if (this.drawFragment) {
				audioListPost = XPath.evaluate(".//html:audio", this.drawFragment);
				//if (audioListPre[0]) alert("100: " + audioListPre[0].paused);
				if (audioListPre.length === audioListPost.length) {
					for (i = 0; i < audioListPre.length; i++) {
						audioListPost[i].parentNode.replaceChild(audioListPre[i], audioListPost[i]);
					}
				}
				//if (audioListPre[0]) alert("106: " + audioListPre[0].paused);
			}
			for (i = 0; i < delList.length; i++) {
				if (delList[i] && delList[i].parentNode) {
					delList[i].parentNode.removeChild(delList[i]);
				}
			}
		},
	}
};
Trait.ViewElementList = {
	uses : [
		"ViewElement"
	],
	construct : function(ownerView, viewId, templateDoc) {
		this.drawFragment = [];
		this.drawParent = [];
		
		this.ViewElement(ownerView, viewId, templateDoc);
	},
	vars : {
		drawElement : undefined,
	},
	methods : {
		draw : function() {
			//this.ViewNodeDraw();
			var i, delList = [], resNode;
			if (this.drawParent) {
				delList = XPath.evaluate("node()", this.drawParent);
			}
			var node;
			try {
				while (this.dataDoc.hasChildNodes()) {
					this.dataDoc.removeChild(this.dataDoc.lastChild);
				}
				node = this.asNode(this.dataDoc);
				this.dataDoc.appendChild(node);
				resNode = XSLT.transformToNode(
					this.dataDoc,
					this.templateDoc,
					this.ownerDocument
				);
				this.drawElement = this.ownerView.translate(resNode);
			} catch(e) {
				console.log("ViewElementList.draw Error!");
				console.log("	Exception: %o", e);
				this.drawElement = this.ownerDocument.createTextNode(e);
			}
			this.syncDrawParent();
			/*
			if (this.drawParent && this.drawElement) {
				this.drawFragment = [];
				for (i = 0; i < this.drawParent.length; i++) {
					this.drawFragment[i] = this.drawElement.cloneNode(true);
					this.drawParent[i].appendChild(this.drawFragment[i]);
				}
			}
			//*/
			for (i = 0; i < delList.length; i++) {
				if (delList[i] && delList[i].parentNode) {
					delList[i].parentNode.removeChild(delList[i]);
				}
			}
		},
		syncDrawParent : function() {
			var newDrawFragment, delList;
			if (this.drawElement) {
				newDrawFragment = [];
				delList = this.drawFragment;
				for (var i = 0; i < this.drawParent.length; i++) {
					for (var j = 0; j < this.drawFragment.length; j++) {
						if (this.drawFragment[j] && this.drawFragment[j].parentNode === this.drawParent[i]) {
							//newDrawFragment[i] = this.drawFragment[j];
							//delList[j] = null;
							break;
						}
					}
					if (!newDrawFragment[i]) {
						newDrawFragment[i] = this.drawElement.cloneNode(true);
						this.drawParent[i].appendChild(newDrawFragment[i]);
					}
				}
				for (var i = 0; i < delList.length; i++) {
					if (delList[i] && delList[i].parentNode) {
						delList[i].parentNode.removeChild(delList[i]);
					}
				}
				this.drawFragment = newDrawFragment;
			}
		},
		setDrawParent : function(node) {
			if (node instanceof Array) {
				this.drawParent = node;
			} else {
				this.drawParent = [node];
			}
			this.syncDrawParent();
		},
		clearDrawParent : function() {
			this.drawParent = [];
			this.syncDrawParent();
		},
		appendDrawParent : function(node) {
			this.drawParent.push(node);
			this.syncDrawParent();
		},
	}
};

Trait.ViewDocument = {
	uses : [
		"ViewNode"
	],
	construct : function(viewPrototypes, ownerDocument) {
		this.viewPrototypes = viewPrototypes;
		this.ownerDocument = ownerDocument;
		this.ownedViewCount = 0;
		this.ownedViews = {
			0 : this
		};
		this.ViewNode(this, this.ownedViewCount);
	},
	vars : {
		viewPrototypes		: undefined,	//View Prototypes
		ownedViews			: undefined,	//View Elements
		ownedViewCount		: undefined,	//last View ID
	},
	methods : {
		appendView : function(viewNode) {
			this.childViews = [];
			this.ViewNodeAppendView(viewNode);
		},
		createView : function(viewName) {
			this.ownedViewCount++;
			this.ownedViews[this.ownedViewCount] = new this.viewPrototypes[viewName](this, this.ownedViewCount);
			return this.ownedViews[this.ownedViewCount];
		},
		loadView : function(viewName, viewData, viewParentId, viewCallback) {
			var viewNode, viewParent;
			viewNode = this.createView(viewName);
			viewParent = this.getViewById(viewParentId);
			if (viewNode) {
				viewNode.setData(viewData);
				if (viewParent) {
					viewParent.appendView(viewNode);
					if (viewCallback) {
						viewCallback.call(viewParent, viewNode);
					}
					//viewParent.draw();
				} else {
					alert("viewParentId not found: "+viewParentId);
				}
			}
			return viewNode;
		},
		getViewById : function(viewId) {
			if (this.ownedViews[viewId]) {
				return this.ownedViews[viewId];
			}
			return undefined;
		},
		draw : function() {
			//alert(XPath.createPath(this.drawParent));
			this.ViewNodeDraw();
			var i;
			if (this.drawParent) {
				var delList = [];
				for (i = 0; i < this.drawParent.childNodes.length; i++) {
					delList.push(this.drawParent.childNodes[i]);
				}
				/*
				while (this.drawParent.hasChildNodes()) {
					this.drawParent.removeChild(this.drawParent.lastChild);
				}
				//*/
				//this.drawFragment = this.ownerDocument.createDocumentFragment();
				for (i = 0; i < this.childViews.length; i++) {
					this.childViews[i].setDrawParent(this.drawParent);
					this.childViews[i].draw();
				}
				//this.drawParent.appendChild(this.drawFragment);
				
				for (i = 0; i < delList.length; i++) {
					delList[i].parentNode.removeChild(delList[i]);
				}
			}
		},
		translate : function(sourceFragment) {
			return sourceFragment;
		},
		makeElement : function(tagName, attributeMap, childNodes) {
			var retNode = this.ownerDocument.createElementNS(this.ownerDocument.namespaceURI, tagName);
			if (attributeMap) {
				var key;
				for (key in attributeMap) {
					retNode.setAttribute(key, attributeMap[key]);
				}
			}
			if (childNodes) {
				var i;
				for (i = 0; i < childNodes.length; i++) {
					retNode.appendChild(childNodes[i]);
				}
			}
			return retNode;
		},
	}
};


/*******************************************************************************
 * XPath v1.01 08.04.2014 © Daniel Schulz
 * 
 * 	Changelog:
 *		v1.01 08.04.2014
 *			window.wgxpath
 * 		v1.00 02.08.2013
 * 			initial release
 ******************************************************************************/

var XPath = {
	evaluate : function(query, contextNode) {
		var ownerDoc, res, ret, tmp, isTextNode;
		if (contextNode instanceof Array) {
			ret = [];
			for (var i = 0; i < contextNode.length; i++) {
				res = this.evaluate(query, contextNode[i]);
				if (res instanceof Array) {
					ret = ret.concat(res);
				} else {
					ret.push(res);
				}
			}
			return ret;
		}
		try {
			ownerDoc = contextNode.nodeType === Node.DOCUMENT_NODE
				? contextNode
				: contextNode.ownerDocument;
			//use wgxpath
			if (window.wgxpath) {
				if (!window.document.evaluate) {
					console.log("installing wgxpath on %o", window);
					window.wgxpath.install(window);
				}
				if (!ownerDoc.evaluate) {
					//console.log("installing wgxpath on %o", ownerDoc);
					//window.wgxpath.install( { document : ownerDoc } );
				}
			}
			
			//alert(ownerDoc + "\n" + ownerDoc.evaluate + "\n" + ownerDoc.selectNodes);
			isTextNode = false;
			if (contextNode.nodeType === Node.TEXT_NODE) {
				if (contextNode.nodeValue === "") {
					contextNode.nodeValue = " ";
					isTextNode = true;
				}
			}
			if (!ownerDoc.evaluate) {
				document.removeChild(document.documentElement);
				document.appendChild(document.createElement("pre"));
				document.documentElement.textContent = "Sorry, this app requires your browser to support XPath.\nPlease upgrade to Mozilla Firefox, Google Chrome, or Opera.";
				throw "XPath not supported.";
			}
			
			res = ownerDoc.evaluate(query, contextNode, NS.resolver, XPathResult.ANY_TYPE, null);
			switch (res.resultType) {
				case XPathResult.NUMBER_TYPE:
					ret = res.numberValue;
					break;
				case XPathResult.STRING_TYPE:
					ret = res.stringValue;
					break;
				case XPathResult.BOOLEAN_TYPE:
					ret = res.booleanValue;
					break;
				default:
					ret = [];
					while (tmp = res.iterateNext()) {
						ret.push(tmp);
					}
					break;
			}
			if (isTextNode) {
				contextNode.nodeValue = "";
			}
			return ret;
		} catch(e) {
			window.console.log("XPath error!");
			window.console.log("Query: %o", query);
			window.console.log("Context node: %o", contextNode);
			window.console.log("	Exception: %o", e);
			throw e;
		}
	},
	createPath : function(contextNode) {
		var node, nodeList, i, ret = [""], tag, precedingList, followingList;
		nodeList = this.evaluate("ancestor-or-self::node()", contextNode);
		for (i = 0; i < nodeList.length; i++) {
			node = nodeList[i];
			switch (node.nodeType) {
				case node.TEXT_NODE:
					tag = "text()";
					break;
				case node.ELEMENT_NODE:
					tag = NS.prefixer(node.namespaceURI) + ":" + node.localName;
					break;
				default:
					tag = false;
					break;
			}
			if (tag) {
				precedingList = XPath.evaluate("preceding-sibling::" + tag, node);
				followingList = XPath.evaluate("following-sibling::" + tag, node);
				if (precedingList.length + followingList.length) {
					tag += "[" + (precedingList.length + 1) + "]";
				}
				ret.push(tag);
			}
		}
		return ret.join("/");
	},
};


// © 2013 Daniel Schulz

var XSLT = {
	transformToFragment : function(dataNode, templateDoc, ownerDoc) {
		var nodeList, node, i, tmpDoc, uri,
			xslt,
			retFragment = false;
		try {
			//xsl:import parsen, für Chrome+Safari
			//*
			while (node = XPath.evaluate("//xsl:import", templateDoc)[0]) {
				uri = node.getAttribute("href");
				if (uri[0] !== "/") {
					uri = templateDoc.fileURI + "/../" + uri;
				}
				if (tmpDoc = DOM.loadDocument(uri)) {
					nodeList = XPath.evaluate("/xsl:stylesheet/*", tmpDoc);
					for (i = 0; i < nodeList.length; i++) {
						node.parentNode.appendChild(templateDoc.importNode(nodeList[i], true));
					}
				}
				node.parentNode.removeChild(node);
			}
			//*/
			//throw "Testing api.xslt!";
			if (window.XSLTProcessor) {
				xslt = new XSLTProcessor();
				xslt.importStylesheet(templateDoc);
				retFragment = xslt.transformToFragment(dataNode, ownerDoc);
				if (!retFragment) {
					throw "XSLTProcessor.transformToFragment returned null!";
				}
			} else {
				/*
				var xmlDoc = new ActiveXObject("Msxml2.DOMDocument.6.0");
				xmlDoc.loadXML(DOM.saveXML(dataNode));
				
				var xslDoc = new ActiveXObject("Msxml2.DOMDocument.6.0");
				xslDoc.async = false;
				xslDoc.load(templateDoc.fileURI);
				
				console.log("transforming...");
				var resultXML = xmlDoc.transformNode(xslDoc);	//doesn't work: doesn't process xsl:import
				if (!resultXML) {
					throw "Msxml2.DOMDocument.6.0.transformNode returned an empty string!";
				}
				console.log(resultXML);
				
				var resultDoc = DOM.loadXML(resultXML);
				if (!resultDoc.documentElement) {
					throw "Msxml2.DOMDocument.6.0.transformNode returned an empty document!";
				}
				retFragment = ownerDoc.createDocumentFragment();
				retFragment.appendChild(ownerDoc.importNode(resultDoc.documentElement, true));
				//*/
				throw "YOUR BROWSER IS SHIT LEAVE ME ALONE";
			}
			/*
			if (window.ActiveXObject) {
				xslt = new ActiveXObject("Msxml2.XSLTemplate.6.0");
				//var xmlDoc = new ActiveXObject("Msxml2.DOMDocument");
				//var xslDoc = new ActiveXObject("Msxml2.FreeThreadedDOMDocument");
				xslt.stylesheet = templateDoc;
				xslt = xslt.createProcessor();
				xslt.input = dataNode;
				xslt.transform();
				if (!xslProc.output) {
					throw "Msxml2.XSLTemplate.transform returned null!";
				}
				retFragment = ownerDoc.createDocumentFragment();
				retFragment.appendChild(ownerDoc.importNode(xslProc.output, true));
			}
			//*/
		} catch(e) {
			var doc, uri;
			//ownerDoc.importNode(req.responseXML.documentElement, true);
			console.log("An error occured while attempting to XSL transform. :|");
			console.log("	Data node: %o", dataNode);
			console.log("	Template document: %o", templateDoc);
			console.log("	Owner document: %o", ownerDoc);
			console.log("	Exception: %o", e);
			uri = "/sites/www/scripts/LearningObject/api.xslt.php?template=" + templateDoc.fileURI;
			doc = DOM.saveDocument(uri, dataNode);
			retFragment = ownerDoc.createDocumentFragment();
			retFragment.appendChild(ownerDoc.importNode(doc.documentElement, true));
		}
		//console.log("XSLT complete!");
		return retFragment;
	},
	transformToNode : function(dataNode, templateDoc, ownerDoc) {
		return this.transformToFragment(dataNode, templateDoc, ownerDoc).firstChild;
	},
};


var ACTION = {
	DEBUG : -1,
	
	CONTROLLER_START : 100,
	MODEL_START : 200,
	VIEW_START : 300,
	CONTROLLER_END : 199,
	MODEL_END : 299,
	VIEW_END : 399,
	
	CONTROLLER_DATA_SHUFFLE : 122,
	CONTROLLER_DATA_SAVE : 123,
	CONTROLLER_DATA_HELP : 124,
	
	MODEL_DATA_SET_ID : 210,
	MODEL_DATA_SET_DOC : 211,
	MODEL_DATA_SET_COURSE : 212,
	MODEL_DATA_LOAD : 220,
	MODEL_DATA_SAVE : 221,
	MODEL_DATA_SHUFFLE : 222,
	MODEL_DATA_LOG_START : 230,
	MODEL_DATA_LOG_VERIFY : 231,
	MODEL_DATA_LOG_SUBMIT : 232,
	MODEL_DATA_HELP : 233,
	MODEL_VIEW_LOAD : 240,
	MODEL_VIEW_REDRAW : 241,
	
	VIEW_VIEW_LOAD : 330,
	VIEW_REDRAW : 331,
	VIEW_INPUT_UPDATE : 332,
	VIEW_BUSY_START : 333,
	VIEW_BUSY_FINISH : 334,
};

var LearningObject = Trait.build({
	uses : [
	],
	construct : function() {
		this.controller = new LearningObject.Controller();
		this.view 		= new LearningObject.View();
		this.model 		= new LearningObject.Model();
		
		this.model.model 			= this.model;
		this.model.view 			= this.view;
		this.model.controller 		= this.controller;
		this.view.model 			= this.model;
		this.view.view 				= this.view;
		this.view.controller 		= this.controller;
		this.controller.model 		= this.model;
		this.controller.view 		= this.view;
		this.controller.controller 	= this.controller;
		
		this.controller.start();
	},
	vars : {
		model		: undefined,
		view		: undefined,
		controller	: undefined,
	},
	methods : {
	}
});

LearningObject.PATH_TEMPLATES = "/sites/www/scripts/LearningObject/xslt/";


LearningObject.Controller = Trait.build({
	uses : [
	],
	construct : function() {
		this.eventList = [];
	},
	vars : {
		model		: undefined,
		view		: undefined,
		controller	: undefined,
		
		eventList : undefined,
		events : {
			postMessage : function(mvc, action, payload) {
				if (mvc) {
					mvc.parseMessage(action, payload);
				} else {
					alert("Your browser doesn't support HTML5's setTimeout: http://www.w3.org/TR/2011/WD-html5-20110113/timers.html (lol)");
				}
			},
		},
		actionCodes : {
			loadData : function(param) {
				this.loadDataById(param);
			},
			loadView : function(param) {
				this.loadView(param);
			},
		},
	},
	methods : {
		start : function() {
			var config = { test : "" };
			config.test += "♪";
			this.sendMessage(ACTION.MODEL_START, config);
		},
		exit : function() {
			this.sendMessage(ACTION.MODEL_END);
		},
		end : function() {
			LearningObject.Tab.clear();
		},
		init : function(config) {
		},
		sendMessage : function(action, payload) {
			window.setTimeout(
				this.events.postMessage,
				0,
				this.model,
				action,
				payload
			);
		},
		parseMessage : function(action, payload) {
			switch (action) {
				case ACTION.DEBUG:
					alert("Controller Debug\n"+payload);
					break;
				case ACTION.CONTROLLER_START:
					this.init(payload);
					break;
				case ACTION.CONTROLLER_DATA_SHUFFLE:
					this.shuffleData();
					break;
				case ACTION.CONTROLLER_DATA_SAVE:
					this.saveData();
					break;
				case ACTION.CONTROLLER_END:
					this.end();
					break;
				case ACTION.CONTROLLER_DATA_HELP:
					this.sendMessage(ACTION.MODEL_DATA_HELP, payload);
					break;
			}
			return false;
		},
		parseAction : function(actionName, paramList) {
			if (!paramList) {
				paramList = [];
			}
			if (this.actionCodes[actionName]) {
				this.actionCodes[actionName].apply(this, paramList);
			} else {
				alert("UNKWNOWN ACTION:\n"+actionName);
			}
		},
		setCourseRef : function(courseRef) {
			this.sendMessage(
				ACTION.MODEL_DATA_SET_COURSE,
				courseRef
			);
		},
		setLangId : function(langId) {
			this.view.langId = langId;
		},
		loadView : function(name, view, callback) {
			var parentId;
			parentId = view
				? view.viewId
				: 0;
			this.sendMessage(
				ACTION.MODEL_VIEW_LOAD,
				{
					name : name,
					parent : parentId,
					callback : callback,
				}
			);
		},
		loadDataById : function(dataId) {
			this.sendMessage(
				ACTION.MODEL_DATA_SET_ID,
				dataId
			);
		},
		loadDataByDocument : function(dataDoc) {
			LearningObject.Tab.reset();
			this.sendMessage(
				ACTION.MODEL_DATA_SET_DOC,
				dataDoc
			);
			this.model.sendMessage(
				ACTION.VIEW_REDRAW
			);
		},
		shuffleData : function() {
			this.sendMessage(
				ACTION.MODEL_DATA_SHUFFLE
			);
		},
		saveData : function() {
			this.sendMessage(
				ACTION.MODEL_DATA_SAVE
			);
		},
		requestDraw : function() {
			this.sendMessage(
				ACTION.MODEL_VIEW_REDRAW
			);
		},
		addEventListener : function(type, listener) {
			listener.type = type;
			this.eventList.push(listener);
		},
		dispatchEvent : function(type) {
			var i, listener;
			for (i = 0; i < this.eventList.length; i++) {
				listener = this.eventList[i];
				if (listener.type === type) {
					listener.handleEvent.call(listener.context);
				}
			}
		},
	}
});


LearningObject.Model = Trait.build({
	uses : [
	],
	construct : function() {
		this.data = new LearningObject.Model.Data();
		this.obj = new LearningObject.Model.Obj();
	},
	vars : {
		model		: undefined,
		view		: undefined,
		controller	: undefined,
		
		data : undefined,
		
		events : {
			postMessage : function(mvc, action, payload) {
				mvc.parseMessage(action, payload);
			},
		},
	},
	methods : {
		init : function(config) {
			config.test += "♪";
			this.sendMessage(ACTION.VIEW_START, config);
		},
		end : function() {
		},
		sendMessage : function(action, payload) {
			window.setTimeout(
				this.events.postMessage,
				0,
				this.view,
				action,
				payload
			);
		},
		parseMessage : function(action, payload) {
			switch (action) {
				case ACTION.DEBUG:
					alert("Model Debug\n"+payload);
					break;
				case ACTION.MODEL_START:
					this.init(payload);
					break;
				case ACTION.MODEL_DATA_SET_ID:
					this.data.init(payload);
					this.obj.init(payload);
					break;
				case ACTION.MODEL_DATA_SET_DOC:
					this.data.setDoc(payload);
					break;
				case ACTION.MODEL_DATA_LOAD:
					this.sendMessage(
						ACTION.VIEW_BUSY_START
					);
					window.setTimeout(
						function() {
							try {
								this.data.load();
								this.obj.load();
							} catch(e) {
								console.log("Model.Data.load Error!");
								console.log("	Exception: %o", e);
							}
							this.sendMessage(
								ACTION.VIEW_BUSY_FINISH
							);
						}.bind(this)
					);
					break;
				case ACTION.MODEL_DATA_SAVE:
					this.sendMessage(
						ACTION.VIEW_BUSY_START
					);
					window.setTimeout(
						function() {
							try {
								this.data.save();
							} catch(e) {
								console.log("Model.Data.save Error!");
								console.log("	Exception: %o", e);
							}
							this.sendMessage(
								ACTION.VIEW_BUSY_FINISH
							);
						}.bind(this)
					);
					break;
				case ACTION.MODEL_DATA_SHUFFLE:
					this.data.shuffle();
					this.sendMessage(ACTION.VIEW_REDRAW);
					break;
				case ACTION.MODEL_DATA_LOG_START:
					this.data.logStart(payload);
					break;
				case ACTION.MODEL_DATA_LOG_VERIFY:
					this.sendMessage(
						ACTION.VIEW_BUSY_START
					);
					window.setTimeout(
						function() {
							try {
								this.data.logVerify(payload);
								this.controller.requestDraw();
							} catch(e) {
								console.log("Model.Data.logVerify Error!");
								console.log("	Exception: %o", e);
							}
							this.sendMessage(
								ACTION.VIEW_BUSY_FINISH
							);
						}.bind(this)
					);
					break;
				case ACTION.MODEL_DATA_LOG_SUBMIT:
					this.data.logSubmit(payload);
					break;
				case ACTION.MODEL_DATA_HELP:
					this.data.helpActivate(payload.task, parseInt(payload.show));
					this.sendMessage(ACTION.VIEW_REDRAW);
					break;
				case ACTION.MODEL_VIEW_LOAD:
					this.loadView(payload);
					break;
				case ACTION.MODEL_VIEW_REDRAW:
					this.sendMessage(ACTION.VIEW_REDRAW);
					break;
				case ACTION.MODEL_END:
					this.end();
					this.sendMessage(ACTION.VIEW_END);
					break;
				case ACTION.MODEL_DATA_SET_COURSE:
					this.data.setCourseRef(payload);
					break;
			}
			return false;
		},
		loadView : function(data) {
			var viewName = undefined,
				viewData = undefined,
				viewParent = data.parent,
				viewCallback = data.callback;
			switch (data.name) {
				case "obj-mediaPicker":
					viewName = "MediaPicker";
					viewData = {
						dataDoc : this.obj.doc
					};
					break;
				case "obj-stylePicker":
					viewName = "StylePicker";
					viewData = {
						dataDoc : this.obj.doc
					};
					break;
				case "obj-tablePicker":
					viewName = "TablePicker";
					viewData = {
						dataDoc : this.obj.doc
					};
					break;
				case "editor":
					viewName = "Editor";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
				case "editor-input":
					viewName = "HTMLEditor";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
				case "editor-raw":
					viewName = "XMLEditor";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
				case "editor-output":
					viewName = "Exercise";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
				case "editor-meta":
					viewName = "Meta";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
				case "user":
					viewName = "User";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
				case "log":
					viewName = "Log";
					viewData = {
						dataDoc : this.data.doc
					};
					break;
			}
			if (viewName && viewData) {
				this.sendMessage(
					ACTION.VIEW_VIEW_LOAD,
					{
						name : viewName,
						data : viewData,
						parent : viewParent,
						callback : viewCallback,
					}
				);
			}
		},
	}
});


LearningObject.Model.Data = Trait.build({
	uses : [
	],
	construct : function() {
	},
	vars : {
		id : undefined,
		courseRef : undefined,
		logRef : undefined,
		doc : undefined,
		xml : undefined,
		events : {
		},
		verifyAttributes : [
			"input-verify-count",
			"input-verify-bool",
			"input-verify-correct",
			"input-verify-wrong",
			"input-verify-position",
		],
		uriList : {
			load : "/sites/www/scripts/LearningObject/api.load.php",
			save : "/sites/www/scripts/LearningObject/api.save.php",
			start : "/sites/www/scripts/LearningObject/api.log.start.php",
			verify : "/sites/www/scripts/LearningObject/api.log.verify.php",
			submit : "/sites/www/scripts/LearningObject/api.log.submit.php",
		},
		lodbAttributeMap : {
			"page" : {
				"name" : "",
			},
			"quiz" : {
				"shuffle-answers" : "1",
				"display-answers" : "rows",
			},
			"question" : {
				"type" : "select",
			},
			"itemMapping" : {
				"display-answers" : "rows",
				"display-input" : "rows",
			},
			"pictureMapping" : {
			},
			"pictureMatch" : {
				"x" : "0",
				"y" : "0",
				"width" : "0",
				"height" : "0",
			},
			"categoryMapping" : {
				"display-answers" : "rows",
				"display-input" : "rows",
			},
			"marqueeCapture" : {
				"display-answers" : "rows",
				"display-input" : "rows",
			},
			"cloze" : {
				"type" : "drag",
				"shuffle-answers" : "1",
				"allow-help" : "0",
			},
			"clozeUncover" : {
				"type" : "drag",
				"shuffle-answers" : "1",
				"allow-help" : "0",
			},
			"clozeText" : {
			},
			"gameOptions" : {
				"difficulty" : "easy",
				"time-limit" : "",
			},
			"answer" : {
				"solved" : "0",
				"correct" : "0",
				"solved-answer" : "",
			},
			"simpleAnswer" : {
				"solved" : "0",
				"correct" : "0",
				"solved-answer" : "",
			},
			"keywordAnswer" : {
				"solved" : "0",
				"correct" : "0",
				"solved-answer" : "",
			},
		},
	},
	methods : {
		init : function(id) {
			this.setId(id);
			this.load();
		},
		setId : function(id) {
			this.id = id;
		},
		setDoc : function(doc) {
			if (this.doc) {
				var node = this.doc.importNode(doc.documentElement, true);
				this.doc.replaceChild(node, this.doc.documentElement);
			} else {
				this.doc = doc;
			}
		},
		setCourseRef : function(courseRef) {
			this.courseRef = courseRef
				? courseRef
				: undefined;
		},
		buildURI : function(uri, param) {
			var ret, key, val, arr;
			ret = uri;
			if (param) {
				arr = [];
				for (key in param) {
					val = param[key];
					arr.push(encodeURIComponent(key) + "=" + encodeURIComponent(val));
				}
				if (arr.length) {
					if (uri.split("?").length > 1) {
						ret += "&";
					} else {
						ret += "?";
					}
					ret += arr.join("&");
				}
			}
			return ret;
		},
		//Loads Data Document by its internal ID
		load : function() {
			var res, uri, param;
			uri = this.uriList.load;
			param = {};
			param.id = this.id;
			if (this.courseRef) {
				param.courseRef = this.courseRef;
			}
			uri = this.buildURI(uri, param);
			res = DOM.loadDocument(uri);
			this.doc = res;
		},
		//Saves Data Document to its internal ID
		save : function() {
			var res, uri, param;
			uri = this.uriList.save;
			param = {};
			param.id = this.id;
			if (this.courseRef) {
				param.courseRef = this.courseRef;
			}
			uri = this.buildURI(uri, param);
			this.sanitizeDocument();
			this.clear();
			res = DOM.saveDocument(uri, this.doc);
		},
		logStart : function() {
			var res, uri, req;
			this.logRef = undefined;
			uri = this.uriList.start;
			req = {};
			req.id = this.id;
			if (this.courseRef) {
				req.courseRef = this.courseRef;
			}
			uri = this.buildURI(uri, req);
			//this.verifyClear();
			res = DOM.saveDocument(uri, this.doc);
			if (res) {
				res = XPath.evaluate("string(lo_session_log/@node-ref)", res);
				if (res.length) {
					this.logRef = res;
				}
			}
			return this.logRef;
		},
		logVerify : function(param) {
			var ret, res, uri, param, pageNodeList, pageNode, i, pageNo, replaceNode;
			ret = false;
			if (!this.logRef) {
				this.logStart();
			}
			if (this.logRef) {
				uri = this.uriList.verify;
				req = {};
				req.id = this.id;
				req.logRef = this.logRef;
				if (this.courseRef) {
					req.courseRef = this.courseRef;
				}
				if (param && param.page) {
					req.page = param.page;
				}
				uri = this.buildURI(uri, req);
				
				res = DOM.saveDocument(uri, this.doc);
				res = this.doc.importNode(res.documentElement, true);	//<lodb:pagesLog>
				
				pageNodeList = XPath.evaluate("lodb:page", res);
				for (i = 0; i < pageNodeList.length; i++) {
					pageNode = pageNodeList[i];
					pageNo = pageNode.getAttribute("no");
					
					replaceNode =  XPath.evaluate("lodb:page[position() = " + pageNo + "]", this.doc.documentElement)[0];
					if (replaceNode) {
						replaceNode.parentNode.replaceChild(pageNode, replaceNode);
					}
				}
				ret = true;
			}
			return ret;
		},
		//Saves Data Document to its internal ID
		logSubmit : function(logSubmit) {
			var ret, res, uri, req;
			ret = false;
			if (!this.logRef) {
				this.logStart();
			}
			if (this.logRef) {
				uri = this.uriList.submit;
				req = {};
				req.id = this.id;
				req.logRef = this.logRef;
				if (this.courseRef) {
					req.courseRef = this.courseRef;
				}
				req.log = logSubmit ? 1 : 0;
				uri = this.buildURI(uri, req);
				//this.verifyClear();
				res = DOM.saveDocument(uri, this.doc);
				if (res) {
					ret = res;
				}
			}
			return ret;
		},
		helpActivate : function(path, show) {
			var taskNode = this.getItemByPath(path);
			if (taskNode) {
				if (show) {
					taskNode.setAttribute("show-help", "");
				} else {
					taskNode.removeAttribute("show-help");
				}
			}
		},
		//Removes all user input from the Data Document
		clear : function() {
			var nodeList, i;
			this.verifyClear();
			nodeList = XPath.evaluate(".//lodb:input", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				nodeList[i].parentNode.removeChild(nodeList[i]);
			}
		},
		backup : function() {
			this.xml = DOM.saveXML(this.doc);
		},
		restore : function() {
			this.doc = DOM.loadXML(this.xml);
		},
		createLODBElement : function(tagName) {
			var retNode;
			retNode = this.doc.createElementNS(NS.LODB, "lodb:" + tagName);
			if (this.lodbAttributeMap[tagName]) {
				for (var key in this.lodbAttributeMap[tagName]) {
					retNode.setAttribute(key, this.lodbAttributeMap[tagName][key]);
				}
			}
			return retNode;
		},
		createPage : function() {
			var retNode;
			retNode = this.createLODBElement("page");
			retNode.setAttribute("name", "##/lang/tab/page##" + (this.getLODBElements(["page"]).length + 1));
			//retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		//Tasks
		createQuiz : function() {
			var retNode;
			retNode = this.createLODBElement("quiz");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createItemMapping : function() {
			var retNode;
			retNode = this.createLODBElement("itemMapping");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createAnswerReferenceText(""));
			return retNode;
		},
		createCategoryMapping : function() {
			var retNode;
			retNode = this.createLODBElement("categoryMapping");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createAnswerReferenceText(""));
			return retNode;
		},
		createSentenceMapping : function() {
			var retNode;
			retNode = this.createLODBElement("sentenceMapping");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createPictureMapping : function() {
			var retNode;
			retNode = this.createLODBElement("pictureMapping");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createAnswerReferenceText(""));
			retNode.appendChild(this.createPictureArea());
			return retNode;
		},
		createCloze : function() {
			var retNode;
			retNode = this.createLODBElement("cloze");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createAnswerReferenceText(""));
			retNode.appendChild(this.createClozeText());
			return retNode;
		},
		createEssay : function() {
			var retNode;
			retNode = this.createLODBElement("essay");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createSolution(""));
			retNode.appendChild(this.createKeywordAnswerPile(""));
			return retNode;
		},
		createText : function() {
			var retNode;
			retNode = this.createLODBElement("text");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		//Games
		createQuizCapture : function() {
			var retNode;
			retNode = this.createLODBElement("quizCapture");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createQuizUncover : function() {
			var retNode;
			retNode = this.createLODBElement("quizUncover");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createUncoverArea());
			return retNode;
		},
		createMemory : function() {
			var retNode;
			retNode = this.createLODBElement("memory");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createCrossword : function() {
			var retNode;
			retNode = this.createLODBElement("crossword");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createCategoryCapture : function() {
			var retNode;
			retNode = this.createLODBElement("categoryCapture");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createMarqueeCapture : function() {
			var retNode;
			retNode = this.createLODBElement("marqueeCapture");
			retNode.appendChild(this.createTaskContent());
			return retNode;
		},
		createCategoryUncover : function() {
			var retNode;
			retNode = this.createLODBElement("categoryUncover");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createUncoverArea());
			return retNode;
		},
		createClozeUncover : function() {
			var retNode;
			retNode = this.createLODBElement("clozeUncover");
			retNode.appendChild(this.createTaskContent());
			retNode.appendChild(this.createUncoverArea());
			retNode.appendChild(this.createClozeText());
			return retNode;
		},
		createMemoryMatch : function() {
			var retNode;
			retNode = this.createLODBElement("memoryMatch");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createAnswer(" ", true));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createCrosswordMatch : function() {
			var retNode;
			retNode = this.createLODBElement("crosswordMatch");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createSimpleAnswer(" ", true));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createMarqueeMatch : function() {
			var retNode;
			retNode = this.createLODBElement("marqueeMatch");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createSimpleAnswerSet([" "]));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createUncoverArea : function() {
			var retNode;
			retNode = this.createLODBElement("uncoverArea");
			return retNode;
		},
		createPictureArea : function() {
			var retNode;
			retNode = this.createLODBElement("pictureArea");
			return retNode;
		},
		createGameOptions : function() {
			var retNode;
			retNode = this.createLODBElement("gameOptions");
			return retNode;
		},
		//Task elements
		createSolution : function(text) {
			var retNode;
			retNode = this.createLODBElement("solution");
			retNode.appendChild(this.doc.createTextNode(text));
			return retNode;
		},
		createDesc : function(desc) {
			var retNode;
			retNode = this.createLODBElement("desc");
			retNode.appendChild(this.doc.createTextNode(desc));
			return retNode;
		},
		createAnswerReferenceText : function(desc) {
			var retNode;
			retNode = this.createLODBElement("answerReferenceText");
			retNode.appendChild(this.doc.createTextNode(desc));
			return retNode;
		},
		createQuestion : function() {
			var retNode;
			retNode = this.createLODBElement("question");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createAnswerList([" "]));
			//retNode.appendChild(this.createHint(""));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createItemMatch : function() {
			var retNode;
			retNode = this.createLODBElement("itemMatch");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createAnswerSet([" "]));
			//retNode.appendChild(this.createHint(""));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createPictureMatch : function(x, y, width, height) {
			var retNode;
			retNode = this.createLODBElement("pictureMatch");
			retNode.setAttribute("x", x);
			retNode.setAttribute("y", y);
			retNode.setAttribute("width", width);
			retNode.setAttribute("height", height);
			
			retNode.appendChild(this.createAnswerSet([" "]));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createCategoryMatch : function() {
			var retNode;
			retNode = this.createLODBElement("categoryMatch");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createAnswerSet([" "]));
			//retNode.appendChild(this.createHint(""));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createSentenceMatch : function() {
			var retNode;
			retNode = this.createLODBElement("sentenceMatch");
			retNode.appendChild(this.createName(""));
			retNode.appendChild(this.createAnswerSequence([" "]));
			//retNode.appendChild(this.createHint(""));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createClozeText : function() {
			var retNode;
			retNode = this.createLODBElement("clozeText");
			retNode.appendChild(this.doc.createElementNS(NS.HTML, "p"));
			return retNode;
		},
		createGap : function(answerList) {
			var retNode;
			retNode = this.createLODBElement("gap");
			retNode.appendChild(this.createSimpleAnswerSet(answerList));
			//retNode.appendChild(this.createHint(""));
			retNode.appendChild(this.createFeedback(""));
			return retNode;
		},
		createAnswerSequence : function(answerList) {
			var retNode, i;
			retNode = this.createLODBElement("answerSequence");
			for (i = 0; i < answerList.length; i++) {
				retNode.appendChild(this.createAnswerSet([answerList[i]]));
			}
			return retNode;
		},
		createAnswerSet : function(answerList) {
			var retNode, i;
			retNode = this.createLODBElement("answerSet");
			for (i = 0; i < answerList.length; i++) {
				retNode.appendChild(this.createAnswer(answerList[i], true));
			}
			return retNode;
		},
		createSimpleAnswerSet : function(answerList) {
			var retNode, i;
			retNode = this.createLODBElement("simpleAnswerSet");
			for (i = 0; i < answerList.length; i++) {
				retNode.appendChild(this.createSimpleAnswer(answerList[i], true));
			}
			return retNode;
		},
		createKeywordAnswerPile : function(answerList) {
			var retNode, i;
			retNode = this.createLODBElement("keywordAnswerPile");
			for (i = 0; i < answerList.length; i++) {
				retNode.appendChild(this.createKeywordAnswerSet([answerList[i]], true));
			}
			return retNode;
		},
		createKeywordAnswerSet : function(answerList) {
			var retNode, i;
			retNode = this.createLODBElement("keywordAnswerSet");
			for (i = 0; i < answerList.length; i++) {
				retNode.appendChild(this.createKeywordAnswer(answerList[i], true));
			}
			return retNode;
		},
		createAnswerList : function(answerList) {
			var retNode, i;
			retNode = this.createLODBElement("answerList");
			for (i = 0; i < answerList.length; i++) {
				retNode.appendChild(this.createAnswer(answerList[i], false));
			}
			return retNode;
		},
		setAnswerList : function(answerListNode, answerList) {
			var nodeList, i;
			nodeList = XPath.evaluate("lodb:answer", answerListNode);
			for (i = 0; i < nodeList.length; i++) {
				if (i < answerList.length) {
					this.setAnswer(nodeList[i], answerList[i]);
				} else {
					answerListNode.removeChild(nodeList[i]);
				}
			}
		},
		createAnswer : function(answer, isCorrect) {
			var retNode;
			retNode = this.createLODBElement("answer");
			//retNode.appendChild(this.createName(answer));
			retNode.appendChild(this.doc.createTextNode(answer));
			retNode.setAttribute("correct", isCorrect ? "1" : "0");
			return retNode;
		},
		createSimpleAnswer : function(answer, isCorrect) {
			var retNode;
			retNode = this.createLODBElement("simpleAnswer");
			//retNode.appendChild(this.createName(answer));
			retNode.appendChild(this.doc.createTextNode(answer));
			retNode.setAttribute("correct", isCorrect ? "1" : "0");
			return retNode;
		},
		createKeywordAnswer : function(answer, isCorrect) {
			var retNode;
			retNode = this.createLODBElement("keywordAnswer");
			//retNode.appendChild(this.createName(answer));
			retNode.appendChild(this.doc.createTextNode(answer));
			retNode.setAttribute("correct", isCorrect ? "1" : "0");
			return retNode;
		},
		createAnswerReference : function(id) {
			var retNode;
			retNode = this.createLODBElement("answerReference");
			retNode.setAttribute("id", id);
			return retNode;
		},
		setAnswer : function(answerNode, answer) {
			while (answerNode.hasChildNodes()) {
				answerNode.removeChild(answerNode.lastChild);
			}
			answerNode.appendChild(this.createName(answer));
		},
		createHint : function(hint) {
			var retNode, i;
			retNode = this.createLODBElement("hint");
			retNode.appendChild(this.doc.createTextNode(hint));
			return retNode;
		},
		createFeedback : function(text) {
			var retNode, node;
			retNode = this.doc.createDocumentFragment();
			
			node = this.createLODBElement("positiveFeedback");
			node.appendChild(this.doc.createTextNode(text));
			retNode.appendChild(node);
			
			node = this.createLODBElement("negativeFeedback");
			retNode.appendChild(node);
			
			return retNode;
		},
		createTaskContent : function() {
			var retNode, node;
			retNode = this.doc.createDocumentFragment();
			
			retNode.appendChild(this.createDesc(""));
			retNode.appendChild(this.createGameOptions());
			retNode.appendChild(this.createFeedback(""));
			
			return retNode;
		},
		createName : function(name) {
			var retNode, i;
			retNode = this.createLODBElement("name");
			retNode.appendChild(this.doc.createTextNode(name));
			return retNode;
		},
		sanitizeRemoveList : [
			"//lodb:answerReference/text()",
			"//lodb:gap/text()",
			"//lodb:pictureArea/node()[not(self::html:img)]",
		],
		sanitizeNormalizeList : [
			"//lodb:simpleAnswer",
			"//lodb:keywordAnswer",
			"//@solved-answer",
			"//@name",
		],
		sanitizeDocument : function() {
			var nodeList, i;
			nodeList = XPath.evaluate(this.sanitizeRemoveList.join(" | "), this.doc);
			for (i = 0; i < nodeList.length; i++) {
				nodeList[i].parentNode.removeChild(nodeList[i]);
			}			
			nodeList = XPath.evaluate(this.sanitizeNormalizeList.join(" | "), this.doc);
			for (i = 0; i < nodeList.length; i++) {
				nodeList[i].textContent = XPath.evaluate("normalize-space(.)", nodeList[i]);
			}
		},
		getLODBElements : function(tagList) {
			var retList, nodeList, i, j;
			retList = [];
			for (i = 0; i < tagList.length; i++) {
				nodeList = this.doc.getElementsByTagNameNS(NS.LODB, tagList[i]);
				for (j = 0; j < nodeList.length; j++) {
					retList.push(nodeList[j]);
				}
			}
			return retList;
		},
		appendInputByPath : function(path, value) {
			var nodeList, i;
			nodeList = XPath.evaluate(path, this.doc);
			for (i = 0; i < nodeList.length; i++) {
				this.appendInputByNode(nodeList[i], value);
			}
		},
		setInputByPath : function(path, value) {
			var nodeList, i;
			nodeList = XPath.evaluate(path, this.doc);
			for (i = 0; i < nodeList.length; i++) {
				this.setInputByNode(nodeList[i], value);
			}
		},
		appendInputByNode : function(parentNode, value) {
			var node;
			node = XPath.evaluate("lodb:input", parentNode)[0];
			if (!node) {
				node = this.createInput();
				parentNode.appendChild(node);
			}
			this.setInputByNode(node, value);
		},
		setInputByNode : function(node, value) {
			switch (typeof value) {
				case "string":
					node.textContent = value;
					node.setAttribute("input-value", value);
					break;
				case "boolean":
					if (value) {
						node.setAttribute("correct", "1");
					} else {
						node.setAttribute("correct", "0");
					}
					break;
			}
		},
		verifyClear : function(parentNode) {
			var nodeList, attr, i, j;
			if (!parentNode) {
				parentNode = this.doc;
			}
			for (i = 0; i < this.verifyAttributes.length; i++) {
				attr = this.verifyAttributes[i];
				nodeList = XPath.evaluate(".//*[@" + attr + "]", parentNode);
				for (j = 0; j < nodeList.length; j++) {
					nodeList[j].removeAttribute(attr);
				}
			}
			nodeList = XPath.evaluate(".//*[@temp]", parentNode);
			for (i = 0; i < nodeList.length; i++) {
				if (nodeList[i] && nodeList[i].parentNode) {
					nodeList[i].parentNode.removeChild(nodeList[i]);
				}
			}
			
		},
		/*
		verifyInput : function() {
			var nodeList, i, correct;
			this.verifyClear();
			//alert(DOM.saveXML(this.doc));
			//answerSequence: answer[x] = input[x]
			nodeList = XPath.evaluate(".//lodb:answerSequence", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				correct = this.verifyAnswerSequenceNode(nodeList[i]);
				nodeList[i].setAttribute(
					"input-correct",
					correct
				);
			}
			//answerSet: input[x] IN [answer[1], answer[2], ...] 
			nodeList = XPath.evaluate(".//lodb:answerSet", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				correct = this.verifyAnswerSetNode(nodeList[i]);
				nodeList[i].setAttribute(
					"input-correct",
					correct
				);
			}
			//answerList: answer[x]/@correct = input[x]/@correct
			nodeList = XPath.evaluate(".//lodb:answerList", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				correct = this.verifyAnswerListNode(nodeList[i]);
				nodeList[i].setAttribute(
					"input-correct",
					correct
				);
			}
		},
		verifyAnswerSequenceNode : function(parentNode) {
			var ret, answerList, i;
			ret = 1;
			//answerSequence: answer[x] = input[x]
			answerList = XPath.evaluate("lodb:answerSet", parentNode);
			for (i = 0; i < answerList.length; i++) {
				if (!this.verifyAnswerSetNode(answerList[i])) {
					ret = 0;
					break;
				}
			}
			return ret;
		},
		verifyAnswerSetNode : function(parentNode) {
			var ret, inputList, i;
			//answerChoice: input[x] IN [answer[1], answer[2], ...] 
			inputList = XPath.evaluate("lodb:input", parentNode);
			ret = inputList.length
				? 1
				: 0;
			for (i = 0; i < inputList.length; i++) {
				if (XPath.evaluate("not(@input-value = ../lodb:answer/@answer-value)", inputList[i])) {
					ret = 0;
					break;
				}
			}
			return ret;
		},
		verifyAnswerListNode : function(parentNode) {
			var ret, answerList, inputList, i, inputNode;
			ret = 1;
			//answerList: answer[x]/@correct = input[x]/@correct
			answerList = XPath.evaluate("lodb:answer", parentNode);
			inputList = XPath.evaluate("lodb:input", parentNode);
			for (i = 0; i < answerList.length; i++) {
				inputNode = inputList[i];
				if (!inputNode || inputNode.getAttribute("correct") !== answerList[i].getAttribute("correct")) {
					ret = 0;
					break;
				}
			}
			return ret;
		},
		//*/
		getItemByPath : function(path) {
			var retNode, tmpNode;
			retNode = false;
			if (tmpNode = XPath.evaluate(path, this.doc)[0]) {
				retNode = tmpNode;
			}
			return retNode;
		},
		moveItemsByPath : function(parentPath, childPath) {
			var parentNode, childNodeList, i;
			if (parentNode = this.getItemByPath(parentPath)) {
				//this.verifyClear(parentNode);
				childNodeList = XPath.evaluate(childPath, this.doc);
				for (i = 0; i < childNodeList.length; i++) {
					//this.verifyClear(childNodeList[i].parentNode);
					parentNode.appendChild(childNodeList[i]);
				}
			}
			this.sanitizeDocument();
		},
		replaceChildNodesByPath : function(targetPath, sourceNode) {
			var parentNode, sourceNodeList, i;
			if (parentNode = XPath.evaluate(targetPath, this.doc)[0]) {
				//alert("437:replaceChildNodesByPath\n"+targetPath+"\n"+parentNode+"\n"+sourceNode);
				while (parentNode.hasChildNodes()) {
					parentNode.removeChild(parentNode.lastChild);
				}
				switch (parentNode.nodeType) {
					case parentNode.ATTRIBUTE_NODE:
						//parentNode.textContent = sourceNode.textContent;
						parentNode.value = XPath.evaluate("normalize-space(.)", sourceNode);
						break;
					default:
						sourceNodeList = sourceNode.childNodes;
						for (i = 0; i < sourceNodeList.length; i++) {
							parentNode.appendChild(this.doc.importNode(sourceNodeList[i], true));
						}
				}
			} else {
				//alert("386:replaceChildNodesByPath\n"+targetPath+"\n"+parentNode);
			}
			this.sanitizeDocument();
		},
		replaceAttributeByPath : function(targetPath, value) {
			var attrNode, node, key, val;
			attrNode = XPath.evaluate(targetPath, this.doc)[0];
			if (attrNode && attrNode.ownerElement) {
				node = attrNode.ownerElement;
				key = attrNode.name;
				val = "" + value;
				//alert(targetPath + ": " + value);
				if (node.getAttribute(key) !== val) {
					node.setAttribute(key, val);
				}
				//attrNode.ownerElement.setAttribute(attrNode.name, value);
			} else {
				//alert("734: replaceAttributeByPath\n" + targetPath + "\n" + value);
			}
		},
		appendNodesByPath : function(targetPath, sourceNodeList) {
			var i, parentNode;
			if (parentNode = XPath.evaluate(targetPath, this.doc)[0]) {
				for (i = 0; i < sourceNodeList.length; i++) {
					parentNode.appendChild(sourceNodeList[i]);
				}
			}
			//alert("406:appendNodesByPath\n"+targetPath+"\n"+parentNode);
			this.sanitizeDocument();
		},
		removeNodesByPath : function(targetPath) {
			var i, sourceNodeList;
			if (sourceNodeList = XPath.evaluate(targetPath, this.doc)) {
				for (i = 0; i < sourceNodeList.length; i++) {
					sourceNodeList[i].parentNode.removeChild(sourceNodeList[i]);
				}
			}
		},
		getAnswerValue : function(node) {
			var ret, i;
			ret = "";
			switch (node.nodeType) {
				case node.ELEMENT_NODE:
					switch (node.localName) {
						case "img":
						case "audio":
						case "video":
							if (node.hasAttribute("data-media-ref")) {
								ret += " "+node.getAttribute("data-media-ref")+" ";
							}
							if (node.hasAttribute("src")) {
								ret += " "+node.getAttribute("src")+" ";
							}
							break;
						default:
							if (node.namespaceURI === NS.HTML) {
								//ret += "<" + node.localName + ">";
							}
							for (i = 0; i < node.childNodes.length; i++) {
								ret += this.getAnswerValue(node.childNodes[i]);
							}
							break;
					}
					break;
				case node.TEXT_NODE:
					ret += node.wholeText;
					break;
				default:
					break;
			}
			if (ret.length) {
				console.log(JSON.stringify([ret, XPath.evaluate("normalize-space(.)", node.ownerDocument.createTextNode(ret))]));
				ret = XPath.evaluate("normalize-space(.)", node.ownerDocument.createTextNode(ret));
			}
			return ret;
		},
		prepare : function() {
			var nodeList, i;
			
			//setting @answer-value
			nodeList = XPath.evaluate(".//lodb:answer", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				nodeList[i].setAttribute(
					"answer-value",
					this.getAnswerValue(nodeList[i])
				);
			}
			nodeList = XPath.evaluate(".//lodb:simpleAnswer | .//lodb:keywordAnswer", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				nodeList[i].setAttribute(
					"answer-value",
					nodeList[i].textContent
				);
			}
			
			//creating <lodb:input/>
			nodeList = XPath.evaluate(".//lodb:page/*", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				this.prepareTask(nodeList[i]);
			}
		},
		prepareTask : function(taskNode) {
			switch (taskNode.localName) {
				case "quiz":
				case "quizUncover":
				case "quizCapture":
					this.prepareAnswerList(taskNode);
					break;
				case "itemMapping":
				case "pictureMapping":
				case "categoryMapping":
					this.prepareAnswerReferenceText(taskNode);
					break;
				case "cloze":
					this.prepareCloze(taskNode);
					break;
				case "sentenceMapping":
					this.prepareAnswerSequence(taskNode);
					break;
				case "essay":
					this.prepareInput(taskNode);
					break;
				case "text":
					break;
				case "categoryCapture":
					break;
				case "marqueeCapture":
					break;
				case "memory":
					break;
				case "crossword":
					break;
				case "clozeUncover":
					break;
				case "categoryUncover":
					break;
			}
		},
		prepareAnswerList : function(parentNode) {
			var nodeList, node, i;
			nodeList = XPath.evaluate(".//lodb:answerList/lodb:answer", parentNode);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.parentNode.appendChild(this.createInputByAnswer(node));
			}
		},
		prepareAnswerSet : function(parentNode) {
			var nodeList, node, i;
			nodeList = XPath.evaluate(".//lodb:answerSet/lodb:answer", parentNode);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.parentNode.appendChild(this.createInputByAnswer(node));
			}
		},
		prepareAnswerSequence : function(parentNode) {
			var nodeList, node, i;
			nodeList = XPath.evaluate(".//lodb:answerSequence[1]/lodb:answerSet/lodb:answer", parentNode);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				if (node.getAttribute("solved") === "1") {
					node.parentNode.appendChild(this.createInputByAnswer(node));
				} else {
					node.parentNode.parentNode.parentNode.appendChild(this.createInputByAnswer(node));
				}
			}
		},
		prepareAnswerReferenceText : function(parentNode) {
			var nodeList, node, i, answerNodeList, answerNode, inputNode, textNode;
			textNode = XPath.evaluate("lodb:answerReferenceText", parentNode)[0];
			if (!textNode) {
				textNode = this.createAnswerReferenceText("");
				parentNode.appendChild(textNode);
			}
			answerNodeList = XPath.evaluate(".//lodb:answerSet/lodb:answer | .//lodb:simpleAnswerSet/lodb:simpleAnswer", parentNode);
			for (i = 0; i < answerNodeList.length; i++) {
				answerNode = answerNodeList[i];
				inputNode = this.createInputByAnswer(answerNode);
				if (answerNode.getAttribute("solved") === "1") {
					answerNode.parentNode.appendChild(inputNode);
				} else {
					node = XPath.evaluate(".//lodb:answerReference[@id=" + (i+1) + "]", textNode)[0];
					if (node) {
						node.appendChild(inputNode);
					} else {
						textNode.appendChild(inputNode);
					}
				}
			}
		},
		prepareCloze : function(parentNode) {
			var nodeList, node, i, tmpList;
			this.prepareAnswerReferenceText(parentNode);
			
			clozeNode = XPath.evaluate("lodb:clozeText", parentNode)[0];
			if (!clozeNode) {
				clozeNode = this.createClozeText();
				parentNode.appendChild(clozeNode);
			}
			
			switch (clozeNode.getAttribute("type")) {
				case "drag":
					/*
					tmpList = [];
					nodeList = XPath.evaluate(".//lodb:simpleAnswer[@solved = 0]", clozeNode);
					for (i = 0; i < nodeList.length; i++) {
						tmpList.push(this.createInputByAnswer(nodeList[i]));
					}
					this.shuffleList(tmpList);
					for (i = 0; i < tmpList.length; i++) {
						tmpList[i].setAttribute("temp", "");
						clozeNode.appendChild(tmpList[i]);
					}
					//*/
					break;
				case "dropdown":
					/*
					tmpList = [];
					nodeList = XPath.evaluate(".//lodb:simpleAnswer", clozeNode);
					for (i = 0; i < nodeList.length; i++) {
						tmpList.push(nodeList[i].cloneNode(true));
					}
					this.shuffleList(tmpList);
					for (i = 0; i < tmpList.length; i++) {
						tmpList[i].setAttribute("temp", "");
						clozeNode.appendChild(tmpList[i]);
					}
					//*/
					break;
				case "freetext":
					break;
			}
		},
		prepareInput : function(parentNode) {
			parentNode.appendChild(this.createInput());
		},
		createInput : function() {
			return this.createLODBElement("input");
		},
		createInputByAnswer : function(answerNode) {
			var retNode;
			retNode = this.createInput();
			//console.log("creating <lodb:input>... %o", retNode);
			for (var i = 0; i < answerNode.childNodes.length; i++) {
				retNode.appendChild(answerNode.childNodes[i].cloneNode(true));
			}
			retNode.setAttribute("input-value", answerNode.getAttribute("answer-value"));
			retNode.setAttribute("solved-answer", answerNode.getAttribute("solved-answer"));
			return retNode;
		},
		//Randomizes everything that's randomizable in the Data Document
		shuffle : function() {
			var nodeList, i, node, arr, j;
			
			this.clear();
			
			this.prepare();
			
			this.shuffleDocument();
		},
		shuffleDocument : function() {
			nodeList = XPath.evaluate(".//lodb:input", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.setAttribute("input-verify-position", i);
			}
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.parentNode.appendChild(node);
			}
			
			nodeList = XPath.evaluate(".//*[@shuffle-answers = 1]//*[lodb:answer]", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.setAttribute("input-verify-position", i);
			}
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.parentNode.appendChild(node);
			}
			nodeList = XPath.evaluate(".//*[@shuffle-answers = 1]//lodb:answerSet/lodb:answer | .//*[@shuffle-answers = 1]//lodb:simpleAnswerSet/lodb:simpleAnswer", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.setAttribute("input-verify-position", i);
			}
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.parentNode.appendChild(node);
			}
		},
		/*
		shuffleOLD : function() {
			//itemMapping shuffling
			nodeList = XPath.evaluate(".//lodb:answerSet | .//lodb:simpleAnswerSet | .//lodb:answerList", this.doc);
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				this.shuffleMappingByNode(nodeList[i], XPath.evaluate("local-name(ancestor::*[parent::lodb:page])", nodeList[i]));
			}
			
			nodeList = XPath.evaluate(".//lodb:solution", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				node = this.createInput();
				nodeList[i].parentNode.appendChild(node);
			}
			nodeList = XPath.evaluate(".//lodb:clozeText", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				this.shuffleClozeByNode(nodeList[i]);
			}
			nodeList = XPath.evaluate(".//lodb:answerSequence[1]", this.doc);
			for (i = 0; i < nodeList.length; i++) {
				this.shuffleSentenceByNode(nodeList[i]);
			}
			
			nodeList = XPath.evaluate(".//lodb:categoryMapping/lodb:input | .//lodb:itemMapping/lodb:input", this.doc);
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.parentNode.appendChild(node);
			}
		},
		shuffleMappingByNode : function(parentNode, loType) {
			var nodeList, i, j, node;
			nodeList = XPath.evaluate("lodb:answer[@solved = 1] | lodb:simpleAnswer[@solved = 1]", parentNode);
			for (i = 0; i < nodeList.length; i++) {
				switch (loType) {
					case "sentenceMapping":
						break;
					case "cloze":
					case "itemMapping":
					case "categoryMapping":
					default:
						node = this.createInputByAnswer(nodeList[i]);
						parentNode.appendChild(node);
						break;
				}				
			}
			nodeList = XPath.evaluate("lodb:answer[@solved = 0] | lodb:simpleAnswer[@solved = 0]", parentNode);
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				switch (loType) {
					case "cloze":
						break;
					case "itemMapping":
					case "categoryMapping":
						node = this.createInputByAnswer(nodeList[i]);
						parentNode.parentNode.parentNode.appendChild(node);
						break;
					case "sentenceMapping":
						break;
					default:
						node = this.createInputByAnswer(nodeList[i]);
						parentNode.appendChild(node);
						break;
				}				
			}
		},
		shuffleClozeByNode : function(clozeNode) {
			var nodeList, node, i, tmpList;
			switch (clozeNode.getAttribute("type")) {
				case "drag":
					tmpList = [];
					nodeList = XPath.evaluate(".//lodb:simpleAnswer[@solved = 0]", clozeNode);
					for (i = 0; i < nodeList.length; i++) {
						tmpList.push(this.createInputByAnswer(nodeList[i]));
					}
					this.shuffleList(tmpList);
					for (i = 0; i < tmpList.length; i++) {
						tmpList[i].setAttribute("temp", "");
						clozeNode.appendChild(tmpList[i]);
					}
					break;
				case "dropdown":
					tmpList = [];
					nodeList = XPath.evaluate(".//lodb:simpleAnswer", clozeNode);
					for (i = 0; i < nodeList.length; i++) {
						tmpList.push(nodeList[i].cloneNode(true));
					}
					this.shuffleList(tmpList);
					for (i = 0; i < tmpList.length; i++) {
						tmpList[i].setAttribute("temp", "");
						clozeNode.appendChild(tmpList[i]);
					}
					break;
				case "freetext":
					break;
			}
		},
		shuffleSentenceByNode : function(parentNode) {
			var nodeList, i, j, node;
			nodeList = XPath.evaluate("lodb:answerSet/lodb:answer[@solved = 1]", parentNode);
			for (i = 0; i < nodeList.length; i++) {
				node = this.createInputByAnswer(nodeList[i]);
				nodeList[i].parentNode.appendChild(node);		
			}
			nodeList = XPath.evaluate("lodb:answerSet/lodb:answer[@solved = 0]", parentNode);
			this.shuffleList(nodeList);
			for (i = 0; i < nodeList.length; i++) {
				node = this.createInputByAnswer(nodeList[i]);
				parentNode.parentNode.appendChild(node);		
			}
		},
		//*/
		//shuffles array
		shuffleList : function(list) {
			var i, j, tmp;
			i = list.length;
			while (i > 0) {
				j = Math.floor(Math.random() * i);
				i--;
				tmp = list[i];
				list[i] = list[j];
				list[j] = tmp;
			}
		},
	}
});


LearningObject.Model.Obj = Trait.build({
	uses : [
	],
	construct : function() {
	},
	vars : {
		id : undefined,
		doc : undefined,
		xml : undefined,
		events : {
		},
	},
	methods : {
		init : function(id) {
			this.setId(id);
			this.load();
		},
		setId : function(id) {
			this.id = id;
		},
		setDoc : function(doc) {
			if (this.doc) {
				var node = this.doc.importNode(doc.documentElement, true);
				this.doc.replaceChild(node, this.doc.documentElement);
			} else {
				this.doc = doc;
			}
		},
		//Loads Data Document by its internal ID
		load : function() {
			var uri = "/sites/www/scripts/LearningObject/api.obj.php?id="+this.id;
			this.doc = DOM.loadDocument(uri);
		},
		//Saves Data Document to its internal ID
		save : function() {
			//var uri = "/sites/www/scripts/LearningObject/api.save.php?id="+this.id;
			//DOM.saveDocument(uri, this.doc);
		},
		backup : function() {
			this.xml = DOM.saveXML(this.doc);
		},
		restore : function() {
			this.doc = DOM.loadXML(this.xml);
		},
	}
});


LearningObject.Tab = {
	currentTabList : {},
	build : function(parentNode) {
		var nodeList, i;
		if (!parentNode.tabPath) {
			parentNode.tabPath = XPath.createPath(parentNode);
			parentNode.dataPath = XPath.evaluate("string(@data-model-path)", parentNode);
			parentNode.ownerTab = parentNode;
			parentNode.tabManager = this;
			parentNode.currentTab = this.currentTabList[parentNode.tabPath]
				? this.currentTabList[parentNode.tabPath].currentTab
				: 0;
			this.currentTabList[parentNode.tabPath] = parentNode;
			
			parentNode.changeTab = function(eve) {
				this.ownerTab.setTab(this.getAttribute("data-tab-no"));
			};
			parentNode.previousTab = function(eve) {
				this.ownerTab.setTab(this.ownerTab.currentTab - 1);
			};
			parentNode.nextTab = function(eve) {
				this.ownerTab.setTab(this.ownerTab.currentTab + 1);
			};
			parentNode.firstTab = function(eve) {
				this.ownerTab.setTab(0);
			};
			parentNode.lastTab = function(eve) {
				this.ownerTab.setTab(this.ownerTab.headList.length);
			};
			parentNode.setTab = function(no, syncingTab) {
				no = parseInt(no);
				if (no >= this.headList.length) {
					no = this.headList.length - 1;
				}
				if (no < 0) {
					no = 0;
				}
				if (this.headList[this.currentTab]) {
					this.headList[this.currentTab].setAttribute("data-tab-active", "0");
				}
				if (this.bodyList[this.currentTab]) {
					this.bodyList[this.currentTab].setAttribute("data-tab-active", "0");
				}
				this.currentTab = no;
				if (this.headList[this.currentTab]) {
					this.headList[this.currentTab].setAttribute("data-tab-active", "1");
				}
				if (this.bodyList[this.currentTab]) {
					this.bodyList[this.currentTab].setAttribute("data-tab-active", "1");
				}
				if (!syncingTab) {
					this.tabManager.syncTabsByDataPath(this);
				}
			};
			parentNode.headList = XPath.evaluate("html:nav/*", parentNode);
			parentNode.bodyList = XPath.evaluate("html:section/*", parentNode);
			for (i = 0; i < parentNode.headList.length; i++) {
				if (parentNode.bodyList[i]) {
					parentNode.headList[i].setAttribute("data-tab-no", i);
					parentNode.headList[i].addEventListener(
						"click",
						parentNode.changeTab,
						false
					);
					parentNode.headList[i].ownerTab = parentNode;
					parentNode.headList[i].setAttribute("data-tab-active", "0");
					parentNode.bodyList[i].setAttribute("data-tab-active", "0");
				}
			}
			parentNode.commandList = {};
			parentNode.commandList.first = XPath.evaluate(".//*[@data-tab-command = 'first']", parentNode);
			for (i = 0; i < parentNode.commandList.first.length; i++) {
				parentNode.commandList.first[i].ownerTab = parentNode;
				parentNode.commandList.first[i].addEventListener(
					"click",
					parentNode.firstTab,
					false
				);
			}
			parentNode.commandList.last = XPath.evaluate(".//*[@data-tab-command = 'last']", parentNode);
			for (i = 0; i < parentNode.commandList.last.length; i++) {
				parentNode.commandList.last[i].ownerTab = parentNode;
				parentNode.commandList.last[i].addEventListener(
					"click",
					parentNode.lastTab,
					false
				);
			}
			parentNode.commandList.next = XPath.evaluate(".//*[@data-tab-command = 'next']", parentNode);
			for (i = 0; i < parentNode.commandList.next.length; i++) {
				parentNode.commandList.next[i].ownerTab = parentNode;
				parentNode.commandList.next[i].addEventListener(
					"click",
					parentNode.nextTab,
					false
				);
			}
			parentNode.commandList.previous = XPath.evaluate(".//*[@data-tab-command = 'previous']", parentNode);
			for (i = 0; i < parentNode.commandList.previous.length; i++) {
				parentNode.commandList.previous[i].ownerTab = parentNode;
				parentNode.commandList.previous[i].addEventListener(
					"click",
					parentNode.previousTab,
					false
				);
			}
			parentNode.setTab(parentNode.currentTab);
		}
	},
	clear : function() {
		this.currentTabList = {};
	},
	reset : function() {
		var key;
		for (key in this.currentTabList) {
			this.currentTabList[key].setTab(0);
		}
	},
	getTabByModelPath : function(searchPath) {
		var key, node;
		for (key in this.currentTabList) {
			node = this.currentTabList[key];
			if (node.dataPath === searchPath) {
				return node;
			}
		}
		return false;
	},
	syncTabsByDataPath : function(tabNode) {
		var key, node;
		if (tabNode.dataPath.length) {
			for (key in this.currentTabList) {
				node = this.currentTabList[key];
				if (node.dataPath === tabNode.dataPath) {
					node.setTab(tabNode.currentTab, true);
					node.currentTab = tabNode.currentTab;
				}
			}
		}
	},
};


LearningObject.View = Trait.build({
	uses : [
		"ViewDocument"
	],
	construct : function() {
		DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject._global.xsl");
		this.ViewDocument(LearningObject.View, window.document);
		if (this.ownerDocument.getElementById("learning-object")) {
			this.setDrawParent(this.ownerDocument.getElementById("learning-object"));
		}
	},
	vars : {
		model		: undefined,
		view		: undefined,
		controller	: undefined,
		
		langId : 0,
		translationList : undefined,
		
		events : {
			postMessage : function(mvc, action, payload) {
				mvc.parseMessage(action, payload);
			},
		},
	},
	methods : {
		init : function(config) {
			config.test += "♪";
			this.sendMessage(ACTION.CONTROLLER_START, config);
		},
		draw : function() {
			this.parseMessage(ACTION.VIEW_BUSY_START);
			
			window.setTimeout(
				function() {
					try {
						this.ViewDocumentDraw();
					} catch(e) {
						console.log("View.draw Error!");
						console.log("	Exception: %o", e);
					}
					this.parseMessage(
						ACTION.VIEW_BUSY_FINISH
					);
				}.bind(this)
			);
		},
		end : function() {
			while (this.drawParent.hasChildNodes()) {
				this.drawParent.removeChild(this.drawParent.lastChild);
			}
		},
		sendMessage : function(action, payload) {
			window.setTimeout(
				this.events.postMessage,
				0,
				this.controller,
				action,
				payload
			);
		},
		parseMessage : function(action, payload) {
			switch (action) {
				case ACTION.DEBUG:
					alert("View Debug:\n"+payload);
					break;
				case ACTION.VIEW_START:
					this.init(payload);
					break;
				case ACTION.VIEW_VIEW_LOAD:
					this.loadView(payload.name, payload.data, payload.parent, payload.callback);
					break;
				case ACTION.VIEW_REDRAW:
					this.draw();
					break;
				case ACTION.VIEW_INPUT_UPDATE:
					console.log(this.childViews[0].updateInput);
					break;
				case ACTION.VIEW_END:
					this.end();
					this.sendMessage(ACTION.CONTROLLER_END);
					break;
				case ACTION.VIEW_BUSY_START:
					if (this.drawParent) {
						this.drawParent.setAttribute("data-view-busy", "");
					}
					break;
				case ACTION.VIEW_BUSY_FINISH:
					if (this.drawParent) {
						this.drawParent.removeAttribute("data-view-busy");
					}
					break;
			}
			return false;
		},
		loadTranslation : function() {
			var req, uri;
			uri = "/sites/www/scripts/LearningObject/api.lang.php?id=" + this.langId;
			/*
			req = new XMLHttpRequest();
			req.open("POST", uri, false);
			req.send();
			this.translationList = JSON.parse(req.responseText);
			//*/
			this.translationList = DOM.loadJSON(uri);
		},
		translateString : function(text) {
			var notFoundList, notFoundExists, tmp, i, key, val;
			if (!this.translationList) {
				this.loadTranslation();
			}
			for (i in this.translationList) {
				key = "##" + i + "##";
				val = this.translationList[i];
				text = text.split(key).join(val);
			}
			notFoundList = [];
			notFoundExists = {};
			tmp = text.split("##");
			for (i = 1; i < tmp.length; i += 2) {
				key = tmp[i];
				val = "\t'" + key + "' => '"+key.split("/").pop()+"',";
				if (!notFoundExists[val]) {
					notFoundList.push(val);
					notFoundExists[val] = true;
				}
			}
			if (notFoundList.length) {
				notFoundList.sort();
				console.log("undefined dictionary entries:\n" + notFoundList.join("\n"));
			}
			return text;
		},
		translate : function(sourceFragment) {
			var retFragment, oldXML, newXML;
			oldXML = DOM.saveXML(sourceFragment);
			newXML = this.translateString(oldXML);
			if (oldXML === newXML) {
				retFragment = sourceFragment;
			} else {
				retFragment = DOM.loadXML(newXML).documentElement;
				retFragment = sourceFragment.ownerDocument.importNode(retFragment, true);
			}
			return retFragment;
		},
	}
});


LearningObject.View.Editor = Trait.build({
	uses : [
		"ViewElement"
	],
	construct : function(ownerView, viewId) {
		this.pages = {};
		this.activePage = "editor-input";
		this.ViewElement(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.editor.xsl")
		);
		this.ownerView.controller.loadView("editor-input", 	this, function(childView) { this.pages["editor-input"] 	= childView; });
		this.ownerView.controller.loadView("editor-raw", 	this, function(childView) { this.pages["editor-raw"] 	= childView; });
		//this.ownerView.controller.loadView("editor-output", this, function(childView) { this.pages["editor-output"] = childView; });
		this.ownerView.controller.loadView("editor-meta", 	this, function(childView) { this.pages["editor-meta"] 	= childView; });
		this.ownerView.controller.requestDraw();
	},
	vars : {
		activePage 	: undefined,
		pages : undefined,
		events : {
		},
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		},
		draw : function() {
			var nodeList, i, viewName;
			this.ViewElementDraw();
			nodeList = XPath.evaluate(".//*[@data-lo-id='editor-body']/*", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				viewName = nodeList[i].getAttribute("data-lo-id");
				if (this.pages[viewName]) {
					this.pages[viewName].setDrawParent(nodeList[i]);
					this.pages[viewName].draw();
				}
			}
			/*
			nodeList = XPath.evaluate(".//*[@data-lo-id='editor-head']//html:input", this.drawFragment);
			parentNode = XPath.evaluate(".//*[@data-lo-id='editor-body']", this.drawFragment)[0];
			for (i = 0; i < nodeList.length; i++) {
				nodeList[i].ownerView = this;
				viewName = nodeList[i].value;
				viewActive = 0+(viewName === this.activePage);
				if (this.pages[viewName]) {
					nodeList[i].addEventListener(
						"change",
						this.events.viewSelect,
						false
					);
					nodeList[i].parentNode.setAttribute("data-lo-show", viewActive);
					
					viewNode = parentNode.ownerDocument.createElementNS(NS.HTML, "section");
					viewNode.setAttribute("data-lo-id", viewName);
					viewNode.setAttribute("data-lo-show", viewActive);
					parentNode.appendChild(viewNode);
					
					this.pages[viewName].setDrawParent(viewNode);
					this.pages[viewName].draw();
				}
			}
			//*/
			/*
			parentNode = XPath.evaluate(".//*[@data-lo-id='editor-input']", this.drawFragment)[0];
			if (this.inputView && parentNode) {
				this.inputView.setDrawParent(parentNode);
				this.inputView.draw();
			}
			parentNode = XPath.evaluate(".//*[@data-lo-id='editor-raw']", this.drawFragment)[0];
			if (this.rawView && parentNode) {
				this.rawView.setDrawParent(parentNode);
				this.rawView.draw();
			}
			parentNode = XPath.evaluate(".//*[@data-lo-id='editor-output']", this.drawFragment)[0];
			if (this.outputView && parentNode) {
				this.outputView.setDrawParent(parentNode);
				this.outputView.draw();
			}
			parentNode = XPath.evaluate(".//*[@data-lo-id='editor-meta']", this.drawFragment)[0];
			if (this.metaView && parentNode) {
				this.metaView.setDrawParent(parentNode);
				this.metaView.draw();
			}
			//*/
		},
	}
});


LearningObject.View.Exercise = Trait.build({
	uses : [
		"ViewElement",
		"ControllerMoveable",
		"ControllerCommand",
	],
	construct : function(ownerView, viewId) {
		this.config = {};
		this.config.showHints = true;
		this.config.showFeedback = true;
		this.config.allowRetry = false;
		this.config.saveLog = true;
		this.config.showLog = true;
		
		this.ViewElement(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.exercise.xsl")
		);
		
		this.parseCommand("start");
	},
	vars : {
		config		: undefined,
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		},
		draw : function() {
			var nodeList, node, i;
			this.ViewElementDraw();
			this.ControllerMoveableDraw();
			this.ControllerCommandDraw();
			//alert(DOM.saveXML(this.data.dataDoc));
			if (this.config.showHints) {
				nodeList = XPath.evaluate(".//*[@data-command='hint-trigger']", this.drawFragment);
				for (i = 0; i < nodeList.length; i++) {
					node = nodeList[i];
					node.removeAttribute("disabled");
				}
			}
		},
		parseCommand : function(name, targetNode, param) {
			if (!param) {
				param = {};
			}
			switch (name) {
				case "hint-trigger":
					targetNode.parentNode.setAttribute("data-hint-active", "1");
					break;
				case "help":
					this.updateInput();
					this.ownerView.sendMessage(ACTION.CONTROLLER_DATA_HELP, param);
					//targetNode.parentNode.setAttribute("data-help-active", "1");
					break;
				case "shuffle":
					this.ownerView.controller.shuffleData();
					//this.draw();
					break;
				case "start":
					//this.ownerView.model.parseMessage(ACTION.MODEL_DATA_LOG_START, param);
					break;
				case "verify":
					this.updateInput();
					this.ownerView.model.parseMessage(ACTION.MODEL_DATA_LOG_VERIFY, param);
					break;
				case "submit":
					this.updateInput();
					var doc = this.ownerView.model.data.logSubmit(this.config.saveLog);
					this.ownerView.controller.dispatchEvent("submit");
					if (this.config.showLog) {
						this.ownerView.controller.loadDataByDocument(doc);
						this.ownerView.controller.loadView("log");
					} else {
						this.ownerView.controller.exit();
					}
					
					/*
					var id = this.ownerView.model.data.submit();
					
					window.setTimeout(
						function(id) {
							//loadLearningObject(id, "log");
						},
						1000,
						id
					);
					//*/
					break;
			}
		},
		updateInput : function() {
			var nodeList, i;
			nodeList = XPath.evaluate(".//html:input[@type][@data-model-path]", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				this.ownerView.model.data.setInputByPath(nodeList[i].getAttribute("data-model-path"), this.getInputValue(nodeList[i]));
			}
			nodeList = XPath.evaluate(".//html:input[not(@type)][@data-model-path]", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				//alert([nodeList[i].getAttribute("data-model-path"), this.getInputValue(nodeList[i])].join("\n"));
				this.ownerView.model.data.appendInputByPath(nodeList[i].getAttribute("data-model-path"), this.getInputValue(nodeList[i]));
			}
			nodeList = XPath.evaluate(".//html:select[@data-model-path]", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				this.ownerView.model.data.appendInputByPath(nodeList[i].getAttribute("data-model-path"), nodeList[i].value);
			}
			nodeList = XPath.evaluate(".//*[@contenteditable][@data-model-path]", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				this.ownerView.model.data.replaceChildNodesByPath(nodeList[i].getAttribute("data-model-path"), nodeList[i]);
			}
		},
		getInputValue : function(inputNode) {
			var ret;
			switch (inputNode.type) {
				case "checkbox":
				case "radio":
					ret = inputNode.checked;
					break;
				default:
					inputNode.setAttribute("value", inputNode.value);
					ret = XPath.evaluate("normalize-space(@value)", inputNode);
					if (ret !== inputNode.value) {
						inputNode.value = ret;
						inputNode.setAttribute("value", inputNode.value);
					}
					break;
			}
			return ret;
		},
	}
});


LearningObject.View.HTMLEditor = Trait.build({
	uses : [
		"LOEditor",
	],
	construct : function(ownerView, viewId) {
		this.LOEditor(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.html-editor.xsl")
		);
	},
	vars : {
		
	},
	methods : {
		asNode : function(dataDoc) {
			var retNode;
			retNode = dataDoc.importNode(this.data.dataDoc.documentElement, true);
			if (this.getClipboard("lodb")) {
				retNode.setAttribute("_clipboard-filled", "");
			}
			return retNode;
		},
		clearError: function() {
			//this.outputNode.setAttribute("style", "display: none");
		},
		setError : function(text, func) {
			console.log("HTMLEditor Error!");
			if (func) {
				console.log("	Function: %o", func);
			}
			console.log("	Exception: %o", text);
		},
	}
});


LearningObject.View.Log = Trait.build({
	uses : [
		"ViewElement",
		"ControllerCommand",
	],
	construct : function(ownerView, viewId) {
		this.ViewElement(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.result.xsl")
		);
		this.ownerView.controller.requestDraw();
	},
	vars : {
		outputView 	: undefined,
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		},
		draw : function() {
			this.ViewElementDraw();
			this.ControllerCommandDraw();
		},
		
	}
});


LearningObject.View.MediaPicker = Trait.build({
	uses : [
		"ViewElementList",
	],
	construct : function(ownerView, viewId) {
		this.ViewElementList(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.mediaPicker.xsl")
		);
	},
	vars : {
		popupURL : "/mod/htmlarea/popups/IWinsertImage.php?avail_imgtypes=62&ecard=1&fl=1&align=&align_dflt=left&mode=preview",
		currentRange : undefined,
		currentEditor : undefined,
		currentNode : undefined,
		mediaFormatMenuNode : undefined,
		styleNodeList : undefined,
		styleAttribute : "data-media-attribute",
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		},
		draw : function() {
			var nodeList, node, i;
			this.ViewElementListDraw();
			//console.log("MediaPicker finished drawing!");
			
			nodeList = XPath.evaluate(".//html:select", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node._mediaPicker = this;
				node.addEventListener(
					"change",
					function(eve) {
						this._mediaPicker.setStyle(this);
					},
					false
				);
			}
			this.styleNodeList = nodeList;
			
			this.mediaFormatMenuNode = XPath.evaluate("descendant-or-self::*[@data-mediaPicker='format']", this.drawFragment)[0];
		},
		clearError: function() {
			//this.outputNode.setAttribute("style", "display: none");
		},
		setError : function(text, func) {
			console.log("MediaPicker Error!");
			if (func) {
				console.log("	Function: %o", func);
			}
			console.log("	Exception: %o", text);
		},
		setCurrentNode : function(node) {
			var i, key;
			if (node && node.nodeType === Node.ELEMENT_NODE) {
				this.currentNode = node;
			} else {
				this.currentNode = undefined;
			}
			
			if (this.currentNode && (this.currentNode.localName === "img" || this.currentNode.localName === "audio" || this.currentNode.localName === "video")) {
				if (this.mediaFormatMenuNode) {
					this.mediaFormatMenuNode.removeAttribute("disabled");
				}
				for (i = 0; i < this.styleNodeList.length; i++) {
					node = this.styleNodeList[i];
					node.disabled = false;
					key = node.getAttribute(this.styleAttribute);
					if (this.currentNode.hasAttribute(key)) {
						node.value = this.currentNode.getAttribute(key);
					} else {
						node.value = "";
					}
				}
			} else {
				if (this.mediaFormatMenuNode) {
					this.mediaFormatMenuNode.setAttribute("disabled", "disabled");
				}
				for (i = 0; i < this.styleNodeList.length; i++) {
					node = this.styleNodeList[i];
					node.disabled = true;
				}
			}
		},
		setStyle : function(styleNode) {
			if (this.currentNode) {
				this.currentNode.setAttribute(styleNode.getAttribute(this.styleAttribute), styleNode.value);
				if (this.currentEditor) {
					this.currentEditor.updateEditorNodes();
				}
			}
		},
		setFloat : function(value) {
			if (this.currentNode) {
				this.currentNode.setAttribute("data-media-float", value);
				if (this.currentEditor) {
					this.currentEditor.updateEditorNodes();
				}
			}
		},
		pickMedia : function(currentRange, editor) {
			var mediaPicker, outparam, url, currentNode;
			mediaPicker = this;
			outparam = null;
			this.currentRange = currentRange;
			this.currentEditor = editor;
			currentNode = currentRange.startContainer;
			if (currentNode.localName === "img") {
				outparam = {
					f_url    : currentNode.src,
					f_alt    : currentNode.alt,
					f_border : currentNode.border,
					f_align  : currentNode.align,
					f_vert   : currentNode.vspace,
					f_horiz  : currentNode.hspace,
				};
			}
			try {
				url = this.popupURL;
				url += "&call_obj_id=" + this.ownerView.model.obj.doc.documentElement.getAttribute("id");
			} catch(e) {
				this.setError(e, "pickMedia");
				url = false;
			}
			
			this.setCurrentNode(currentNode);
			
			if (url) {
				Dialog(
					url,
					function(param) {
						mediaPicker.insertMedia(param);
						/*
						var img = image;
						if (!img) {
							var sel = editor._getSelection();
							var range = editor._createRange(sel);
							editor._doc.execCommand("insertimage", false, param.f_url);
							if (HTMLArea.is_ie) {
								img = range.parentElement();
								// wonder if this works...
								if (img.tagName.toLowerCase() != "img") {
									img = img.previousSibling;
								}
							} else {
								img = range.startContainer.previousSibling;
							}
						} else {
							img.src = param.f_url;

						}
						for (field in param) {
							var value = param[field];
							switch (field) {
								case "f_alt"    : img.alt	 = value; break;
								case "f_border" : img.border = parseInt(value || "0"); break;
								case "f_align"  : img.align	 = value; break;
								case "f_vert"   : img.vspace = parseInt(value || "0"); break;
								case "f_horiz"  : img.hspace = parseInt(value || "0"); break;
							}
						}
						//*/
					},
					outparam
				);
			}
			
		},
		insertMedia : function(param) {
			var mediaNode;
			if (mediaNode = this.createMediaNode(param)) {
				this.currentRange.insertNode(mediaNode);
				this.currentEditor.updateEditorNodes();
				this.setCurrentNode(mediaNode);
			}
		},
		//param : { objType, mediaURI }
		//<div data-media-type="objType"><media/></div>
		createMediaNode : function(param) {
			var mediaNode, sourceList, sourceNode, key;
			//alert(JSON.stringify(param));
			
			mediaNode = false;
			
			switch (param.objType) {
				case "lo_audio":
				case "lo_video":
					//create or modify <audio src> thing
					switch (param.objType) {
						case "lo_audio":
							mediaNode = document.createElement("audio");
							sourceList = {
								lib_ogg : "audio/ogg",
								lib_mp3 : "audio/mpeg"
							};
							break;
						case "lo_video":
							mediaNode = document.createElement("video");
							sourceList = {
								lib_webm : "video/webm",
								lib_mp4 : "video/mp4"
							};
							break;
					}
					//mediaNode.setAttribute("src", param.mediaURI);
					mediaNode.setAttribute("controls", "controls");
					mediaNode.setAttribute("preload", "none");
					//mediaNode.setAttribute("contenteditable", "false");
					
					for (key in sourceList) {
						sourceNode = document.createElement("source");
						sourceNode.setAttribute("src", param.mediaURI + "&media=" + key);
						sourceNode.setAttribute("type", sourceList[key]);
						mediaNode.appendChild(sourceNode);
					}
					break;
				case "lo_img":
					//create or modify <img src> thing
					mediaNode = document.createElement("img");
					mediaNode.setAttribute("src", param.mediaURI);
					break;
			}
			if (mediaNode) {
				//mediaNode.setAttribute("draggable", "true");
				mediaNode.setAttribute("data-media-type", param.objType);
				mediaNode.setAttribute("data-media-ref", param.objRef);
				mediaNode.setAttribute("data-media-version", "0");
			}
			return mediaNode;
		},
	}
});


LearningObject.View.Meta = Trait.build({
	uses : [
		"LOEditor"
	],
	construct : function(ownerView, viewId) {
		this.LOEditor(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.meta.xsl")
		);
	},
	vars : {
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		}
	}
});


LearningObject.View.StylePicker = Trait.build({
	uses : [
		"ViewElementList",
	],
	construct : function(ownerView, viewId) {
		this.ViewElementList(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.stylePicker.xsl")
		);
		this.calcStyleList();
	},
	vars : {
		blockStyleList : undefined,
		//blockStyleNode : undefined,
		inlineStyleList : undefined,
		//inlineStyleNode : undefined,
	},
	methods : {
		asNode : function(dataDoc) {
			var retNode, node, i;
			retNode = dataDoc.createElement("stylePicker");
			for (i in this.blockStyleList) {
				node = dataDoc.createElement("blockStyle");
				node.setAttribute("name", i);
				retNode.appendChild(node);
			}
			for (i in this.inlineStyleList) {
				node = dataDoc.createElement("inlineStyle");
				node.setAttribute("name", i);
				retNode.appendChild(node);
			}
			/*
			if (this.parentView.getClipboard("stylePicker")) {
				retNode.setAttribute("_clipboard-filled", "");
			}
			//*/
			return retNode;
		},
		draw : function() {
			var nodeList, node, i;
			this.ViewElementListDraw();
			
			//blockStyle
			nodeList = XPath.evaluate(".//html:select[@name = 'blockStyle']", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.stylePicker = this;
				node.addEventListener(
					"change",
					function (eve) {
						this.stylePicker.insertBlock(this.value);
					},
					false
				);
			}
			
			//inlineStyle
			nodeList = XPath.evaluate(".//html:select[@name = 'inlineStyle']", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node.stylePicker = this;
				node.addEventListener(
					"change",
					function (eve) {
						this.stylePicker.insertInline(this.value);
					},
					false
				);
			}
			
			/*
			this.blockStyleNode = XPath.evaluate(".//html:select[@name = 'blockStyle']", this.drawFragment)[0];
			this.blockStyleNode.stylePicker = this;
			this.blockStyleNode.addEventListener(
				"change",
				function (eve) {
					this.stylePicker.insertBlock(this.value);
				},
				false
			);
			
			this.inlineStyleNode = XPath.evaluate(".//html:select[@name = 'inlineStyle']", this.drawFragment)[0];
			this.inlineStyleNode.stylePicker = this;
			this.inlineStyleNode.addEventListener(
				"change",
				function (eve) {
					this.stylePicker.insertInline(this.value);
				},
				false
			);
			//*/
		},
		getStyleElement : function(styleName) {
			if (this.blockStyleList[styleName]) {
				return this.blockStyleList[styleName].cloneNode(true);
			}
			if (this.inlineStyleList[styleName]) {
				return this.inlineStyleList[styleName].cloneNode(true);
			}
			alert("unknown style: " + styleName);
			return null;
			//return this.inlineStyleList[styleName].cloneNode(true);
			/*
			var retNode;
			switch (styleName) {
				case "block-h1":
					retNode = document.createElement("h1");
					break;
				case "block-h2":
					retNode = document.createElement("h2");
					break;
				case "block-h3":
					retNode = document.createElement("h2");
					break;
				case "block-question":
					retNode = document.createElement("div");
					break;
				case "block-text":
					retNode = document.createElement("div");
					break;
				case "block-dialog":
					retNode = document.createElement("div");
					break;
				case "block-help":
					retNode = document.createElement("div");
					break;
				case "block-footnote":
					retNode = document.createElement("div");
					break;
				case "inline-normal":
					retNode = document.createElement("span");
					break;
				case "inline-bold":
					retNode = document.createElement("b");
					break;
				case "inline-italic":
					retNode = document.createElement("i");
					break;
				case "inline-suffix":
					retNode = document.createElement("span");
					break;
				case "inline-grammar":
					retNode = document.createElement("span");	
					break;
				default:
					alert("unknown style: " + styleName);
					break;
			}
			retNode.setAttribute("data-style", styleName);
			return retNode;
			//*/
		},
		calcStyleList : function() {
			this.blockStyleList = {};
			this.blockStyleList["block-h1"] = document.createElement("h1");
			this.blockStyleList["block-h2"] = document.createElement("h2");
			this.blockStyleList["block-h3"] = document.createElement("h2");
			this.blockStyleList["block-h4"] = document.createElement("h2");
			this.blockStyleList["block-text"] = document.createElement("div");
			this.blockStyleList["block-dialog"] = document.createElement("div");
			this.blockStyleList["block-question"] = document.createElement("div");
			this.blockStyleList["block-structures"] = document.createElement("div");
			this.blockStyleList["block-warning"] = document.createElement("div");
			this.blockStyleList["block-help"] = document.createElement("div");
			this.blockStyleList["block-example"] = document.createElement("div");
			this.blockStyleList["block-info"] = document.createElement("div");
			this.blockStyleList["block-translation"] = document.createElement("div");
			this.blockStyleList["block-footnote"] = document.createElement("div");
			
			this.inlineStyleList = {};
			//this.inlineStyleList["inline-normal"] = document.createElement("span");
			this.inlineStyleList["inline-bold"] = document.createElement("b");
			this.inlineStyleList["inline-italic"] = document.createElement("i");
			this.inlineStyleList["inline-suffix"] = document.createElement("span");
			this.inlineStyleList["inline-grammar"] = document.createElement("span");
			this.inlineStyleList["inline-grammar-male"] = document.createElement("span");
			this.inlineStyleList["inline-grammar-female"] = document.createElement("span");
			this.inlineStyleList["inline-grammar-neuter"] = document.createElement("span");
			
			
			for (var i in this.blockStyleList) {
				this.blockStyleList[i].setAttribute("data-style", i);
			}
			for (var i in this.inlineStyleList) {
				this.inlineStyleList[i].setAttribute("data-style", i);
			}
		},
		insertBlock : function(styleName) {
			var param, node, styleName;
			if (node = this.getStyleElement(styleName)) {
				param = {};
				param.parentNode = node;
				this.parentView.parseCommand("stylePicker-insert", null, param);
			}
		},
		insertInline : function(styleName) {
			var param, node, styleName;
			if (this.inlineStyleList[styleName]) {
				node = this.getStyleElement(styleName);
				
				param = {};
				param.parentNode = node;
				this.parentView.parseCommand("stylePicker-insert", null, param);
			}
		},
		clearError: function() {
			//this.outputNode.setAttribute("style", "display: none");
		},
		setError : function(text, func) {
			console.log("StylePicker Error!");
			if (func) {
				console.log("	Function: %o", func);
			}
			console.log("	Exception: %o", text);
		},
	}
});


LearningObject.View.TablePicker = Trait.build({
	uses : [
		"ViewElementList",
	],
	construct : function(ownerView, viewId) {
		this.ViewElementList(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.tablePicker.xsl")
		);
	},
	vars : {
		currentNode : undefined,
		tableMenuNode : undefined,
		tableCommandNodeList : undefined,
		styleNodeList : undefined,
		styleAttribute : "data-table-attribute",
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		},
		draw : function() {
			this.ViewElementListDraw();
			nodeList = XPath.evaluate(".//html:select", this.drawFragment);
			for (i = 0; i < nodeList.length; i++) {
				node = nodeList[i];
				node._tablePicker = this;
				node.addEventListener(
					"change",
					function(eve) {
						this._tablePicker.setStyle(this);
					},
					false
				);
			}
			this.styleNodeList = nodeList;
			this.tableMenuNode = XPath.evaluate("descendant-or-self::*[@data-tablePicker='table']", this.drawFragment)[0];
			this.tableCommandNodeList = XPath.evaluate("descendant-or-self::*[@data-tablePicker='table']/html:button", this.drawFragment);
			
			this.setCurrentNode(this.currentNode);
		},
		clearError: function() {
			//this.outputNode.setAttribute("style", "display: none");
		},
		setError : function(text, func) {
			console.log("StylePicker Error!");
			if (func) {
				console.log("	Function: %o", func);
			}
			console.log("	Exception: %o", text);
		},
		setCurrentNode : function(node) {
			var i, key;
			if (node && node.nodeType === Node.ELEMENT_NODE) {
				this.currentNode = node;
			} else {
				this.currentNode = undefined;
			}
			
			if (this.currentNode) {
				if (this.tableMenuNode) {
					this.tableMenuNode.removeAttribute("disabled");
				}
				for (i = 0; i < this.styleNodeList.length; i++) {
					node = this.styleNodeList[i];
					node.disabled = false;
					key = node.getAttribute(this.styleAttribute);
					if (this.currentNode.hasAttribute(key)) {
						node.value = this.currentNode.getAttribute(key);
					} else {
						node.value = "";
					}
				}
				for (i = 0; i < this.tableCommandNodeList.length; i++) {
					node = this.tableCommandNodeList[i];
					node.disabled = false;
				}
			} else {
				if (this.tableMenuNode) {
					this.tableMenuNode.setAttribute("disabled", "disabled");
					this.tableMenuNode.removeAttribute("open");
				}
				for (i = 0; i < this.styleNodeList.length; i++) {
					node = this.styleNodeList[i];
					node.disabled = true;
				}
				for (i = 0; i < this.tableCommandNodeList.length; i++) {
					node = this.tableCommandNodeList[i];
					node.disabled = true;
				}
			}
		},
		setStyle : function(styleNode) {
			if (this.currentNode) {
				this.currentNode.setAttribute(styleNode.getAttribute(this.styleAttribute), styleNode.value);
			}
		},
	}
});


LearningObject.View.User = Trait.build({
	uses : [
		"ViewElement",
		"ControllerCommand",
	],
	construct : function(ownerView, viewId) {
		this.ViewElement(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.user.xsl")
		);
		this.ownerView.controller.loadView(
			"editor-output",
			this,
			function(childView) {
				this.outputView = childView;
				this.ownerView.sendMessage(ACTION.CONTROLLER_DATA_SHUFFLE);
			}
		);
	},
	vars : {
		outputView 	: undefined,
	},
	methods : {
		asNode : function(dataDoc) {
			return dataDoc.importNode(this.data.dataDoc.documentElement, true);
		},
		draw : function() {
			var parentNode;
			this.ViewElementDraw();
			this.ControllerCommandDraw();
			parentNode = XPath.evaluate(".//*[@data-lo-id='editor-output']", this.drawFragment)[0];
			if (this.outputView && parentNode) {
				this.outputView.setDrawParent(parentNode);
				this.outputView.draw();
			}
		},
		
	}
});


LearningObject.View.XMLEditor = Trait.build({
	uses : [
		"ViewElement",
		"ControllerCommand",
	],
	construct : function(ownerView, viewId) {
		this.ViewElement(
			ownerView,
			viewId,
			DOM.loadDocument(LearningObject.PATH_TEMPLATES + "LearningObject.xml-editor.xsl")
		);
	},
	vars : {
		inputNode : undefined,
		outputNode : undefined,
		events : {
			textareaStretch : function(eve) {
				var rowMax = 32768, rowStep = 32;
				if (this.rows < rowStep) {
					this.rows = rowStep;
				}
				while (this.scrollHeight > this.clientHeight && this.rows < rowMax) {
					this.rows += rowStep;
				}
			},
		},
	},
	methods : {
		asNode : function(dataDoc) {
			var retNode = dataDoc.createElement("input");
			retNode.appendChild(dataDoc.createTextNode(DOM.saveXML(this.data.dataDoc)));
			return retNode;
		},
		draw : function() {
			this.ViewElementDraw();
			this.ControllerCommandDraw();
			
			this.inputNode = XPath.evaluate(".//html:textarea", this.drawFragment)[0];
			this.inputNode.xmlEditor = this;
			this.inputNode.addEventListener(
				"mouseenter",
				this.events.textareaStretch,
				false
			);
			this.inputNode.addEventListener(
				"focus",
				this.events.textareaStretch,
				false
			);
			this.events.textareaStretch.call(this.inputNode);
			
			this.outputNode = XPath.evaluate(".//html:pre", this.drawFragment)[0];
			this.outputNode.xmlEditor = this;
			this.outputNode.addEventListener(
				"input",
				this.events.textareaStretch,
				false
			);
			this.events.textareaStretch.call(this.outputNode);
			
			this.clearError();
		},
		parseCommand : function(name) {
			this.clearError();
			try {
				switch (name) {
					case "reset":
						loadLearningObject(this.ownerView.model.data.id, "editor", this.ownerView.langId);
						this.ownerView.controller.exit();
						return;
					case "apply":
						var newDoc = DOM.loadXML(this.inputNode.value);
						this.ownerView.model.parseMessage(ACTION.MODEL_DATA_SET_DOC, newDoc);
						this.ownerView.draw();
						break;
					case "save":
						var newDoc = DOM.loadXML(this.inputNode.value);
						this.ownerView.model.parseMessage(ACTION.MODEL_DATA_SET_DOC, newDoc);
						this.ownerView.draw();
						this.ownerView.model.parseMessage(ACTION.MODEL_DATA_SAVE);
						break;
				}
			} catch(e) {
				this.setError(e);
			}
		},
		clearError: function() {
			this.outputNode.setAttribute("style", "display: none");
		},
		setError : function(text) {
			console.log("XMLEditor Error!");
			console.log("	Exception: %o", text);
			this.outputNode.textContent = text;
			this.outputNode.removeAttribute("style");
		},
	}
});


//© 2010 Daniel Schulz

Renderer.LearningObject = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObject";
				
	this.data["lo_type"] = "lo_text";
	this.data["body"] = "";

	this.domTree = {
		_anchor : null,
		_title : null,	
			
		body : null,
		_object : null,
	};

	this.isContent = true;
	this.isContainer = false;
	
}
Renderer.LearningObject.prototype = new Renderer.abstractObject();

Renderer.LearningObject.prototype.prepareObject = function() {
	if (this.div ||  this.makeDiv()) {			
		//Einführung...
		this.domTree["body"] = HTML.makeElement(
			"div",
			["class"],
			["RendererBody"],
			this.data["body"]
		);
		this.checkOnsubmit();
	}
};


//© 2010 Daniel Schulz

Renderer.LearningObjectAudio = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObjectAudio";
				
	this.data["href"] = "";
	//this.data["mimetype"] = "";
	
	this.domTree = {	//enthält alle html-elemente, die für diese aufgabe erzeugt werden
		_anchor : null,
		_title : null,
		media : null
	};

	this.isContent = false;
	this.isContainer = false;
	
}
Renderer.LearningObjectAudio.prototype = new Renderer.abstractObject();

Renderer.LearningObjectAudio.prototype.prepareObject = function() {
	var node;
	
	if (this.navi_title) {
		node = HTML.makeElement(
			"audio",
			["class", 			"src", 				"preload", 	"controls"],
			["RendererAudio", 	this.data["href"], 	"auto", 	"controls"]
		);
		this.navi_title.appendChild(node);
	}
	if (this.div ||  this.makeDiv()) {
		/*
		//HTML???
		this.domTree["media"] = HTML.makeElement(
			"object",
			["class", "type", "data", "width", "height", "autostart", "controller"],
			["RendererAudio", this.data["mimetype"], this.data["href"], "320", "32", "false", "true"]
		);
		
		//HTML5
		this.domTree["media"] = HTML.makeElement(
			"audio",
			["class", 			"src", 				"preload", 	"controls"],
			["RendererAudio", 	this.data["href"], 	"auto", 	"controls"]
		);
		//*/

		this.checkOnsubmit();
	}
};


//© 2010 Daniel Schulz

Renderer.LearningObjectContainer = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObjectContainer";
				
	this.domTree = {
		_title : "",
		_object : null
	};
	
	this.buttonTree = {
		"next" : null
	};
	
	this.isContent = false;
	this.isContainer = true;
}
Renderer.LearningObjectContainer.prototype = new Renderer.abstractObject();

Renderer.LearningObjectContainer.prototype.prepareObject = function() {
};


//© 2010 Daniel Schulz

Renderer.LearningObjectCourse = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObjectCourse";
				
	this.domTree = {
		//_title : "",
		_object : null
	};
	this.buttonTree = {
		"next" : null
	};
	
	this.isContent = false;
	this.isContainer = true;
}
Renderer.LearningObjectCourse.prototype = new Renderer.abstractObject();

Renderer.LearningObjectCourse.prototype.prepareObject = function() {


};


//© 2013 Daniel Schulz

Renderer.LearningObjectExercise = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObjectExercise";
	
	this.domTree = {	//enthält alle html-elemente, die für diese aufgabe erzeugt werden
		_anchor : null,
		_title : null,
		loRoot : null
	};

	this.isContent = true;
	this.isContainer = false;
	
	this.loLoaded = false;
	this.loView = "user";
	this.lo = new LearningObject();
}
Renderer.LearningObjectExercise.prototype = new Renderer.abstractObject();

Renderer.LearningObjectExercise.prototype.prepareObject = function() {
	if (this.div ||  this.makeDiv()) {
		var listener, i, keep, res;
		listener = {};
		listener.context = this;
		listener.handleEvent = function() {
			HTML.addClass(this.navi, "Renderer-LO-submit");
		};
		HTML.addClass(this.navi, "Renderer-LO");
		//alert(this.rootObject.data._ref);
		this.domTree["loRoot"] = HTML.makeElement("div", ["class"], ["RendererLearningObjectExercise"]);
		this.lo.view.setDrawParent(this.domTree["loRoot"]);
		this.lo.controller.addEventListener("submit", listener);
		this.lo.controller.setLangId(this.data.langId);
		//this.lo.controller.loadDataById(this.data._ref);
		//this.lo.controller.loadView(this.loView);
		this.lo.controller.setCourseRef(this.rootObject.data._ref);
		
		res = [];
		for (i = 0; i < this.data._objects.length; i++) {
			keep = true;
			switch (this.data._objects[i].type) {
				case "lo_audio":
					keep = false;
					break;
				case "lo_session_log":
					HTML.addClass(this.navi, "Renderer-LO-submit");
					break;
			}
			if (keep) {
				res.push(this.data._objects[i]);
			}
		}
		this.data._objects = res;

		this.checkOnsubmit();
	}
};

Renderer.LearningObjectExercise.prototype.prepareContent = function() {
	if (!this.loLoaded) {
		this.loLoaded = true;
		this.lo.controller.loadDataById(this.data._ref);
		this.lo.controller.loadView(this.loView);
	}
};


//© 2010 Daniel Schulz

Renderer.LearningObjectImage = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObjectImage";
				
	this.data["href"] = "";
	this.data["mimetype"] = "";
	
	this.domTree = {	//enthält alle html-elemente, die für diese aufgabe erzeugt werden
		_anchor : null,
		_title : null,
		media : null
	};

	this.isContent = true;
	this.isContainer = false;
	
}
Renderer.LearningObjectImage.prototype = new Renderer.abstractObject();

Renderer.LearningObjectImage.prototype.prepareObject = function() {
		if (this.div ||  this.makeDiv()) {
			//Img..
			this.domTree["media"] = HTML.makeElement(
										"img",
										["class", "src", "alt"],
										["RendererImage", this.data["href"], this.data["_title"]]);
			
			//this.showContent();
			this.checkOnsubmit();
		}
};


//© 2013 Daniel Schulz

Renderer.LearningObjectSessionLog = function(sid, ajaxScript, id, pool) {
	this.constructor(sid, ajaxScript, id, pool);
	this.__class__ = "LearningObjectSessionLog";
	
	this.domTree = {	//enthält alle html-elemente, die für diese aufgabe erzeugt werden
		_anchor : null,
		_title : null,
		logRoot : null
	};

	this.isContent = true;
	this.isContainer = false;
}
Renderer.LearningObjectSessionLog.prototype = new Renderer.abstractObject();

Renderer.LearningObjectSessionLog.prototype.prepareObject = function() {
	if (this.div ||  this.makeDiv()) {			
		//Einführung...
		this.domTree["body"] = HTML.makeElement(
			"div",
			["class"],
			["RendererBody"]
		);
		this.checkOnsubmit();
	}
};

Renderer.LearningObjectSessionLog.prototype.prepareContent = function() {
	if (this.domTree["body"]) {
		var dataNode;
		try {
			dataNode = DOM.loadXML(this.data["_xml"]);
			dataNode = dataNode.documentElement;
			dataNode = document.importNode(dataNode, true);
			this.domTree["body"].appendChild(dataNode);
		} catch (e) {
			alert(e);
		}
	}
};