diff options
| -rw-r--r-- | core/SimpleUploader.swf | bin | 301349 -> 0 bytes | |||
| -rw-r--r-- | core/controllers/simple_uploader.php | 18 | ||||
| -rw-r--r-- | core/views/admin_maintenance_task.html.php | 6 | ||||
| -rw-r--r-- | core/views/simple_uploader.html.php | 240 | ||||
| -rw-r--r-- | lib/swfupload/swfupload.js | 927 | ||||
| -rw-r--r-- | lib/swfupload/swfupload.queue.js | 77 | ||||
| -rw-r--r-- | lib/swfupload/swfupload.swf | bin | 0 -> 11931 bytes | |||
| -rw-r--r-- | modules/server_add/js/server_add.js | 8 | ||||
| -rw-r--r-- | modules/server_add/views/server_add_tree_dialog.html.php | 2 | ||||
| -rw-r--r-- | themes/default/css/screen.css | 88 |
10 files changed, 1307 insertions, 59 deletions
diff --git a/core/SimpleUploader.swf b/core/SimpleUploader.swf Binary files differdeleted file mode 100644 index 152917b1..00000000 --- a/core/SimpleUploader.swf +++ /dev/null diff --git a/core/controllers/simple_uploader.php b/core/controllers/simple_uploader.php index 67b86e7a..c369e9f2 100644 --- a/core/controllers/simple_uploader.php +++ b/core/controllers/simple_uploader.php @@ -24,19 +24,6 @@ class Simple_Uploader_Controller extends Controller { $v = new View("simple_uploader.html"); $v->item = $item; - $v->flash_vars = - "uploadUrl=" . urlencode( - url::site("simple_uploader/add_photo/$item->id" . - "?csrf=" . access::csrf_token() . - "&g3sid=" . Session::instance()->id() . - "&user_agent=" . urlencode(Input::instance()->server("HTTP_USER_AGENT")))) . - "&title=" . urlencode(t("Add photos")) . - "&addLabel=" . urlencode(t("Choose photos to add...")) . - "&pendingText=" . urlencode(t("Pending")) . - "&completeText=" . urlencode(t("Complete")) . - "&fileHeader=" . urlencode(t("File")) . - "&statusHeader=" . urlencode(t("Status")) . - "&sizeHeader=" . urlencode(t("Size")); print $v; } @@ -50,7 +37,7 @@ class Simple_Uploader_Controller extends Controller { access::verify_csrf(); $file_validation = new Validation($_FILES); - $file_validation->add_rules("file", "upload::valid", "upload::type[gif,jpg,png,flv,mp4]"); + $file_validation->add_rules("Filedata", "upload::valid", "upload::type[gif,jpg,png,flv,mp4]"); if ($file_validation->validate()) { // SimpleUploader.swf does not yet call /start directly, so simulate it here for now. @@ -58,7 +45,7 @@ class Simple_Uploader_Controller extends Controller { batch::start(); } - $temp_filename = upload::save("file"); + $temp_filename = upload::save("Filedata"); try { $title = substr(basename($temp_filename), 10); // Skip unique identifier Kohana adds $path_info = pathinfo($temp_filename); @@ -77,6 +64,7 @@ class Simple_Uploader_Controller extends Controller { } unlink($temp_filename); } + print "File Received"; } public function finish() { diff --git a/core/views/admin_maintenance_task.html.php b/core/views/admin_maintenance_task.html.php index 1b64ffb3..1ee02311 100644 --- a/core/views/admin_maintenance_task.html.php +++ b/core/views/admin_maintenance_task.html.php @@ -5,7 +5,7 @@ url: "<?= url::site("admin/maintenance/run/$task->id?csrf=$csrf") ?>", dataType: "json", success: function(data) { - $("#gProgressBar").progressbar("value", data.task.percent_complete); + $(".gProgressBar").progressbar("value", data.task.percent_complete); $("#gStatus").html("" + data.task.status); if (data.task.done) { $("#gPauseButton").hide(); @@ -16,14 +16,14 @@ } }); } - $("#gProgressBar").progressbar({value: 0}); + $(".gProgressBar").progressbar({value: 0}); update(); dismiss = function() { window.location.reload(); } </script> <div id="gProgress"> - <div id="gProgressBar"></div> + <div class="gProgressBar"></div> <div id="gStatus"></div> <div> <button id="gPauseButton" class="ui-state-default ui-corner-all" onclick="dismiss()"><?= t("Pause") ?></button> diff --git a/core/views/simple_uploader.html.php b/core/views/simple_uploader.html.php index 0d1d4ee2..064f88fc 100644 --- a/core/views/simple_uploader.html.php +++ b/core/views/simple_uploader.html.php @@ -1,34 +1,216 @@ <?php defined("SYSPATH") or die("No direct script access.") ?> -<!-- hack to get this string into the dialog's titlebar --> -<form id="gAddPhotos" action="<?= url::site("simple_uploader/finish") ?>"> +<script type="text/javascript" src="<?= url::file("lib/swfupload/swfupload.js") ?>"></script> +<script type="text/javascript" src="<?= url::file("lib/swfupload/swfupload.queue.js") ?>"></script> + +<!-- hack to set the title for the dialog --> +<form id="gAddPhotosForm" action="<?= url::site("simple_uploader/finish") ?>"> <fieldset> <legend> <?= t("Add photos to %album_title", array("album_title" => $item->title)) ?> </legend> </fieldset> - - <object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" - id="SimpleUploader" - width="470px" - height="400px" - codebase="http://fpdownload.macromedia.com/get/flashplayer/current/swflash.cab"> - <param name="movie" value="<?= url::file("core/SimpleUploader.swf") ?>" /> - <param name="flashVars" value="<?= $flash_vars ?>" /> - <param name="quality" value="high" /> - <param name="bgcolor" value="#ffffff" /> - <param name="allowScriptAccess" value="sameDomain" /> - <embed src="<?= url::file("core/SimpleUploader.swf") ?>" - quality="high" - bgcolor="#ffffff" - flashVars="<?= $flash_vars ?>" - width="470" height="400" name="<?= url::file("core/SimpleUploader.swf") ?>" - align="middle" - play="true" - loop="false" - quality="high" - allowScriptAccess="sameDomain" - type="application/x-shockwave-flash" - pluginspage="http://www.adobe.com/go/getflashplayer"> - </embed> - </object> - - <input type="submit" class="ui-state-default ui-corner-all" value="<?= t("Finish") ?>"/> </form> + +<div id="gAddPhotos"> + <p> + <?= t("Photos will be uploaded to album: ") ?> + </p> + <ul> + <? foreach ($item->parents() as $parent): ?> + <li> <?= $parent->title ?> </li> + <? endforeach ?> + <li class="active"> <?= $item->title ?> </li> + </ul> + + <p><?= t("Upload Queue") ?></p> + <div id="gAddPhotosCanvas"> + <div id="gAddPhotosQueue"></div> + <div id="gEditPhotosQueue"></div> + </div> + <span id="gChooseFilesButtonPlaceholder"></span> + <button id="gUploadCancel" type="button" + onclick="swfu.cancelQueue();" + disabled="disabled"> + <?= t("Cancel all") ?> + </button> + + <!-- Proxy the done request back to our form, since its been ajaxified --> + <button onclick="$('#gAddPhotosForm').submit()"> + <?= t("Done") ?> + </button> +</div> + +<script type="text/javascript"> + var swfu = new SWFUpload({ + flash_url : "<?= url::file("lib/swfupload/swfupload.swf") ?>", + upload_url: "<?= url::site("simple_uploader/add_photo/$item->id") ?>", + post_params: { + "g3sid": "<?= Session::instance()->id() ?>", + "user_agent": "<?= Input::instance()->server("HTTP_USER_AGENT") ?>", + "csrf": "<?= access::csrf_token() ?>" + }, + file_size_limit : "100 MB", + file_types : "*.gif;*.jpg;*.png;*.flv;*.mp4", + file_types_description : "<?= t("Photos and Movies") ?>", + file_upload_limit : 100, + file_queue_limit : 0, + custom_settings : { }, + debug: false, + + // Button settings + // button_image_url: "...", + button_width: "130", + button_height: "29", + button_placeholder_id: "gChooseFilesButtonPlaceholder", + button_text: '<span class="swfUploadFont">Select photos...</span>', + button_text_style: ".swfUploadFont { font-size: 18; }", + button_text_left_padding: 12, + button_text_top_padding: 3, + + // The event handler functions are defined in handlers.js + file_queued_handler : file_queued, + file_queue_error_handler : file_queue_error, + file_dialog_complete_handler : file_dialog_complete, + upload_start_handler : upload_start, + upload_progress_handler : upload_progress, + upload_error_handler : upload_error, + upload_success_handler : upload_success, + upload_complete_handler : upload_complete, + queue_complete_handler : queue_complete + }); + + // @todo add support for cancelling individual uploads + function File_Progress(file) { + this.box = $("#" + file.id); + if (!this.box.length) { + $("#gAddPhotosQueue").append( + "<div class=\"box\" id=\"" + file.id + "\">" + + "<div class=\"title\"></div>" + + "<div class=\"status\"></div>" + + "<div class=\"progressbar\"></div></div>"); + this.box = $("#" + file.id); + } + this.title = this.box.find(".title"); + this.status = this.box.find(".status"); + this.progress_bar = this.box.find(".progressbar"); + this.progress_bar.progressbar(); + this.progress_bar.css("visibility", "hidden"); + } + + File_Progress.prototype.set_status = function(status_class, msg) { + this.box.removeClass("pending error uploading complete").addClass(status_class); + this.status.html(msg); + } + + function file_queued(file) { + var fp = new File_Progress(file); + fp.title.html(file.name); + fp.set_status("pending", "<?= t("Pending...") ?>"); + // @todo add cancel button to call this.cancelUpload(file.id) + } + + function file_queue_error(file, error_code, message) { + if (error_code === SWFUpload.QUEUE_ERROR.QUEUE_LIMIT_EXCEEDED) { + alert("<?= t("You have attempted to queue too many files.") ?>"); + return; + } + + var fp = new File_Progress(file); + switch (error_code) { + case SWFUpload.QUEUE_ERROR.FILE_EXCEEDS_SIZE_LIMIT: + fp.set_status("error", "<?= t("File is too big.") ?>"); + break; + case SWFUpload.QUEUE_ERROR.ZERO_BYTE_FILE: + fp.set_status("error", "<?= t("Cannot upload empty files.") ?>"); + break; + case SWFUpload.QUEUE_ERROR.INVALID_FILETYPE: + fp.set_status("error", "<?= t("Invalid file type.") ?>"); + break; + default: + if (file !== null) { + fp.set_status("error", "<?= t("Unknown error") ?>"); + } + break; + } + } + + function file_dialog_complete(num_files_selected, num_files_queued) { + if (num_files_selected > 0) { + $("#gUploadCancel").enable(true); + } + + // Auto start the upload + this.startUpload(); + } + + function upload_start(file) { + // Do all file validation on the server side. Update the UI here because in Linux + // no uploadProgress events are called (limitation in the Linux Flash VM). + var fp = new File_Progress(file); + fp.title.html(file.name); + fp.set_status("uploading", "<?= t("Uploading...") ?>"); + return true; + // @todo add cancel button to call this.cancelUpload(file.id) + } + + function upload_progress(file, bytes_loaded, bytes_total) { + var percent = Math.ceil((bytes_loaded / bytes_total) * 100); + var fp = new File_Progress(file); + fp.set_status("uploading", "<?= t("Uploading...") ?>"); + fp.progress_bar.css("visibility", "visible"); + fp.progress_bar.progressbar("value", percent); + } + + function upload_success(file, serverData) { + var fp = new File_Progress(file); + fp.progress_bar.progressbar("value", 100); + fp.set_status("complete", "<?= t("Complete.") ?>"); + } + + function upload_error(file, error_code, message) { + var fp = new File_Progress(file); + switch (error_code) { + case SWFUpload.UPLOAD_ERROR.HTTP_ERROR: + fp.set_status("error", "<?= t("Upload error: ") ?>" + message); + break; + case SWFUpload.UPLOAD_ERROR.UPLOAD_FAILED: + fp.set_status("error", "<?= t("Upload failed") ?>"); + break; + case SWFUpload.UPLOAD_ERROR.IO_ERROR: + fp.set_status("error", "<?= t("Server error") ?>"); + break; + case SWFUpload.UPLOAD_ERROR.SECURITY_ERROR: + fp.set_status("error", "<?= t("Security error") ?>"); + break; + case SWFUpload.UPLOAD_ERROR.UPLOAD_LIMIT_EXCEEDED: + fp.set_status("error", "<?= t("Upload limit exceeded") ?>"); + break; + case SWFUpload.UPLOAD_ERROR.FILE_VALIDATION_FAILED: + fp.set_status("error", "<?= t("Failed validation. File skipped") ?>"); + break; + case SWFUpload.UPLOAD_ERROR.FILE_CANCELLED: + // If there aren't any files left (they were all cancelled) disable the cancel button + if (this.getStats().files_queued === 0) { + $("#gUploadCancel").enable(false); + } + fp.set_status("error", "<?= t("Cancelled") ?>"); + break; + case SWFUpload.UPLOAD_ERROR.UPLOAD_STOPPED: + fp.set_status("error", "<?= t("Stopped") ?>"); + break; + default: + fp.set_status("error", "<?= t("Unknown error: ") ?>" + error_code); + break; + } + } + + function upload_complete(file) { + if (this.getStats().files_queued === 0) { + $("#gUploadCancel").enable(false); + } + } + + // This event comes from the Queue Plugin + function queue_complete(num_files_uploaded) { + var status_msg = "<?= t("Uploaded: __COUNT__") ?>"; + $("#gUploadStatus").html(status_msg.replace("__COUNT__", num_files_uploaded)); + } +</script> diff --git a/lib/swfupload/swfupload.js b/lib/swfupload/swfupload.js new file mode 100644 index 00000000..849cf28e --- /dev/null +++ b/lib/swfupload/swfupload.js @@ -0,0 +1,927 @@ +/** + * SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com + * + * mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/, http://www.vinterwebb.se/ + * + * SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilzén and Mammon Media and is released under the MIT License: + * http://www.opensource.org/licenses/mit-license.php + * + * SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT License: + * http://www.opensource.org/licenses/mit-license.php + * + */ + + +/* ******************* */ +/* Constructor & Init */ +/* ******************* */ +var SWFUpload; + +if (SWFUpload == undefined) { + SWFUpload = function (settings) { + this.initSWFUpload(settings); + }; +} + +SWFUpload.prototype.initSWFUpload = function (settings) { + try { + this.customSettings = {}; // A container where developers can place their own settings associated with this instance. + this.settings = settings; + this.eventQueue = []; + this.movieName = "SWFUpload_" + SWFUpload.movieCount++; + this.movieElement = null; + + // Setup global control tracking + SWFUpload.instances[this.movieName] = this; + + // Load the settings. Load the Flash movie. + this.initSettings(); + this.loadFlash(); + this.displayDebugInfo(); + } catch (ex) { + delete SWFUpload.instances[this.movieName]; + throw ex; + } +}; + +/* *************** */ +/* Static Members */ +/* *************** */ +SWFUpload.instances = {}; +SWFUpload.movieCount = 0; +SWFUpload.version = "2.2.0 Beta 2"; +SWFUpload.QUEUE_ERROR = { + QUEUE_LIMIT_EXCEEDED : -100, + FILE_EXCEEDS_SIZE_LIMIT : -110, + ZERO_BYTE_FILE : -120, + INVALID_FILETYPE : -130 +}; +SWFUpload.UPLOAD_ERROR = { + HTTP_ERROR : -200, + MISSING_UPLOAD_URL : -210, + IO_ERROR : -220, + SECURITY_ERROR : -230, + UPLOAD_LIMIT_EXCEEDED : -240, + UPLOAD_FAILED : -250, + SPECIFIED_FILE_ID_NOT_FOUND : -260, + FILE_VALIDATION_FAILED : -270, + FILE_CANCELLED : -280, + UPLOAD_STOPPED : -290 +}; +SWFUpload.FILE_STATUS = { + QUEUED : -1, + IN_PROGRESS : -2, + ERROR : -3, + COMPLETE : -4, + CANCELLED : -5 +}; +SWFUpload.BUTTON_ACTION = { + SELECT_FILE : -100, + SELECT_FILES : -110, + START_UPLOAD : -120 +}; +SWFUpload.CURSOR = { + ARROW : -1, + HAND : -2 +}; +SWFUpload.WINDOW_MODE = { + WINDOW : "window", + TRANSPARENT : "transparent", + OPAQUE : "opaque" +}; + +/* ******************** */ +/* Instance Members */ +/* ******************** */ + +// Private: initSettings ensures that all the +// settings are set, getting a default value if one was not assigned. +SWFUpload.prototype.initSettings = function () { + this.ensureDefault = function (settingName, defaultValue) { + this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName]; + }; + + // Upload backend settings + this.ensureDefault("upload_url", ""); + this.ensureDefault("file_post_name", "Filedata"); + this.ensureDefault("post_params", {}); + this.ensureDefault("use_query_string", false); + this.ensureDefault("requeue_on_error", false); + this.ensureDefault("http_success", []); + + // File Settings + this.ensureDefault("file_types", "*.*"); + this.ensureDefault("file_types_description", "All Files"); + this.ensureDefault("file_size_limit", 0); // Default zero means "unlimited" + this.ensureDefault("file_upload_limit", 0); + this.ensureDefault("file_queue_limit", 0); + + // Flash Settings + this.ensureDefault("flash_url", "swfupload.swf"); + this.ensureDefault("prevent_swf_caching", true); + + // Button Settings + this.ensureDefault("button_image_url", ""); + this.ensureDefault("button_width", 1); + this.ensureDefault("button_height", 1); + this.ensureDefault("button_text", ""); + this.ensureDefault("button_text_style", "color: #000000; font-size: 16pt;"); + this.ensureDefault("button_text_top_padding", 0); + this.ensureDefault("button_text_left_padding", 0); + this.ensureDefault("button_action", SWFUpload.BUTTON_ACTION.SELECT_FILES); + this.ensureDefault("button_disabled", false); + this.ensureDefault("button_placeholder_id", null); + this.ensureDefault("button_cursor", SWFUpload.CURSOR.ARROW); + this.ensureDefault("button_window_mode", SWFUpload.WINDOW_MODE.WINDOW); + + // Debug Settings + this.ensureDefault("debug", false); + this.settings.debug_enabled = this.settings.debug; // Here to maintain v2 API + + // Event Handlers + this.settings.return_upload_start_handler = this.returnUploadStart; + this.ensureDefault("swfupload_loaded_handler", null); + this.ensureDefault("file_dialog_start_handler", null); + this.ensureDefault("file_queued_handler", null); + this.ensureDefault("file_queue_error_handler", null); + this.ensureDefault("file_dialog_complete_handler", null); + + this.ensureDefault("upload_start_handler", null); + this.ensureDefault("upload_progress_handler", null); + this.ensureDefault("upload_error_handler", null); + this.ensureDefault("upload_success_handler", null); + this.ensureDefault("upload_complete_handler", null); + + this.ensureDefault("debug_handler", this.debugMessage); + + this.ensureDefault("custom_settings", {}); + + // Other settings + this.customSettings = this.settings.custom_settings; + + // Update the flash url if needed + if (this.settings.prevent_swf_caching) { + this.settings.flash_url = this.settings.flash_url + "?swfuploadrnd=" + Math.floor(Math.random() * 999999999); + } + + delete this.ensureDefault; +}; + +SWFUpload.prototype.loadFlash = function () { + if (this.settings.button_placeholder_id !== "") { + this.replaceWithFlash(); + } else { + this.appendFlash(); + } +}; + +// Private: appendFlash gets the HTML tag for the Flash +// It then appends the flash to the body +SWFUpload.prototype.appendFlash = function () { + var targetElement, container; + + // Make sure an element with the ID we are going to use doesn't already exist + if (document.getElementById(this.movieName) !== null) { + throw "ID " + this.movieName + " is already in use. The Flash Object could not be added"; + } + + // Get the body tag where we will be adding the flash movie + targetElement = document.getElementsByTagName("body")[0]; + + if (targetElement == undefined) { + throw "Could not find the 'body' element."; + } + + // Append the container and load the flash + container = document.createElement("div"); + container.style.width = "1px"; + container.style.height = "1px"; + container.style.overflow = "hidden"; + + targetElement.appendChild(container); + container.innerHTML = this.getFlashHTML(); // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers) +}; + +// Private: replaceWithFlash replaces the button_placeholder element with the flash movie. +SWFUpload.prototype.replaceWithFlash = function () { + var targetElement, tempParent; + + // Make sure an element with the ID we are going to use doesn't already exist + if (document.getElementById(this.movieName) !== null) { + throw "ID " + this.movieName + " is already in use. The Flash Object could not be added"; + } + + // Get the element where we will be placing the flash movie + targetElement = document.getElementById(this.settings.button_placeholder_id); + + if (targetElement == undefined) { + throw "Could not find the placeholder element."; + } + + // Append the container and load the flash + tempParent = document.createElement("div"); + tempParent.innerHTML = this.getFlashHTML(); // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers) + targetElement.parentNode.replaceChild(tempParent.firstChild, targetElement); + +}; + +// Private: getFlashHTML generates the object tag needed to embed the flash in to the document +SWFUpload.prototype.getFlashHTML = function () { + // Flash Satay object syntax: http://www.alistapart.com/articles/flashsatay + return ['<object id="', this.movieName, '" type="application/x-shockwave-flash" data="', this.settings.flash_url, '" width="', this.settings.button_width, '" height="', this.settings.button_height, '" class="swfupload">', + '<param name="wmode" value="', this.settings.button_window_mode , '" />', + '<param name="movie" value="', this.settings.flash_url, '" />', + '<param name="quality" value="high" />', + '<param name="menu" value="false" />', + '<param name="allowScriptAccess" value="always" />', + '<param name="flashvars" value="' + this.getFlashVars() + '" />', + '</object>'].join(""); +}; + +// Private: getFlashVars builds the parameter string that will be passed +// to flash in the flashvars param. +SWFUpload.prototype.getFlashVars = function () { + // Build a string from the post param object + var paramString = this.buildParamString(); + var httpSuccessString = this.settings.http_success.join(","); + + // Build the parameter string + return ["movieName=", encodeURIComponent(this.movieName), + "&uploadURL=", encodeURIComponent(this.settings.upload_url), + "&useQueryString=", encodeURIComponent(this.settings.use_query_string), + "&requeueOnError=", encodeURIComponent(this.settings.requeue_on_error), + "&httpSuccess=", encodeURIComponent(httpSuccessString), + "&params=", encodeURIComponent(paramString), + "&filePostName=", encodeURIComponent(this.settings.file_post_name), + "&fileTypes=", encodeURIComponent(this.settings.file_types), + "&fileTypesDescription=", encodeURIComponent(this.settings.file_types_description), + "&fileSizeLimit=", encodeURIComponent(this.settings.file_size_limit), + "&fileUploadLimit=", encodeURIComponent(this.settings.file_upload_limit), + "&fileQueueLimit=", encodeURIComponent(this.settings.file_queue_limit), + "&debugEnabled=", encodeURIComponent(this.settings.debug_enabled), + "&buttonImageURL=", encodeURIComponent(this.settings.button_image_url), + "&buttonWidth=", encodeURIComponent(this.settings.button_width), + "&buttonHeight=", encodeURIComponent(this.settings.button_height), + "&buttonText=", encodeURIComponent(this.settings.button_text), + "&buttonTextTopPadding=", encodeURIComponent(this.settings.button_text_top_padding), + "&buttonTextLeftPadding=", encodeURIComponent(this.settings.button_text_left_padding), + "&buttonTextStyle=", encodeURIComponent(this.settings.button_text_style), + "&buttonAction=", encodeURIComponent(this.settings.button_action), + "&buttonDisabled=", encodeURIComponent(this.settings.button_disabled), + "&buttonCursor=", encodeURIComponent(this.settings.button_cursor) + ].join(""); +}; + +// Public: getMovieElement retrieves the DOM reference to the Flash element added by SWFUpload +// The element is cached after the first lookup +SWFUpload.prototype.getMovieElement = function () { + if (this.movieElement == undefined) { + this.movieElement = document.getElementById(this.movieName); + } + + if (this.movieElement === null) { + throw "Could not find Flash element"; + } + + return this.movieElement; +}; + +// Private: buildParamString takes the name/value pairs in the post_params setting object +// and joins them up in to a string formatted "name=value&name=value" +SWFUpload.prototype.buildParamString = function () { + var postParams = this.settings.post_params; + var paramStringPairs = []; + + if (typeof(postParams) === "object") { + for (var name in postParams) { + if (postParams.hasOwnProperty(name)) { + paramStringPairs.push(encodeURIComponent(name.toString()) + "=" + encodeURIComponent(postParams[name].toString())); + } + } + } + + return paramStringPairs.join("&"); +}; + +// Public: Used to remove a SWFUpload instance from the page. This method strives to remove +// all references to the SWF, and other objects so memory is properly freed. +// Returns true if everything was destroyed. Returns a false if a failure occurs leaving SWFUpload in an inconsistant state. +SWFUpload.prototype.destroy = function () { + try { + // Make sure Flash is done before we try to remove it + this.stopUpload(); + + // Remove the SWFUpload DOM nodes + var movieElement = null; + try { + movieElement = this.getMovieElement(); + } catch (ex) { + } + + if (movieElement != undefined && movieElement.parentNode != undefined && typeof movieElement.parentNode.removeChild === "function") { + var container = movieElement.parentNode; + if (container != undefined) { + container.removeChild(movieElement); + if (container.parentNode != undefined && typeof container.parentNode.removeChild === "function") { + container.parentNode.removeChild(container); + } + } + } + + // Destroy references + SWFUpload.instances[this.movieName] = null; + delete SWFUpload.instances[this.movieName]; + + delete this.movieElement; + delete this.settings; + delete this.customSettings; + delete this.eventQueue; + delete this.movieName; + + delete window[this.movieName]; + + return true; + } catch (ex1) { + return false; + } +}; + +// Public: displayDebugInfo prints out settings and configuration +// information about this SWFUpload instance. +// This function (and any references to it) can be deleted when placing +// SWFUpload in production. +SWFUpload.prototype.displayDebugInfo = function () { + this.debug( + [ + "---SWFUpload Instance Info---\n", + "Version: ", SWFUpload.version, "\n", + "Movie Name: ", this.movieName, "\n", + "Settings:\n", + "\t", "upload_url: ", this.settings.upload_url, "\n", + "\t", "flash_url: ", this.settings.flash_url, "\n", + "\t", "use_query_string: ", this.settings.use_query_string.toString(), "\n", + "\t", "requeue_on_error: ", this.settings.requeue_on_error.toString(), "\n", + "\t", "http_success: ", this.settings.http_success.join(", "), "\n", + "\t", "file_post_name: ", this.settings.file_post_name, "\n", + "\t", "post_params: ", this.settings.post_params.toString(), "\n", + "\t", "file_types: ", this.settings.file_types, "\n", + "\t", "file_types_description: ", this.settings.file_types_description, "\n", + "\t", "file_size_limit: ", this.settings.file_size_limit, "\n", + "\t", "file_upload_limit: ", this.settings.file_upload_limit, "\n", + "\t", "file_queue_limit: ", this.settings.file_queue_limit, "\n", + "\t", "debug: ", this.settings.debug.toString(), "\n", + + "\t", "prevent_swf_caching: ", this.settings.prevent_swf_caching.toString(), "\n", + + "\t", "button_placeholder_id: ", this.settings.button_placeholder_id.toString(), "\n", + "\t", "button_image_url: ", this.settings.button_image_url.toString(), "\n", + "\t", "button_width: ", this.settings.button_width.toString(), "\n", + "\t", "button_height: ", this.settings.button_height.toString(), "\n", + "\t", "button_text: ", this.settings.button_text.toString(), "\n", + "\t", "button_text_style: ", this.settings.button_text_style.toString(), "\n", + "\t", "button_text_top_padding: ", this.settings.button_text_top_padding.toString(), "\n", + "\t", "button_text_left_padding: ", this.settings.button_text_left_padding.toString(), "\n", + "\t", "button_action: ", this.settings.button_action.toString(), "\n", + "\t", "button_disabled: ", this.settings.button_disabled.toString(), "\n", + + "\t", "custom_settings: ", this.settings.custom_settings.toString(), "\n", + "Event Handlers:\n", + "\t", "swfupload_loaded_handler assigned: ", (typeof this.settings.swfupload_loaded_handler === "function").toString(), "\n", + "\t", "file_dialog_start_handler assigned: ", (typeof this.settings.file_dialog_start_handler === "function").toString(), "\n", + "\t", "file_queued_handler assigned: ", (typeof this.settings.file_queued_handler === "function").toString(), "\n", + "\t", "file_queue_error_handler assigned: ", (typeof this.settings.file_queue_error_handler === "function").toString(), "\n", + "\t", "upload_start_handler assigned: ", (typeof this.settings.upload_start_handler === "function").toString(), "\n", + "\t", "upload_progress_handler assigned: ", (typeof this.settings.upload_progress_handler === "function").toString(), "\n", + "\t", "upload_error_handler assigned: ", (typeof this.settings.upload_error_handler === "function").toString(), "\n", + "\t", "upload_success_handler assigned: ", (typeof this.settings.upload_success_handler === "function").toString(), "\n", + "\t", "upload_complete_handler assigned: ", (typeof this.settings.upload_complete_handler === "function").toString(), "\n", + "\t", "debug_handler assigned: ", (typeof this.settings.debug_handler === "function").toString(), "\n" + ].join("") + ); +}; + +/* Note: addSetting and getSetting are no longer used by SWFUpload but are included + the maintain v2 API compatibility +*/ +// Public: (Deprecated) addSetting adds a setting value. If the value given is undefined or null then the default_value is used. +SWFUpload.prototype.addSetting = function (name, value, default_value) { + if (value == undefined) { + return (this.settings[name] = default_value); + } else { + return (this.settings[name] = value); + } +}; + +// Public: (Deprecated) getSetting gets a setting. Returns an empty string if the setting was not found. +SWFUpload.prototype.getSetting = function (name) { + if (this.settings[name] != undefined) { + return this.settings[name]; + } + + return ""; +}; + + + +// Private: callFlash handles function calls made to the Flash element. +// Calls are made with a setTimeout for some functions to work around +// bugs in the ExternalInterface library. +SWFUpload.prototype.callFlash = function (functionName, argumentArray) { + argumentArray = argumentArray || []; + + var movieElement = this.getMovieElement(); + var returnValue; + + if (typeof movieElement[functionName] === "function") { + // We have to go through all this if/else stuff because the Flash functions don't have apply() and only accept the exact number of arguments. + if (argumentArray.length === 0) { + returnValue = movieElement[functionName](); + } else if (argumentArray.length === 1) { + returnValue = movieElement[functionName](argumentArray[0]); + } else if (argumentArray.length === 2) { + returnValue = movieElement[functionName](argumentArray[0], argumentArray[1]); + } else if (argumentArray.length === 3) { + returnValue = movieElement[functionName](argumentArray[0], argumentArray[1], argumentArray[2]); + } else { + throw "Too many arguments"; + } + + // Unescape file post param values + if (returnValue != undefined && typeof returnValue.post === "object") { + returnValue = this.unescapeFilePostParams(returnValue); + } + + return returnValue; + } else { + throw "Invalid function name: " + functionName; + } +}; + + +/* ***************************** + -- Flash control methods -- + Your UI should use these + to operate SWFUpload + ***************************** */ + +// Public: selectFile causes a File Selection Dialog window to appear. This +// dialog only allows 1 file to be selected. WARNING: this function does not work in Flash Player 10 +SWFUpload.prototype.selectFile = function () { + this.callFlash("SelectFile"); +}; + +// Public: selectFiles causes a File Selection Dialog window to appear/ This +// dialog allows the user to select any number of files +// Flash Bug Warning: Flash limits the number of selectable files based on the combined length of the file names. +// If the selection name length is too long the dialog will fail in an unpredictable manner. There is no work-around +// for this bug. WARNING: this function does not work in Flash Player 10 +SWFUpload.prototype.selectFiles = function () { + this.callFlash("SelectFiles"); +}; + + +// Public: startUpload starts uploading the first file in the queue unless +// the optional parameter 'fileID' specifies the ID +SWFUpload.prototype.startUpload = function (fileID) { + this.callFlash("StartUpload", [fileID]); +}; + +// Public: cancelUpload cancels any queued file. The fileID parameter may be the file ID or index. +// If you do not specify a fileID the current uploading file or first file in the queue is cancelled. +// If you do not want the uploadError event to trigger you can specify false for the triggerErrorEvent parameter. +SWFUpload.prototype.cancelUpload = function (fileID, triggerErrorEvent) { + if (triggerErrorEvent !== false) { + triggerErrorEvent = true; + } + this.callFlash("CancelUpload", [fileID, triggerErrorEvent]); +}; + +// Public: stopUpload stops the current upload and requeues the file at the beginning of the queue. +// If nothing is currently uploading then nothing happens. +SWFUpload.prototype.stopUpload = function () { + this.callFlash("StopUpload"); +}; + +/* ************************ + * Settings methods + * These methods change the SWFUpload settings. + * SWFUpload settings should not be changed directly on the settings object + * since many of the settings need to be passed to Flash in order to take + * effect. + * *********************** */ + +// Public: getStats gets the file statistics object. +SWFUpload.prototype.getStats = function () { + return this.callFlash("GetStats"); +}; + +// Public: setStats changes the SWFUpload statistics. You shouldn't need to +// change the statistics but you can. Changing the statistics does not +// affect SWFUpload accept for the successful_uploads count which is used +// by the upload_limit setting to determine how many files the user may upload. +SWFUpload.prototype.setStats = function (statsObject) { + this.callFlash("SetStats", [statsObject]); +}; + +// Public: getFile retrieves a File object by ID or Index. If the file is +// not found then 'null' is returned. +SWFUpload.prototype.getFile = function (fileID) { + if (typeof(fileID) === "number") { + return this.callFlash("GetFileByIndex", [fileID]); + } else { + return this.callFlash("GetFile", [fileID]); + } +}; + +// Public: addFileParam sets a name/value pair that will be posted with the +// file specified by the Files ID. If the name already exists then the +// exiting value will be overwritten. +SWFUpload.prototype.addFileParam = function (fileID, name, value) { + return this.callFlash("AddFileParam", [fileID, name, value]); +}; + +// Public: removeFileParam removes a previously set (by addFileParam) name/value +// pair from the specified file. +SWFUpload.prototype.removeFileParam = function (fileID, name) { + this.callFlash("RemoveFileParam", [fileID, name]); +}; + +// Public: setUploadUrl changes the upload_url setting. +SWFUpload.prototype.setUploadURL = function (url) { + this.settings.upload_url = url.toString(); + this.callFlash("SetUploadURL", [url]); +}; + +// Public: setPostParams changes the post_params setting +SWFUpload.prototype.setPostParams = function (paramsObject) { + this.settings.post_params = paramsObject; + this.callFlash("SetPostParams", [paramsObject]); +}; + +// Public: addPostParam adds post name/value pair. Each name can have only one value. +SWFUpload.prototype.addPostParam = function (name, value) { + this.settings.post_params[name] = value; + this.callFlash("SetPostParams", [this.settings.post_params]); +}; + +// Public: removePostParam deletes post name/value pair. +SWFUpload.prototype.removePostParam = function (name) { + delete this.settings.post_params[name]; + this.callFlash("SetPostParams", [this.settings.post_params]); +}; + +// Public: setFileTypes changes the file_types setting and the file_types_description setting +SWFUpload.prototype.setFileTypes = function (types, description) { + this.settings.file_types = types; + this.settings.file_types_description = description; + this.callFlash("SetFileTypes", [types, description]); +}; + +// Public: setFileSizeLimit changes the file_size_limit setting +SWFUpload.prototype.setFileSizeLimit = function (fileSizeLimit) { + this.settings.file_size_limit = fileSizeLimit; + this.callFlash("SetFileSizeLimit", [fileSizeLimit]); +}; + +// Public: setFileUploadLimit changes the file_upload_limit setting +SWFUpload.prototype.setFileUploadLimit = function (fileUploadLimit) { + this.settings.file_upload_limit = fileUploadLimit; + this.callFlash("SetFileUploadLimit", [fileUploadLimit]); +}; + +// Public: setFileQueueLimit changes the file_queue_limit setting +SWFUpload.prototype.setFileQueueLimit = function (fileQueueLimit) { + this.settings.file_queue_limit = fileQueueLimit; + this.callFlash("SetFileQueueLimit", [fileQueueLimit]); +}; + +// Public: setFilePostName changes the file_post_name setting +SWFUpload.prototype.setFilePostName = function (filePostName) { + this.settings.file_post_name = filePostName; + this.callFlash("SetFilePostName", [filePostName]); +}; + +// Public: setUseQueryString changes the use_query_string setting +SWFUpload.prototype.setUseQueryString = function (useQueryString) { + this.settings.use_query_string = useQueryString; + this.callFlash("SetUseQueryString", [useQueryString]); +}; + +// Public: setRequeueOnError changes the requeue_on_error setting +SWFUpload.prototype.setRequeueOnError = function (requeueOnError) { + this.settings.requeue_on_error = requeueOnError; + this.callFlash("SetRequeueOnError", [requeueOnError]); +}; + +// Public: setHTTPSuccess changes the http_success setting +SWFUpload.prototype.setHTTPSuccess = function (http_status_codes) { + if (typeof http_status_codes === "string") { + http_status_codes = http_status_codes.replace(" ", "").split(","); + } + + this.settings.http_success = http_status_codes; + this.callFlash("SetHTTPSuccess", [http_status_codes]); +}; + + +// Public: setDebugEnabled changes the debug_enabled setting +SWFUpload.prototype.setDebugEnabled = function (debugEnabled) { + this.settings.debug_enabled = debugEnabled; + this.callFlash("SetDebugEnabled", [debugEnabled]); +}; + +// Public: setButtonImageURL loads a button image sprite +SWFUpload.prototype.setButtonImageURL = function (buttonImageURL) { + if (buttonImageURL == undefined) { + buttonImageURL = ""; + } + + this.settings.button_image_url = buttonImageURL; + this.callFlash("SetButtonImageURL", [buttonImageURL]); +}; + +// Public: setButtonDimensions resizes the Flash Movie and button +SWFUpload.prototype.setButtonDimensions = function (width, height) { + this.settings.button_width = width; + this.settings.button_height = height; + + var movie = this.getMovieElement(); + if (movie != undefined) { + movie.style.width = width + "px"; + movie.style.height = height + "px"; + } + + this.callFlash("SetButtonDimensions", [width, height]); +}; +// Public: setButtonText Changes the text overlaid on the button +SWFUpload.prototype.setButtonText = function (html) { + this.settings.button_text = html; + this.callFlash("SetButtonText", [html]); +}; +// Public: setButtonTextPadding changes the top and left padding of the text overlay +SWFUpload.prototype.setButtonTextPadding = function (left, top) { + this.settings.button_text_top_padding = top; + this.settings.button_text_left_padding = left; + this.callFlash("SetButtonTextPadding", [left, top]); +}; + +// Public: setButtonTextStyle changes the CSS used to style the HTML/Text overlaid on the button +SWFUpload.prototype.setButtonTextStyle = function (css) { + this.settings.button_text_style = css; + this.callFlash("SetButtonTextStyle", [css]); +}; +// Public: setButtonDisabled disables/enables the button +SWFUpload.prototype.setButtonDisabled = function (isDisabled) { + this.settings.button_disabled = isDisabled; + this.callFlash("SetButtonDisabled", [isDisabled]); +}; +// Public: setButtonAction sets the action that occurs when the button is clicked +SWFUpload.prototype.setButtonAction = function (buttonAction) { + this.settings.button_action = buttonAction; + this.callFlash("SetButtonAction", [buttonAction]); +}; + +// Public: setButtonCursor changes the mouse cursor displayed when hovering over the button +SWFUpload.prototype.setButtonCursor = function (cursor) { + this.settings.button_cursor = cursor; + this.callFlash("SetButtonCursor", [cursor]); +}; + +/* ******************************* + Flash Event Interfaces + These functions are used by Flash to trigger the various + events. + + All these functions a Private. + + Because the ExternalInterface library is buggy the event calls + are added to a queue and the queue then executed by a setTimeout. + This ensures that events are executed in a determinate order and that + the ExternalInterface bugs are avoided. +******************************* */ + +SWFUpload.prototype.queueEvent = function (handlerName, argumentArray) { + // Warning: Don't call this.debug inside here or you'll create an infinite loop + + if (argumentArray == undefined) { + argumentArray = []; + } else if (!(argumentArray instanceof Array)) { + argumentArray = [argumentArray]; + } + + var self = this; + if (typeof this.settings[handlerName] === "function") { + // Queue the event + this.eventQueue.push(function () { + this.settings[handlerName].apply(this, argumentArray); + }); + + // Execute the next queued event + setTimeout(function () { + self.executeNextEvent(); + }, 0); + + } else if (this.settings[handlerName] !== null) { + throw "Event handler " + handlerName + " is unknown or is not a function"; + } +}; + +// Private: Causes the next event in the queue to be executed. Since events are queued using a setTimeout +// we must queue them in order to garentee that they are executed in order. +SWFUpload.prototype.executeNextEvent = function () { + // Warning: Don't call this.debug inside here or you'll create an infinite loop + + var f = this.eventQueue ? this.eventQueue.shift() : null; + if (typeof(f) === "function") { + f.apply(this); + } +}; + +// Private: unescapeFileParams is part of a workaround for a flash bug where objects passed through ExternalInterface cannot have +// properties that contain characters that are not valid for JavaScript identifiers. To work around this +// the Flash Component escapes the parameter names and we must unescape again before passing them along. +SWFUpload.prototype.unescapeFilePostParams = function (file) { + var reg = /[$]([0-9a-f]{4})/i; + var unescapedPost = {}; + var uk; + + if (file != undefined) { + for (var k in file.post) { + if (file.post.hasOwnProperty(k)) { + uk = k; + var match; + while ((match = reg.exec(uk)) !== null) { + uk = uk.replace(match[0], String.fromCharCode(parseInt("0x" + match[1], 16))); + } + unescapedPost[uk] = file.post[k]; + } + } + + file.post = unescapedPost; + } + + return file; +}; + +SWFUpload.prototype.flashReady = function () { + // Check that the movie element is loaded correctly with its ExternalInterface methods defined + var movieElement = this.getMovieElement(); + if (typeof movieElement.StartUpload !== "function") { + throw "ExternalInterface methods failed to initialize."; + } + + // Fix IE Flash/Form bug + if (window[this.movieName] == undefined) { + window[this.movieName] = movieElement; + } + + this.queueEvent("swfupload_loaded_handler"); +}; + + +/* This is a chance to do something before the browse window opens */ +SWFUpload.prototype.fileDialogStart = function () { + this.queueEvent("file_dialog_start_handler"); +}; + + +/* Called when a file is successfully added to the queue. */ +SWFUpload.prototype.fileQueued = function (file) { + file = this.unescapeFilePostParams(file); + this.queueEvent("file_queued_handler", file); +}; + + +/* Handle errors that occur when an attempt to queue a file fails. */ +SWFUpload.prototype.fileQueueError = function (file, errorCode, message) { + file = this.unescapeFilePostParams(file); + this.queueEvent("file_queue_error_handler", [file, errorCode, message]); +}; + +/* Called after the file dialog has closed and the selected files have been queued. + You could call startUpload here if you want the queued files to begin uploading immediately. */ +SWFUpload.prototype.fileDialogComplete = function (numFilesSelected, numFilesQueued) { + this.queueEvent("file_dialog_complete_handler", [numFilesSelected, numFilesQueued]); +}; + +SWFUpload.prototype.uploadStart = function (file) { + file = this.unescapeFilePostParams(file); + this.queueEvent("return_upload_start_handler", file); +}; + +SWFUpload.prototype.returnUploadStart = function (file) { + var returnValue; + if (typeof this.settings.upload_start_handler === "function") { + file = this.unescapeFilePostParams(file); + returnValue = this.settings.upload_start_handler.call(this, file); + } else if (this.settings.upload_start_handler != undefined) { + throw "upload_start_handler must be a function"; + } + + // Convert undefined to true so if nothing is returned from the upload_start_handler it is + // interpretted as 'true'. + if (returnValue === undefined) { + returnValue = true; + } + + returnValue = !!returnValue; + + this.callFlash("ReturnUploadStart", [returnValue]); +}; + + + +SWFUpload.prototype.uploadProgress = function (file, bytesComplete, bytesTotal) { + file = this.unescapeFilePostParams(file); + this.queueEvent("upload_progress_handler", [file, bytesComplete, bytesTotal]); +}; + +SWFUpload.prototype.uploadError = function (file, errorCode, message) { + file = this.unescapeFilePostParams(file); + this.queueEvent("upload_error_handler", [file, errorCode, message]); +}; + +SWFUpload.prototype.uploadSuccess = function (file, serverData) { + file = this.unescapeFilePostParams(file); + this.queueEvent("upload_success_handler", [file, serverData]); +}; + +SWFUpload.prototype.uploadComplete = function (file) { + file = this.unescapeFilePostParams(file); + this.queueEvent("upload_complete_handler", file); +}; + +/* Called by SWFUpload JavaScript and Flash functions when debug is enabled. By default it writes messages to the + internal debug console. You can override this event and have messages written where you want. */ +SWFUpload.prototype.debug = function (message) { + this.queueEvent("debug_handler", message); +}; + + +/* ********************************** + Debug Console + The debug console is a self contained, in page location + for debug message to be sent. The Debug Console adds + itself to the body if necessary. + + The console is automatically scrolled as messages appear. + + If you are using your own debug handler or when you deploy to production and + have debug disabled you can remove these functions to reduce the file size + and complexity. +********************************** */ + +// Private: debugMessage is the default debug_handler. If you want to print debug messages +// call the debug() function. When overriding the function your own function should +// check to see if the debug setting is true before outputting debug information. +SWFUpload.prototype.debugMessage = function (message) { + if (this.settings.debug) { + var exceptionMessage, exceptionValues = []; + + // Check for an exception object and print it nicely + if (typeof message === "object" && typeof message.name === "string" && typeof message.message === "string") { + for (var key in message) { + if (message.hasOwnProperty(key)) { + exceptionValues.push(key + ": " + message[key]); + } + } + exceptionMessage = exceptionValues.join("\n") || ""; + exceptionValues = exceptionMessage.split("\n"); + exceptionMessage = "EXCEPTION: " + exceptionValues.join("\nEXCEPTION: "); + SWFUpload.Console.writeLine(exceptionMessage); + } else { + SWFUpload.Console.writeLine(message); + } + } +}; + +SWFUpload.Console = {}; +SWFUpload.Console.writeLine = function (message) { + var console, documentForm; + + try { + console = document.getElementById("SWFUpload_Console"); + + if (!console) { + documentForm = document.createElement("form"); + document.getElementsByTagName("body")[0].appendChild(documentForm); + + console = document.createElement("textarea"); + console.id = "SWFUpload_Console"; + console.style.fontFamily = "monospace"; + console.setAttribute("wrap", "off"); + console.wrap = "off"; + console.style.overflow = "auto"; + console.style.width = "700px"; + console.style.height = "350px"; + console.style.margin = "5px"; + documentForm.appendChild(console); + } + + console.value += message + "\n"; + + console.scrollTop = console.scrollHeight - console.clientHeight; + } catch (ex) { + alert("Exception: " + ex.name + " Message: " + ex.message); + } +}; diff --git a/lib/swfupload/swfupload.queue.js b/lib/swfupload/swfupload.queue.js new file mode 100644 index 00000000..b04d87ac --- /dev/null +++ b/lib/swfupload/swfupload.queue.js @@ -0,0 +1,77 @@ +/* + Queue Plug-in + + Features: + *Adds a cancelQueue() method for cancelling the entire queue. + *All queued files are uploaded when startUpload() is called. + *If false is returned from uploadComplete then the queue upload is stopped. + If false is not returned (strict comparison) then the queue upload is continued. + *Adds a QueueComplete event that is fired when all the queued files have finished uploading. + Set the event handler with the queue_complete_handler setting. + + */ + +var SWFUpload; +if (typeof(SWFUpload) === "function") { + SWFUpload.queue = {}; + + SWFUpload.prototype.initSettings = (function (oldInitSettings) { + return function () { + if (typeof(oldInitSettings) === "function") { + oldInitSettings.call(this); + } + + this.customSettings.queue_cancelled_flag = false; + this.customSettings.queue_upload_count = 0; + + this.settings.user_upload_complete_handler = this.settings.upload_complete_handler; + this.settings.upload_complete_handler = SWFUpload.queue.uploadCompleteHandler; + + this.settings.queue_complete_handler = this.settings.queue_complete_handler || null; + }; + })(SWFUpload.prototype.initSettings); + + SWFUpload.prototype.startUpload = function (fileID) { + this.customSettings.queue_cancelled_flag = false; + this.callFlash("StartUpload", false, [fileID]); + }; + + SWFUpload.prototype.cancelQueue = function () { + this.customSettings.queue_cancelled_flag = true; + this.stopUpload(); + + var stats = this.getStats(); + while (stats.files_queued > 0) { + this.cancelUpload(); + stats = this.getStats(); + } + }; + + SWFUpload.queue.uploadCompleteHandler = function (file) { + var user_upload_complete_handler = this.settings.user_upload_complete_handler; + var continueUpload; + + if (file.filestatus === SWFUpload.FILE_STATUS.COMPLETE) { + this.customSettings.queue_upload_count++; + } + + if (typeof(user_upload_complete_handler) === "function") { + continueUpload = (user_upload_complete_handler.call(this, file) === false) ? false : true; + } else { + continueUpload = true; + } + + if (continueUpload) { + var stats = this.getStats(); + if (stats.files_queued > 0 && this.customSettings.queue_cancelled_flag === false) { + this.startUpload(); + } else if (this.customSettings.queue_cancelled_flag === false) { + this.queueEvent("queue_complete_handler", [this.customSettings.queue_upload_count]); + this.customSettings.queue_upload_count = 0; + } else { + this.customSettings.queue_cancelled_flag = false; + this.customSettings.queue_upload_count = 0; + } + } + }; +}
\ No newline at end of file diff --git a/lib/swfupload/swfupload.swf b/lib/swfupload/swfupload.swf Binary files differnew file mode 100644 index 00000000..a627b19b --- /dev/null +++ b/lib/swfupload/swfupload.swf diff --git a/modules/server_add/js/server_add.js b/modules/server_add/js/server_add.js index b5ad7336..d4066a7d 100644 --- a/modules/server_add/js/server_add.js +++ b/modules/server_add/js/server_add.js @@ -2,7 +2,7 @@ $("#gServerAdd").ready(function() { $("#gServerAdd :submit").click(function(event) { do_add(this, event); }); - $("#gProgressBar").progressbar(); + $(".gProgressBar").progressbar(); $("#gServerAddTree ul").css("display", "block"); }); @@ -60,8 +60,8 @@ function load_children(parent, callback) { function do_add(submit, event) { event.preventDefault(); - $("#gProgressBar").progressbar("value", 0); - $("#gProgressBar").css("visibility", "visible"); + $(".gProgressBar").progressbar("value", 0); + $(".gProgressBar").css("visibility", "visible"); var check_list = $("#gServerAdd :checkbox[checked]"); var parms = ""; @@ -83,7 +83,7 @@ function do_add(submit, event) { while (!done) { $.ajax({async: false, success: function(data, textStatus) { - $("#gProgressBar").progressbar("value", data.task.percent_complete); + $(".gProgressBar").progressbar("value", data.task.percent_complete); done = data.task.done; }, dataType: "json", diff --git a/modules/server_add/views/server_add_tree_dialog.html.php b/modules/server_add/views/server_add_tree_dialog.html.php index feab2dd0..a52d2729 100644 --- a/modules/server_add/views/server_add_tree_dialog.html.php +++ b/modules/server_add/views/server_add_tree_dialog.html.php @@ -19,5 +19,5 @@ <?= form::submit(array("id" => "gServerAddButton", "name" => "add", "disabled" => true, "class" => "submit"), t("Add")) ?> </span> <?= form::close() ?> - <div id="gProgressBar" style="visibility: hidden" ></div> + <div class="gProgressBar" style="visibility: hidden" ></div> </div> diff --git a/themes/default/css/screen.css b/themes/default/css/screen.css index 3d29726a..b09edbe0 100644 --- a/themes/default/css/screen.css +++ b/themes/default/css/screen.css @@ -874,13 +874,6 @@ form .gError, padding-left: 2.5em; } -#gProgressBar { - height: 1em; - width: 100%; - margin-top: 0.5em; - display: inline-block; -} - #gServerAdd #gServerAddTree { border: 1px solid #CCCCCC; height: 25em; @@ -912,3 +905,84 @@ form .gError, #gServerAdd .gBreadcrumbs li { padding: 10px 6px 10px 16px; } + + +/*************** STUFF THAT NEEDS A HOME ****************/ +.gProgressBar { + height: 1em; + width: 100%; + margin-top: 0.5em; + display: inline-block; +} + +#gAddPhotos p { + margin: 0px; + padding: 0px; +} + +#gAddPhotos ul li { + margin: 0px; + padding: 0px; + padding-right: 4px; +} + +#gAddPhotos ul li.active { + font-weight: bold; +} + +#gAddPhotos ul { + margin: 0px; + padding: 0px; +} + +#gAddPhotos ul li:after { + content: ">"; +} + +#gAddPhotos ul li.active:after { + content: ""; +} + +#gAddPhotosCanvas { + height: 325px; + width: 400px; + overflow: auto; +} + +#gAddPhotosQueue .progressbar { + height: 4px; +} + +#gAddPhotosQueue .title { + font-size: 1.25em; +} + +#gAddPhotosQueue .status { + font-size: .75em; +} + +#gAddPhotosQueue .box { + margin-bottom: 8px; + padding-left: 4px; + padding-bottom: 4px; +} + +#gAddPhotosQueue .pending { + background-color: #e8e8e8; + border: 1px solid #d7d7d7; +} + +#gAddPhotosQueue .error { + background-color: #fcc; + border: 1px solid #ebb; +} + +#gAddPhotosQueue .uploading { + background-color: #ff9; + border: 1px solid #ee8; +} + +#gAddPhotosQueue .complete { + background-color: #cfc; + border: 1px solid #beb; +} |