973 lines
28 KiB
JavaScript
973 lines
28 KiB
JavaScript
|
|
//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=" ";
|
|
|
|
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ählte Datei ist zu groß!";
|
|
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;
|
|
}
|
|
}
|
|
}
|