first commit

2024-12-12 15:33:18 +01:00
commit 2c8998663e
3360 changed files with 777573 additions and 0 deletions
--- a/resources/xajax/xajax_plugins/response/swfupload/swfupload.xajax_uncompressed.js
+++ b/resources/xajax/xajax_plugins/response/swfupload/swfupload.xajax_uncompressed.js
@@ -0,0 +1,972 @@
+
+	//xjxSWFup = xajax.ext.SWFupload;
+	
+	xajax.ext.SWFupload.swf = null;
+	
+	xajax.ext.SWFupload.forms = {};
+	xajax.ext.SWFupload.fields = {};
+	xajax.ext.SWFupload.queues = {};
+	xajax.ext.SWFupload.tools = {};
+ 	
+ 	/* default upload settings */
+	xajax.ext.SWFupload.settings = {
+											flash_url : xajax.ext.SWFupload.config.javascript_URI+"swfupload.swf",
+											file_size_limit : "0",
+											file_types : "*.*",
+											file_types_description : "All Files",
+											file_upload_limit : 0,
+											file_queue_limit : 0,
+											file_queue_error_handler  : xajax.ext.SWFupload.tools.fileQueueError,
+											debug: false,
+											button_image_url : "img/button_500x22.gif",
+											button_width : 270,
+											button_height : 22,
+											button_action :  SWFUpload.BUTTON_ACTION.SELECT_FILES,
+											button_window_mode: SWFUpload.WINDOW_MODE.TRANSPARENT,
+											button_placeholder_id :'' ,
+											button_text : '<span class="btnText">Select Files...</span>',
+											button_text_style : ".btnText { font-size: 10; font-weight: bold; font-family: MS Shell Dlg; }",
+											button_text_top_padding : 3,
+											button_text_left_padding : 100,
+											post_params : {}
+											}
+
+	if ('undefined' == typeof xajax.ext.SWFupload.lang) 
+	{
+		xajax.ext.SWFupload.lang = {};
+		xajax.ext.SWFupload.lang.browseFiles = 'Browse Files';
+		xajax.ext.SWFupload.lang.browseFile = 'Browse File';
+	}
+	
+	
+	
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.init
+		arguments: config [object]
+		
+		Creates the SWFupload instance	
+  */
+  	
+	xajax.ext.SWFupload.configure = function (config) 
+	{
+		if ("object" == typeof config) return xajax.ext.SWFupload.tools.mergeObj(this.settings,config);
+
+		return this.settings;		
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.addQueue
+		arguments: child [object], parent [object], config [objeect ,multiple [bool]
+		
+		Creates a new a new file queue and stores the reference in this.queues
+  */
+	xajax.ext.SWFupload.addQueue = function (child,parent,config,multiple)
+	{
+		var id = xajax.ext.SWFupload.tools.getId();
+		this.queues[id] = new xajax.ext.SWFupload.tools.fileQueue(id,child,parent,config,multiple);
+		
+		return id;		
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.applyConfig
+		arguments: oQueue [object]
+		
+		Applies the queue's config on the SWFupload instance
+  */
+	xajax.ext.SWFupload.applyConfig = function(oQueue) 
+	{
+		
+		var conf = oQueue.getConfig();
+		var swf = xajax.ext.SWFupload.getInstance();
+		
+		if ( 'undefined' != typeof conf.file_types ) 
+			swf.setFileTypes(conf.file_types, conf.file_types_description);
+		
+		if ( 'undefined' != typeof conf.file_size_limit ) 
+			swf.setFileSizeLimit(conf.file_size_limit);
+		
+		if ( 'object' == typeof conf.post_params) 
+		{
+			for (a in conf.post_params)
+			swf.addPostParam(a,conf.post_params[a]);
+		}
+		
+		swf.settings.file_queued_handler = function(oFile) {oQueue.addFile(oFile)};;
+		swf.settings.file_queue_error_handler = oQueue.fileQueueError;
+	}
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.selectFile
+		arguments: oQueue [object]
+		
+		Onclick handler for selecting file
+  */
+
+	xajax.ext.SWFupload.selectFile = function(oQueue) 
+	{
+		this.applyConfig(oQueue);
+		
+		if (oQueue.getConfig().file_queue_limit > 0 && oQueue.getConfig().file_queue_limit <= oQueue.queued) return;
+		
+		xajax.ext.SWFupload.getInstance().selectFile();
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.selectFiles
+		arguments: oQueue [object]
+		
+		Onclick handler for selecting files
+  */
+
+	xajax.ext.SWFupload.selectFiles = function(oQueue) 
+	{
+		this.applyConfig(oQueue);
+		if (oQueue.getConfig().file_queue_limit > 0 && oQueue.getConfig().file_queue_limit <= oQueue.queued) return;
+		xajax.ext.SWFupload.getInstance().selectFiles();
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.getInstance
+		arguments: 
+		
+		Return the SWFupload instance. If there's no instance available it creates a new one with default settings.
+  */
+
+	xajax.ext.SWFupload.getInstance = function() 
+	{
+		if (null == this.swf) this.swf = new SWFUpload(this.settings); 
+		
+		return this.swf;
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.removeFile
+		arguments: QueueId [integer] , FileId [integer]
+		
+		Removes the file (FileID) from queue (QueueId)
+  */
+
+	xajax.ext.SWFupload.removeFile = function(QueueId,FileId,finished) 
+	{
+		this.queues[QueueId].removeFile(FileId,finished);		
+	}
+
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+
+	xajax.ext.SWFupload.request = {};
+
+
+	/*
+		function: xajax.ext.SWFupload.request.getFileFromQueue
+		arguments: oRequest [object]
+		
+		Returns the first file from first available queue.
+		Returns false if no files were selected
+  */
+
+	xajax.ext.SWFupload.request.getFileFromQueue = function(oRequest)
+	{
+
+
+		var instances = {};
+		var queued = 0;
+		if ("string" == typeof oRequest.SWFform) 
+		{
+		
+		
+			if ('object' != typeof xajax.ext.SWFupload.forms[oRequest.SWFform])
+			{
+				return false;
+			}
+			for (a in xajax.ext.SWFupload.forms[oRequest.SWFform]) 
+			{
+				var field = xajax.ext.SWFupload.forms[oRequest.SWFform][a];
+				if (0 < xajax.ext.SWFupload.queues[field].queued) { 
+					oRequest.currentFile = xajax.ext.SWFupload.queues[field].getFile();
+					oRequest.swf = xajax.ext.SWFupload.queues[field].getSWF();
+					return true ;
+				};
+			}
+		} else if ("string" == typeof oRequest.SWFfield) 
+		{
+			if ('string' != typeof xajax.ext.SWFupload.fields[oRequest.SWFfield])
+			{
+				return false;
+			}
+
+			var qId = xajax.ext.SWFupload.fields[oRequest.SWFfield];
+				if (0 < xajax.ext.SWFupload.queues[qId].queued) { 
+					oRequest.currentFile = xajax.ext.SWFupload.queues[qId].getFile();
+					oRequest.swf = xajax.ext.SWFupload.queues[qId].getSWF();
+					return true ;
+				};
+		} else 
+		{
+
+			for (var a in xajax.ext.SWFupload.queues) 
+			{
+				if (0 < xajax.ext.SWFupload.queues[a].queued) { 
+					oRequest.currentFile = xajax.ext.SWFupload.queues[a].getFile();
+					oRequest.swf = xajax.ext.SWFupload.queues[a].getSWF();
+					return true;
+				};
+			}					
+		}
+		
+		return false;
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.request.	xajax.ext.SWFupload.request.processParameters = function(oRequest) 
+
+		arguments: oRequest [object]
+		
+		Processes the parameters
+  */
+
+	xajax.ext.SWFupload.request.processParameters = function(oRequest) 
+	{
+		if ("SWFupload" == oRequest.mode) 
+		{
+			oRequest.currentFile = false;
+			xajax.ext.SWFupload.request.getFileFromQueue(oRequest);
+			if (oRequest.currentFile)	oRequest.method='GET';
+		}
+		return xajax.ext.SWFupload.bak.processParameters(oRequest);
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.request.	xajax.ext.SWFupload.request.prepareRequest = function(oRequest) 
+
+		arguments: oRequest [object]
+		
+		doesn't to anything at all when there's a file selected for upload
+  */
+  
+	xajax.ext.SWFupload.request.prepareRequest = function (oRequest) 
+	{
+		if ("SWFupload" == oRequest.mode && false != oRequest.currentFile) return;
+		return xajax.ext.SWFupload.bak.prepareRequest(oRequest);
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.request.	xajax.ext.SWFupload.request.submitRequest = function(oRequest) 
+
+		arguments: oRequest [object]
+		
+		Submits the request either via SWFupload or XHR
+  */
+  
+	xajax.ext.SWFupload.request.submitRequest = function(oRequest) 
+	{
+		if ( "SWFupload" == oRequest.mode && false != oRequest.currentFile ) 
+		{
+
+			if (oRequest.requestURI) {
+				//backup requestURI, otherwise xajax.responseReceived() is going to delete our url
+				oRequest.bak_requestURI = oRequest.requestURI;
+			} else if (oRequest.bak_requestURI) {
+				oRequest.requestURI = oRequest.bak_requestURI;
+			}
+			
+			var swf = oRequest.swf;
+	
+			var fileQueue = xajax.ext.SWFupload.queues[oRequest.currentFile.QueueId];
+
+			swf.customSettings.currentFile = oRequest.currentFile;
+			swf.setFilePostName(swf.customSettings.currentFile.name);
+
+			swf.customSettings.oRequest = oRequest;
+			swf.setUploadURL(oRequest.requestURI);
+			
+			swf.settings.upload_success_handler =  function ( oFile, response ) 
+			{
+				var xx = xajax;
+				var xt = xx.tools;
+				var xcb = xx.callback;
+				var gcb = xcb.global;
+				var lcb = oRequest.callback;
+				
+				var oRet = oRequest.returnValue;
+
+				var FileId = swf.customSettings.currentFile;				
+				if ( 'function' == typeof this.old_upload_success_handler ) this.old_upload_success_handler( oFile );
+				xcb.execute([gcb, lcb], 'onSuccess', oRequest);
+				var seq = 0;
+				if (response) {
+					var responseXML = (new DOMParser()).parseFromString(response, "text/xml");
+					if (responseXML.documentElement) {
+						oRequest.status.onProcessing();
+						
+						var child = responseXML.documentElement.firstChild;
+						oRet = xt.xml.processFragment(child, seq, oRet, oRequest);
+					}
+				} 
+				var obj = {};
+				obj.fullName = 'Response Complete';
+				obj.sequence = seq;
+				obj.request = oRequest;
+				obj.context = oRequest.context;
+				obj.cmd = 'rcmplt';
+				xt.queue.push(xx.response, obj);
+				
+				// do not re-start the queue if a timeout is set
+				if (null == xx.response.timeout)
+					xt.queue.process(xx.response);
+			}
+
+			swf.settings.upload_complete_handler = function(oFile) 
+			{
+
+				var qFile = this.customSettings.currentFile;
+				xajax.ext.SWFupload.removeFile(qFile.QueueId,qFile.id,true);
+	
+				if ( !xajax.ext.SWFupload.request.getFileFromQueue(oRequest) ) 
+				{
+					if ('function' == typeof oRequest.onUploadComplete) oRequest.onUploadComplete();
+					return;
+				}
+
+				xajax.ext.SWFupload.request.submitRequest(oRequest);
+			}
+			
+
+			swf.settings.upload_start_handler = function(oFile) 
+			{
+				if ('function' == typeof this.old_upload_start_handler) this.old_upload_start_handler(oFile);
+				oRequest.startTime = new Date();
+
+			}
+			swf.settings.upload_progress_handler = function (oFile, bytesLoaded, bytesTotal) 
+			{
+
+				upload = {};
+				upload.received=bytesLoaded;
+				upload.total=bytesTotal;
+				upload.state="uploading";
+				var reqTime = new Date();
+	
+				upload.lastbytes = oRequest.lastbytes;
+				upload.now = reqTime.getTime() / 1000;
+				upload.start = oRequest.startTime.getTime()/ 1000;
+				
+				var step = upload.received / (upload.total / 100);
+				var progressbar = xajax.$('SWFup_progress_'+oFile.id);
+				var w = Math.round(220 *  step / 100);
+				progressbar.style.width=w+'px';
+				
+				var progress = xajax.$("swf_queued_filesize_"+oFile.id);
+				var elapsed = upload.now-upload.start;
+				var rate = xajax.ext.SWFupload.tools.formatBytes(upload.received/ elapsed).toString() + '/s';
+				progress.innerHTML = "<i>"+rate + "</i> "+xajax.ext.SWFupload.tools.formatBytes(upload.received)+"/"+xajax.ext.SWFupload.tools.formatBytes(upload.total);
+		    oRequest.lastbytes = upload.received;					
+				
+			}
+
+			swf.settings.upload_error_handler = function(file, errorCode, message) 
+			{
+				// Skipe error when a file is removed from queue (abort)
+				if (-280 == errorCode) return;
+				 if (file == null) {fileName = '';} else {
+				 	fileName = file.name;
+				 }
+				 
+				 alert("Error Code: "+errorCode+", File name: " + fileName + ", Message: " + message);		
+			};
+ 			swf.startUpload(swf.customSettings.currentFile.id);
+			return;
+		}
+		return xajax.ext.SWFupload.bak.submitRequest(oRequest);
+	}
+
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools.queueFile
+		arguments: oFile,QueueId,QueueContainer
+		
+  */
+		xajax.ext.SWFupload.tools.queueFile = function(oFile,name,QueueId,QueueContainer) {
+			
+			this.id = oFile.id;
+			this.name = name;
+			this.QueueId = QueueId;
+			
+			var container = document.createElement('div');
+			container.id = "SWFup_"+this.id;
+			container.className="swf_queued_file";
+			
+			this.elm = container; 
+			
+			var remove = document.createElement('div');
+			remove.className="swf_queued_file_remove";
+			remove.innerHTML="&nbsp;";
+			
+			var id = this.id;			
+			var QueueId = this.QueueId;			
+			remove.onclick= function () {
+				xajax.ext.SWFupload.removeFile(QueueId,id);
+			}
+			container.appendChild(remove);
+			
+			var label = document.createElement('div');
+			label.className="swf_queued_filename";
+			label.innerHTML = oFile.name;
+			container.appendChild(label);
+
+			var progress_container = document.createElement('div');
+			progress_container.className="swf_queued_file_progress_container";
+			container.appendChild(progress_container);		
+
+					
+			var progress = document.createElement('div');
+			progress.className="swf_queued_file_progress_bar";
+			progress.style.width='1px';
+			progress.id='SWFup_progress_'+oFile.id;
+			progress_container.appendChild(progress);		
+
+		
+			var fSize = document.createElement('div');
+			fSize.className="swf_queued_filesize";
+			fSize.id="swf_queued_filesize_"+this.id;
+			fSize.innerHTML = xajax.ext.SWFupload.tools.formatBytes(oFile.size);
+			container.appendChild(fSize);
+			
+			var fClear= document.createElement('div');
+			fClear.style.clear='both';
+			container.appendChild(fClear);
+			QueueContainer.appendChild(container);			
+	
+			this.container = container;
+			this.oFile = oFile;
+			
+			this.destroy = function() 
+			{
+				QueueContainer.removeChild(container);
+			}
+			
+			return;			
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools.fileQueue
+		arguments: id [integer],child [object], parent [object], multiple [bool]
+		
+		parses the form for fields
+  */	
+
+	xajax.ext.SWFupload.tools.fileQueue = function (id,child,parent,config,multiple)  
+	{
+
+
+		this.id = id;
+		var config = 'object' == typeof config ? xajax.ext.SWFupload.tools.mergeObj(xajax.ext.SWFupload.settings,config) : xajax.ext.SWFupload.settings;
+		this.queued = 0;
+		this.files = {};
+		this.queue = null;
+	
+		this.getConfig = function() {return config;}
+		
+		var tmpName = child.name;
+		var container = document.createElement('div');
+		container.id = 'SWFbuttonContainer_'+tmpName;
+		container.className='swf_browse_button';		
+		parent.appendChild(container);
+
+		
+		var container2 = document.createElement('div');
+		container2.id = 'SWFbutton_'+tmpName;
+		container.appendChild(container2);
+		
+		parent.removeChild(child);
+		
+		var oQueue = this;
+		if (true === multiple) 
+		{
+				config.button_action = SWFUpload.BUTTON_ACTION.SELECT_FILES;
+		} else {
+				config.button_action = SWFUpload.BUTTON_ACTION.SELECT_FILE;
+			
+		}
+
+		var QueueContainer = document.createElement('div');
+		QueueContainer.id = 'SWFqueue_'+ this.id;
+		QueueContainer.className = 'swf_queue_container';
+		parent.appendChild(QueueContainer);
+		
+		config.button_placeholder_id=container2.id;
+
+		var foo = this;
+		
+		var fieldname = child.name;
+		this.addFile = function (oFile) 
+		{
+			foo.files[oFile.id] = new xajax.ext.SWFupload.tools.queueFile(oFile,fieldname,foo.id,QueueContainer);
+			foo.queued++;
+			if (foo.queued == config.file_queue_limit) foo.swf.setButtonDisabled(true);
+		}
+		
+		this.getFile = function (FileId) 
+		{
+			if ("undefined" != typeof FileId) return foo.files[FileId];			
+			for (a in foo.files) return foo.files[a];				
+			return false;
+		}
+
+		this.purge = function (d) {
+		    var a = d.attributes, i, l, n;
+		    if (a) {
+		        l = a.length;
+		        for (i = 0; i < l; i += 1) {
+		            n = a[i].name;
+		            if (typeof d[n] === 'function') {
+		                d[n] = null;
+		            }
+		        }
+		    }
+		    a = d.childNodes;
+		    if (a) {
+		        l = a.length;
+		        for (i = 0; i < l; i += 1) {
+		            this.purge(d.childNodes[i]);
+		        }
+		    }
+		}
+		
+		this.removeFile = function(FileId,finished) 
+		{
+
+			foo.swf.cancelUpload(FileId);
+
+			foo.queued--;
+			if (foo.queued <= config.file_queue_limit) foo.swf.setButtonDisabled(false);
+				var filediv = xajax.$("SWFup_"+foo.files[FileId].id);
+				filediv.className = true === finished ? 'swf_queued_file_finished' : 'swf_queued_file_removed';
+				setTimeout(function () 
+				{
+					xajax.ext.SWFupload.tools.FadeOut(filediv,100);
+				}, xajax.ext.SWFupload.config.FadeTimeOut);
+
+			foo.files[FileId] = null;
+			delete foo.files[FileId];
+		}
+		this.destroy = function() {
+			
+			this.swf.destroy();
+			delete(this.swf);
+			for (a in foo.files) {
+				foo.files[a].destroy();
+				delete (foo.files[a]);
+			}
+			foo.queued=0;
+			delete(foo);
+		}
+		this.fileQueueError = function(swf,code,msg) {
+			if (-110 == code) {
+				msg = "Die gew&auml;hlte Datei ist zu gro&szlig;!";
+				alert(msg);
+			} 
+		}
+		
+		this.getSWF = function() {
+			return this.swf;
+			
+		}
+
+		config.file_queued_handler=this.addFile;
+		config.file_queue_error_handler=this.fileQueueError;
+
+		this.swf = new SWFUpload(config); 
+		
+	}
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools._parseFields
+		arguments: children [array],parent [object], config [object], multiple [bool]
+		
+		parses the form for fields
+  */	
+
+
+	xajax.ext.SWFupload.tools._parseFields = function(children,parent,config,multiple) 
+  {
+    var result={};
+		var iLen = children.length;
+		for (var i = 0; i < iLen; ++i) 
+		{
+			var child = children[i];
+			if ('undefined' != typeof child.childNodes)
+				var res2 = xajax.ext.SWFupload.tools._parseFields(child.childNodes,child,config,multiple);
+				result = xajax.ext.SWFupload.tools.mergeObj(result,res2);
+			if (child.name) 
+			{
+				if ('file' == child.type) 
+				{
+ 					result[child.name] = xajax.ext.SWFupload.addQueue(child,parent,config,multiple);
+				}
+			}
+		}
+		return result;
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools.transForm
+		arguments: form_id [integer] ,config [object] ,multiple [bool]
+		
+		transforms the all fields of the given form into fileQueue instances
+  */
+	
+	xajax.ext.SWFupload.tools.transForm = function(form_id,config,multiple) 
+	{
+		var oForm = xajax.$(form_id);		
+		if (oForm)
+			if (oForm.childNodes) {
+				var fields = xajax.ext.SWFupload.tools._parseFields(oForm.childNodes,oForm,config,multiple);		
+				xajax.ext.SWFupload.forms[form_id] = fields;
+			}
+		return;
+	}
+	
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+
+	/*
+		function: xajax.ext.SWFupload.tools.transField
+		arguments: field_id [integer] ,config [object] ,multiple [bool]
+		
+		transforms the given field into a fileQueue instance
+  */
+	
+	xajax.ext.SWFupload.tools.transField = function(field_id,config,multiple) 
+	{
+		try {
+			var oField = xajax.$(field_id);		
+			if ('undefined' != typeof oField) return xajax.ext.SWFupload.fields[field_id] = xajax.ext.SWFupload.addQueue(oField,oField.parentNode,config,multiple);			
+
+		}catch(ex) {}		
+		return;
+	}
+
+
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools.destroyForm
+		arguments: form_id [integer]
+		
+		destroys the given form
+  */
+
+	xajax.ext.SWFupload.tools.destroyForm = function(form_id) 
+	{
+		if ("undefined" == typeof xajax.ext.SWFupload.forms[form_id]) return;
+		for (a in xajax.ext.SWFupload.forms[form_id]) 
+		{
+			var key = xajax.ext.SWFupload.forms[form_id][a];
+			xajax.ext.SWFupload.queues[key].destroy();
+			delete xajax.ext.SWFupload.queues[key];
+		}
+		delete xajax.ext.SWFupload.forms[form_id];
+		return;
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools.destroyField
+		arguments: field_id [integer]
+		
+		destroys the given field
+  */
+  
+	xajax.ext.SWFupload.tools.destroyField = function(field_id) 
+	{
+			if ("undefined" == typeof xajax.ext.SWFupload.fields[field_id]) return;
+			var key = xajax.ext.SWFupload.fields[field_id];
+			xajax.ext.SWFupload.queues[key].destroy();
+			delete(xajax.ext.SWFupload.queues[key]);
+			delete xajax.ext.SWFupload.fields[field_id];
+
+		return true;
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+
+	/*
+		function: xajax.ext.SWFupload.tools.FadeOut
+		arguments: elm [object], opacity [integer]
+		
+		fades a div	
+  */
+
+	xajax.ext.SWFupload.tools.FadeOut = function(elm,opacity) 
+	{
+		var reduceOpacityBy = 15;
+		var rate = 40;	
+		if (opacity > 0) 
+		{
+			opacity -= reduceOpacityBy;
+			if (opacity < 0) 
+			{
+				opacity = 0;
+			}
+	
+			if (elm.filters) 
+			{
+				try 
+				{
+					elm.filters.item("DXImageTransform.Microsoft.Alpha").opacity = opacity;
+				} catch (e) {
+					// If it is not set initially, the browser will throw an error.  This will set it if it is not set yet.
+					elm.style.filter = "progid:DXImageTransform.Microsoft.Alpha(opacity=" + opacity + ")";
+				}
+			} else {
+				elm.style.opacity = opacity / 100;
+			}
+		}
+	
+		if ( opacity > 0) 
+		{
+			var oSelf = this;
+			setTimeout(function () 
+			{
+				xajax.ext.SWFupload.tools.FadeOut(elm,opacity);
+			}, rate);
+		} else {
+			var parent = elm.parentNode;
+			parent.removeChild(elm);
+		}
+	}
+
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+
+	/*
+		function: xajax.ext.SWFupload.tools.formatBytes
+		arguments: bytes [integer]
+		
+		returns string with formatted size (kB / MB)	
+  */
+
+	xajax.ext.SWFupload.tools.formatBytes = function(bytes) 
+	{
+
+		var ret = {};
+		if (bytes / 1204  < 1024) 
+		{
+		    return (Math.round(bytes / 1024 * 100)/100).toString()+ " kB";
+		} else {
+		    return (Math.round(bytes / 1024 / 1024 * 100)/100).toString()+ " MB";
+		}
+		return ret;		
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	
+	/*
+		function: xajax.ext.SWFupload.tools.mergeObj
+		arguments: n objects
+		
+		Merges all objects and returns a single object.
+		Newrt keys override existing keys.
+	
+  */
+  
+	xajax.ext.SWFupload.tools.mergeObj = function() 
+	{
+		if ('object' != typeof arguments) return;
+		
+		var res = {};
+		var len = arguments.length;
+		for (var i=0;i<len;i++) 
+		{
+			var obj = arguments[i];
+			for (a in obj) 
+			{
+				res[a] = obj[a];
+			}
+		}
+		return res;
+	}
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.ext.SWFupload.tools.getId
+		arguments: 
+		
+		returns a 'unique' (rand) id	
+  */
+  
+	xajax.ext.SWFupload.tools.getId = function() 
+	{
+		var pid_str = "";
+		for (i=0;i<=3;i++) {
+			var pid = 0;
+			pid = Math.random();
+			while( Math.ceil(pid).toString().length<8) 
+			{
+				pid *= 10;
+			}
+			pid = Math.ceil(pid).toString();		
+			pid_str = pid_str+pid.toString();
+		}
+		return pid_str;
+	}
+	
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.command.handler.register('SWFup_dfi')
+		arguments: object
+		
+		xajax response command for ext.SWFupload.tools.destroyField
+  */	
+	xajax.command.handler.register('SWFup_dfi', function(args) 
+	{
+		args.cmdFullName = 'ext.SWFupload.tools.destroyField';
+		xajax.ext.SWFupload.tools.destroyField(args.id);
+		return true;
+	});
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.command.handler.register('SWFup_dfo')
+		arguments: object
+		
+		xajax response command for ext.SWFupload.tools.destroyForm
+  */	
+
+	xajax.command.handler.register('SWFup_dfo', function(args) 
+	{
+		args.cmdFullName = 'ext.SWFupload.tools.destroyForm';
+		xajax.ext.SWFupload.tools.destroyForm(args.id);
+		return true;
+	});
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.command.handler.register('SWFup_tfi'I
+		arguments: object
+		
+		xajax response command for ext.SWFupload.tools.transField
+  */	
+	
+	xajax.command.handler.register('SWFup_tfi', function(args) 
+	{
+			args.cmdFullName = 'ext.SWFupload.tools.transField';
+			
+//			if ("string" == typeof args.data.config.upload_complete_handler) {
+//				try {
+//					eval("var foo = "+args.data.config.upload_complete_handler);
+//					args.data.config.upload_complete_handler = foo;
+//				} catch(ex) {delete(args.data.config.upload_complete_handler);}
+//			}
+	
+			if ("string" == typeof args.data.config.upload_success_handler) {
+				try {
+					eval("var foo = "+args.data.config.upload_success_handler);
+					args.data.config.upload_success_handler = foo;
+				} catch(ex) {delete(args.data.config.upload_success_handler);}
+			}
+	
+			xajax.ext.SWFupload.tools.transField(args.id, args.data.config,args.data.multi);
+		return true;
+	});
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+	/*
+		function: xajax.command.handler.register('SWFup_tfo']
+		arguments: object
+		
+		xajax response command for ext.SWFupload.tools.transForm
+  */		
+	xajax.command.handler.register('SWFup_tfo',function(args) 
+	{
+try {
+		args.cmdFullName = 'ext.SWFupload.tools.transForm';
+//		if ("string" == typeof args.data.config.upload_complete_handler) 
+//		{
+//			try {
+//				eval("var foo = "+args.data.config.upload_complete_handler);
+//				args.data.config.upload_complete_handler = foo;
+//			} catch(ex) {delete(args.data.config.upload_complete_handler);}
+//		}
+
+		if ("string" == typeof args.data.config.upload_success_handler) 
+		{
+			try 
+			{
+				eval("var foo = "+args.data.config.upload_success_handler);
+				args.data.config.upload_success_handler = foo;
+			} catch(ex) 
+			{
+				delete(args.data.config.upload_success_handler);
+			}
+		}
+		xajax.ext.SWFupload.tools.transForm(args.id, args.data.config,args.data.multi);
+
+	} catch(ex) 
+	{
+		
+	}
+
+
+		return true;
+
+
+	});
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+
+
+	xajax.ext.SWFupload.bak = {};
+	xajax.ext.SWFupload.bak.prepareRequest = xajax.prepareRequest;
+	xajax.ext.SWFupload.bak.submitRequest = xajax.submitRequest;
+	xajax.ext.SWFupload.bak.responseProcessor = xajax.responseProcessor;
+	xajax.ext.SWFupload.bak.processParameters = xajax.processParameters;
+
+	xajax.prepareRequest = xajax.ext.SWFupload.request.prepareRequest;
+	xajax.submitRequest = xajax.ext.SWFupload.request.submitRequest;
+	xajax.processParameters = xajax.ext.SWFupload.request.processParameters;
+
+
+	/* ------------------------------------------------------------------------------------------------------------------------ */
+
+
+// -------------------------------------------------------------------------------------------------------------------------------------
+/*
+
+	Function: DOMParser
+	
+	Prototype DomParser for IE/Opera
+
+*/
+if (typeof DOMParser == "undefined") {
+   DOMParser = function () {}
+
+   DOMParser.prototype.parseFromString = function (str, contentType) {
+      if (typeof ActiveXObject != "undefined") {
+         	var d = new ActiveXObject("Microsoft.XMLDOM");
+         	d.loadXML(str);
+         return d;
+      } else if (typeof XMLHttpRequest != "undefined") {
+         var req = new XMLHttpRequest;
+         req.open("GET", "data:" + (contentType || "application/xml") +
+                         ";charset=utf-8," + encodeURIComponent(str), false);
+         if (req.overrideMimeType) {
+            req.overrideMimeType(contentType);
+         }
+         req.send(null);
+         return req.responseXML;
+      }
+   }
+}