true, wenn der Loader existiert, sonst false
* @type boolean
*/
ResourceLoader.exists = function(id) {
return (typeof ResourceLoader.loaderMap[id] == "object");
}
/**
* Liefert den Loader mit der angegebenen Id
* @param {id} id Id des Loaders
* @return Loader mit der angegebenen Id oder null, wenn kein Loader mit der Id, existiert
* @type ResourceLoader
*/
ResourceLoader.getLoader = function(id) {
return ResourceLoader.loaderMap[id];
}
/**
* Liefert die Id des Loaders
* @return Id des Loaders
* @type String
*/
ResourceLoader.prototype.getId = function() {
return this.id;
}
/**
* Erzeut einen HTTP-Request fuer Ajax-Abfragen
* @return Liefert ein Cross-Browser XMLHttpRequest zurueck
* @type XMLHttpRequest
* @private
*/
ResourceLoader.createRequest = function() {
if (ResourceLoader.xml.useXmlHttp){
return new XMLHttpRequest();
} else if(ResourceLoader.xml.useActiveX) {
if(!ResourceLoader.xmlHttpVersion) {
for(var i = 0; i < ResourceLoader.ARR_XMLHTTP_VERS.length; i++) {
try {
new ActiveXObject(ResourceLoader.ARR_XMLHTTP_VERS[i]);
ResourceLoader.xmlHttpVersion = ResourceLoader.ARR_XMLHTTP_VERS[i];
break;
} catch(oError) {} // Absicht: Hier soll kein Error geworfen werden!
// es wird die "beste" Version fuer MSIE ermittelt
}
}
if(ResourceLoader.xmlHttpVersion) {
return new ActiveXObject(ResourceLoader.xmlHttpVersion);
} else {
// AT.log("atoolo: Could not create XML HTTP Request.", "error");
}
} else {
// AT.log("atoolo: Your browser doesn't support an XMLHTTP Request.", "error");
}
return null;
}
/**
* Liefert true, wenn der Browser Ajax unterstuetzt.
* @return true, wenn der Browser Ajax unterstuetzt.
* @type boolean
*/
ResourceLoader.isAjaxSupported = function() {
return ResourceLoader.xml.useXmlHttp || ResourceLoader.xml.useActiveX;
}
/**
* Bricht einen aktiven ansynchronen Request ab.
* @type void
*/
ResourceLoader.prototype.abort = function() {
try {
for (key in this.asynchronRequests) {
var req = this.asynchronRequests[key];
if (req != null && !this.isAborted) {
this.isAborted = true;
// AT.log("ResourceLoader.prototype.abort(): abort request", "warn");
req.abort();
}
this.asynchronRequests = new Object();
}
} catch (e) {
// AT.log("ResourceLoader.prototype.abort(): " + e, "error", e);
}
}
/**
* Liefert den Fortschritt der Asynchron geladenen Rresoucen in Prozent
* @return Fortschritt der Asynchron geladenen Rresoucen in Prozent
* @type int
*/
ResourceLoader.prototype.getAsynchronLoadStatus = function() {
var status = 0;
if (this.asynchronRequestCounter == 0) {
status = 100;
} else {
var processStatus = 0;
var c = 0;
for (id in this.asynchronRequests) {
c++;
var req = this.asynchronRequests[id];
if(req.readyState == 1) {
processStatus += 1;
} else if(req.readyState == 2) {
processStatus += 2;
} else if(req.readyState == 3) {
processStatus += 2;
} else if(req.readyState == 4) {
processStatus += 3;
} else {
// AT.log(c + " unknown state: " + id + ": " + req.readyState ,"error");
}
}
if (this.asynchronRequestCounter != c) {
// AT.log("invalid request counter " + this.asynchronRequestCounter + " != " + c, "error");
}
if (processStatus > (this.asynchronRequestCounter * 3)) {
// AT.log("processStatus greater as counter " + processStatus, "error");
}
status = (processStatus * 100) / (this.asynchronRequestCounter * 3);
}
if (status >= 100) {
if (status > 100) {
// AT.log("calculation error: status = " + status, "error");
}
return 100;
} else {
return status;
}
}
/**
* Wird fuer jede, im Ladevorgang befindliche Resouces aufgerufen, wenn sich desses Lade-Status
* geaendert hat
* @type void
* @private
*/
ResourceLoader.prototype.onreadystatechange = function(sWorkon, sUrl) {
var sId = ResourceLoader.createId(sUrl);
var req = this.asynchronRequests[sId];
if (req) {
if (req.readyState == 1) {
} else if(req.readyState == 2) {
} else if(req.readyState == 3) {
} else if(req.readyState == 4) {
var response = null;
if (req.status == 200) {
if ((Plappadu.Utils.Browser.isIE6 || Plappadu.Utils.Browser.isIE7) && sWorkon == 'addCss') { // MSIE6 workaround
this.cssBatch.push(req.responseText);
} else {
response = this.workon(sWorkon, sUrl, req);
}
//AT.log(sUrl + " loaded");
} else {
response = "error";
// AT.log(sUrl + " loading failed, status: " + req.status, "error");
}
delete this.asynchronRequests[sId];
this.asynchronRequestCounter--;
if (this.asynchronRequestCounter == 0 && this.isFinished) {
if (Plappadu.Utils.Browser.isIE6 || Plappadu.Utils.Browser.isIE7) { // MSIE6 workaround
this.executeCssBatch();
}
ResourceLoader.removeLoader(this.getId());
if (this.asynchronCallback != null) {
this.asynchronCallback(response);
}
}
}
} else {
// AT.log("request " + sId + " not found", "error");
}
}
/**
* Fuert einen Request aus und Liefert je nach sWorkon ein Objekt zurueck.
* Das sWorkon definiert wie der Request verarbeitet werden soll. Folgende Werte sind moeglich
* sWorkon | Beschreibung |
|---|---|
| addJs | Laed ein JavaScript und fuegt es in das Document ein. Der Rueckgabewert ist null |
| addCss | Laed eine CSS-Datei und fuegt es in das Document ein. Der Rueckgabewert ist null |
| addVb | Laed eine Visual-Basic-Datei und fuegt es in das Document ein. Der Rueckgabewert ist null |
| getFileContent | Liefert den Inhalt der Datei als String zurueck |
| getXML | Liefert die Datei als XML-DOMDocument zurueck |
| getJson | Evaluiert den Inhalt der Datei und liefert in als Java-Script-Objekt (JSON) zurueck |
oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @param {Array} aRequestHeader Mit zu sendende HTTP-Request Header
* @param {String} sWorkon gibt an, wie der Request verarbeitet werden soll (addJs|addCss|addVb|getFileContent|getXml|getJson)
* @return Je nach sWorkon wird ein Objekt oder null zurueckgeliefert:sWorkon wird null zurueckgeliefert
* null, wenn nicht gesendet werden soll.
* oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @return JavaScript-Object der JSON-Datei
* @type JSONObject
*/
ResourceLoader.getJsonObject = function(url, oContent) {
// Plappadu.log("gettingJsonObject");
var method = null;
// Plappadu.log("url:"+url);
// Plappadu.log("oContent:"+oContent);
if (oContent == null) {
method = "GET";
} else {
method = "POST";
}
// Plappadu.log("method:"+method);
var loader = ResourceLoader.createLoader();
try {
return loader.doRequest(method, url, oContent, null, 'getJson');
} finally {
ResourceLoader.removeLoader(loader.getId());
}
}
/**
* Laed ein JavaScript-Object (JSON) asynchron und ruft eine Callback-Methode auf, wenn es geladen wurde
* @param {String} url URL der JSON-Datei
* @param {Object} oContent Inhalt der gesendet werden soll oder null, wenn nicht gesendet werden soll.
* oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @param {String} callback Callback-Methode, die aufgerufen wird, wenn des JSON-Objekt geladen wurde. Der Methode wird das
* geladene JSON-Objekt uebergeben.
* @type void
*/
ResourceLoader.loadJsonObject = function(url, oContent, callback) {
// AT.log("gettingJsonObject");
var method = null;
if (oContent == null) {
method = "GET";
} else {
method = "POST";
}
var loader = ResourceLoader.createAsynchronLoader(null, callback);
loader.doRequest(method, url, oContent, null, 'getJson');
loader.isFinished = true;
}
/**
* Liefert ein XML-DOMDocument-Object (JSON) aus einer XML-Dateu zurueck
* @param {String} url URL der XML-Datei
* @param {Object} oContent Inhalt der gesendet werden soll oder null, wenn nicht gesendet werden soll.
* oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @return XML-DOMDocument-Object der XML-Datei
* @type DOMDocument
*/
ResourceLoader.getDOMDocument = function(url, oContent) {
var method = null;
if (oContent == null) {
method = "GET";
} else {
method = "POST";
}
var loader = ResourceLoader.createLoader();
try {
return loader.doRequest(method, url, oContent, null, 'getXml');
} finally {
ResourceLoader.removeLoader(loader.getId());
}
}
/**
* Liefert den Inhalt einer Datei
* @param {String} url URL der Datei
* @param {Object} oContent Inhalt der gesendet werden soll oder null, wenn nicht gesendet werden soll.
* oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @return Inhalt der Datei
* @type String
*/
ResourceLoader.getContent = function(url, oContent) {
var method = null;
if (oContent == null) {
method = "GET";
} else {
method = "POST";
}
var loader = ResourceLoader.createLoader();
try {
return loader.doRequest(method, url, oContent, null, 'getFileContent');
} finally {
ResourceLoader.removeLoader(loader.getId());
}
}
/**
* Liefert ein DOM-Document aus einer externen XML-Datei, ueber das forward-Servlet.
* @param {String} url URL der XML-Datei
* @param {Object} oContent Inhalt der gesendet werden soll oder null, wenn nicht gesendet werden soll.
* oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @return XML-DOMDocument-Object der XML-Datei
* @type DOMDocument
*/
ResourceLoader.getExternalDOMDocument = function(url, oContent) {
var url = "/forward/?url="+encodeURIComponent(url);
return ResourceLoader.getDOMDocument(url, oContent);
}
/**
* Liefert den Inhalt einer Externen URL
* @param {String} url URL der Datei
* @param {Object} oContent Inhalt der gesendet werden soll oder null, wenn nicht gesendet werden soll.
* oContent kann ein HTML-Formular sein dessen Felder ausgelesen und denen ein URL-ParameterString generiert wird. Sonst muss
* oContent ein String sein der einen URL-ParameterString enthaehlt der per GET oder POST versendet werden kann
* @return Inhalt der Datei
* @type String
*/
ResourceLoader.getExternalContent = function(url, oContent, tidy) {
if((tidy == null) || (tidy == "false")) { tidy = false; }
var url = "/forward/?url="+encodeURIComponent(url)+"&tidy="+tidy;
return ResourceLoader.getContent(url, oContent);
}
/**
* Liefert den Inhalt einer Datei aus Atoolo-Disk
* @param {String} fileName Name der Datei die geladen werden soll
* @param {String} storageId Id der Datei die geladen werden soll
* @return Inhalt der Datei
* @type String
*/
ResourceLoader.getStorageFileContent = function(fileName, storageId, parentId, tidy) {
if(tidy == null) { tidy = false; }
if(storageId == null) {
storageId = ResourceLoader.getStorageIdByName(fileName, parentId);
}
var url = "/control/"+encodeURIComponent(fileName)+"?sys_mt_storage_action=load&mt_storage_id="+storageId+"&sys_mt_jsp_Handler=com.cynapsis.myTools.http.handler.HttpStorageHandler";
if(tidy) { url += "&tidy=true"; }
var loader = ResourceLoader.createLoader();
try {
return loader.doRequest('GET', url, null, null, 'getFileContent');
} finally {
ResourceLoader.removeLoader(loader.getId());
}
}
/**
* Liefert das DOMDocument aus Atoolo-Disk
* @param {String} fileName Name der Datei die geladen werden soll
* @param {String} storageId Id der Datei die geladen werden soll
* @return Inhalt der Datei
* @type String
*/
ResourceLoader.getStorageDOMDocument = function(fileName, storageId, parentId, tidy) {
if(tidy == null) { tidy = false; }
if (storageId == null) {
storageId = ResourceLoader.getStorageIdByName(fileName, parentId);
}
var url = "/control/"+encodeURIComponent(fileName)+"?sys_mt_storage_action=load&mt_storage_id="+storageId+"&sys_mt_jsp_Handler=com.cynapsis.myTools.http.handler.HttpStorageHandler";
if(tidy) { url += "&tidy=true"; }
var loader = ResourceLoader.createLoader();
try {
return loader.doRequest('GET', url, null, null, 'getXml');
} finally {
ResourceLoader.removeLoader(loader.getId());
}
}
/**
* Holt die StorageId einer Datei von Atoolo-Disk
* @param {String} fileName Name der Datei die geladen werden soll
* @param {String} parentId Id des Verzeichnisses, in dem die Datei liegt
* @return Id der Atolo-Disk-Datei
* @type String
*/
ResourceLoader.getStorageIdByName = function(fileName, parentId) {
var url = "/json/getFileByName.jsp?fileName="+fileName;
if (parentId != null) {
url += "&parentId=" + parentId;
}
var loader = ResourceLoader.createLoader();
try {
var file = loader.doRequest('GET', url, null, null, 'getJson');
if (file == null || file == 'undefined' || file == '' || file.id == null) {
return null;
} else {
return file.id;
}
} finally {
ResourceLoader.removeLoader(loader.getId());
}
}
/**
* Erzeugt aus einem HTML-Formular eine POST-Body-String
* @param {HTMLFormElement} oForm HTML-Formular-Element
* @return POST Body
* @type String
* @private
*/
ResourceLoader.getRequestBody = function(oForm) {
var aParams = new Array();
var addField = function(name,value) {
var sParam = encodeURIComponent(name);
sParam += "=";
sParam += encodeURIComponent(value);
aParams.push(sParam);
};
for (var i=0 ; i < oForm.elements.length; i++) {
var el = oForm.elements[i];
if (!el.disabled) {
switch(el.type) {
case 'text': case 'password': case 'hidden': case 'textarea': case 'file':
addField(el.name, el.value);
break;
case 'select-one':
if (el.selectedIndex>=0) {
addField(el.name,el.options[el.selectedIndex].value);
}
break;
case 'select-multiple':
for (var j=0; jfalse, wenn
* das JavaScript bereits enthalten ist
* @type boolean
* @private
*/
ResourceLoader.addJs = function(sContent, sUrl) {
try {
var sId = ResourceLoader.createId(sUrl);
var scriptNode = document.getElementById(sId);
if (scriptNode == null) {
var scriptNode = document.createElement("script");
scriptNode.type = "text/javascript";
scriptNode.id = "JS" + sId;
//scriptNode.charset = "UTF-8";
if (sContent == null) {
scriptNode.src = sUrl;
}
//document.getElementsByTagName("body")[0].appendChild(scriptNode);
document.getElementById("scripts").appendChild(scriptNode);
if (sContent != null) {
scriptNode.text = sContent;
}
return true;
} else {
return false;
}
return scriptNode;
} catch (e) {
}
}
/**
* Fuegt ein VB-Script dynamisch in die Seite ein
* @param {String} sContent VB-Script Source
* @param {String} sUrl URL des VB-Script
* @return liefert true wenn das VB-Script hinzugefuegt wurde oder false, wenn
* das VB-Script bereits enthalten ist
* @type boolean
* @private
*/
ResourceLoader.addVb = function(sContent, sUrl) {
var sId = ResourceLoader.createId(sUrl);
var scriptNode = document.getElementById(sId);
if (scriptNode == null) {
var scriptNode = document.createElement("script");
scriptNode.type = "text/vbscript";
scriptNode.id = "VB" + sId;
scriptNode.charset = "UTF-8";
if (sContent == null) {
scriptNode.src = sUrl;
}
document.getElementsByTagName("head")[0].appendChild(scriptNode);
if (sContent != null) {
scriptNode.text = sContent;
}
return true;
} else {
return false;
}
}
/**
* Fuegt alle gesammelten CSS in den DOM-Baum
* @type void
* @private
*/
ResourceLoader.prototype.executeCssBatch = function() { // MSIE6 workaround
try {
if (this.cssBatch == null || this.cssBatch.length == 0) {
return;
}
var t1 = new Date().getTime();
if (this.loadingLevel == "base") {
var cssNode = document.getElementById("base");
if (cssNode == null) {
cssNode = document.createElement("style");
cssNode.id = "base";
cssNode.type = "text/css";
document.getElementsByTagName("head")[0].appendChild(cssNode);
}
if (ResourceLoader.cssDependentSources["dependent1"]) {
// AT.log("rewrite base css, possible overwrite dependent css", "warn");
}
ResourceLoader.cssBaseSources.push(this.cssBatch.join("\n"));
cssNode.styleSheet.cssText = ResourceLoader.cssBaseSources.join("\n"); // ist ja eh nur fuer'n MSIE
} else if (this.loadingLevel == 'dependent') {
var smallest = null;
var min = -1;
var counter = 0;
for (key in ResourceLoader.cssDependentSources) {
counter++;
if (min == -1 || min < ResourceLoader.cssDependentSources[key].length) {
smallest = key;
min = ResourceLoader.cssDependentSources[key].length;
}
}
var cssNode = null;
var key = null;
// verwende maximal 20 Style-Tags
if (counter == 0 || counter < 1) {
key = "dependent" + (counter + 1);
cssNode = document.getElementById(key);
if (cssNode == null) {
cssNode = document.createElement("style");
cssNode.id = key;
cssNode.type = "text/css";
document.getElementsByTagName("head")[0].appendChild(cssNode);
}
} else {
key = smallest;
cssNode = document.getElementById(smallest);
}
var css = null;
if (ResourceLoader.cssDependentSources[key]) {
css = ResourceLoader.cssDependentSources[key] + "\n" + this.cssBatch.join("\n");
} else {
css = this.cssBatch.join("\n");
}
ResourceLoader.cssDependentSources[key] = css;
cssNode.styleSheet.cssText = css; // ist ja eh nur fuer'n MSIE
}
//AT.log("addCss bad version TIMER: " + (new Date().getTime() - t1), "info");
} catch (e) {
// AT.log("ResourceLoader.executeCssBatch: " + e, "error", e);
}
}
/**
* Fuegt ein CSS dynamisch in die Seite ein
* @param {String} sUrl URL des CSS
* @return liefert true wenn das CSS hinzugefuegt wurde oder false, wenn
* das CSS bereits enthalten ist
* @type boolean
* @private
*/
ResourceLoader.addCss = function(sContent, sUrl) {
var sId = ResourceLoader.createId(sUrl);
var cssNode = document.getElementById(sId);
if (cssNode == null) {
var t1 = new Date().getTime();
if (sContent == null) {
cssNode = document.createElement("link");
cssNode.id = sId;
cssNode.type = "text/css";
cssNode.rel = "stylesheet";
cssNode.href = sUrl;
document.getElementsByTagName("head")[0].appendChild(cssNode);
} else {
cssNode = document.createElement("style");
cssNode.id = sId;
cssNode.type = "text/css";
document.getElementsByTagName("head")[0].appendChild(cssNode);
if (cssNode.styleSheet) { // MSIE
cssNode.styleSheet.cssText = sContent;
} else { // DOM
var cssText = document.createTextNode(sContent);
cssNode.appendChild(cssText);
}
}
//AT.log("addCss good version TIMER: " + (new Date().getTime() - t1), "info");
return true;
} else {
return false;
}
}