WordPress.org

Make WordPress Core

Ticket #41752: 41752.patch

File 41752.patch, 91.8 KB (added by azaozz, 9 months ago)
  • src/wp-admin/async-upload.php

     
    1414        define( 'WP_ADMIN', true );
    1515}
    1616
    17 if ( defined('ABSPATH') )
    18         require_once(ABSPATH . 'wp-load.php');
    19 else
     17if ( defined( 'ABSPATH' ) ) {
     18        require_once( ABSPATH . 'wp-load.php' );
     19} else {
    2020        require_once( dirname( dirname( __FILE__ ) ) . '/wp-load.php' );
    21 
    22 if ( ! ( isset( $_REQUEST['action'] ) && 'upload-attachment' == $_REQUEST['action'] ) ) {
    23         // Flash often fails to send cookies with the POST or upload, so we need to pass it in GET or POST instead
    24         if ( is_ssl() && empty($_COOKIE[SECURE_AUTH_COOKIE]) && !empty($_REQUEST['auth_cookie']) )
    25                 $_COOKIE[SECURE_AUTH_COOKIE] = $_REQUEST['auth_cookie'];
    26         elseif ( empty($_COOKIE[AUTH_COOKIE]) && !empty($_REQUEST['auth_cookie']) )
    27                 $_COOKIE[AUTH_COOKIE] = $_REQUEST['auth_cookie'];
    28         if ( empty($_COOKIE[LOGGED_IN_COOKIE]) && !empty($_REQUEST['logged_in_cookie']) )
    29                 $_COOKIE[LOGGED_IN_COOKIE] = $_REQUEST['logged_in_cookie'];
    30         unset($current_user);
    3121}
    3222
    3323require_once( ABSPATH . 'wp-admin/admin.php' );
  • src/wp-admin/includes/update-core.php

     
    716716// 4.9
    717717'wp-includes/js/plupload/plupload.flash.swf',
    718718'wp-includes/js/plupload/plupload.silverlight.xap',
     719'wp-includes/js/swfupload/plugins',
     720'wp-includes/js/swfupload/swfupload.swf',
    719721);
    720722
    721723/**
  • src/wp-includes/js/swfupload/plugins/swfupload.cookies.js

     
    1 /*
    2         Cookie Plug-in
    3        
    4         This plug in automatically gets all the cookies for this site and adds them to the post_params.
    5         Cookies are loaded only on initialization.  The refreshCookies function can be called to update the post_params.
    6         The cookies will override any other post params with the same name.
    7 */
    8 
    9 var SWFUpload;
    10 if (typeof(SWFUpload) === "function") {
    11         SWFUpload.prototype.initSettings = function (oldInitSettings) {
    12                 return function () {
    13                         if (typeof(oldInitSettings) === "function") {
    14                                 oldInitSettings.call(this);
    15                         }
    16                        
    17                         this.refreshCookies(false);     // The false parameter must be sent since SWFUpload has not initialzed at this point
    18                 };
    19         }(SWFUpload.prototype.initSettings);
    20        
    21         // refreshes the post_params and updates SWFUpload.  The sendToFlash parameters is optional and defaults to True
    22         SWFUpload.prototype.refreshCookies = function (sendToFlash) {
    23                 if (sendToFlash === undefined) {
    24                         sendToFlash = true;
    25                 }
    26                 sendToFlash = !!sendToFlash;
    27                
    28                 // Get the post_params object
    29                 var postParams = this.settings.post_params;
    30                
    31                 // Get the cookies
    32                 var i, cookieArray = document.cookie.split(';'), caLength = cookieArray.length, c, eqIndex, name, value;
    33                 for (i = 0; i < caLength; i++) {
    34                         c = cookieArray[i];
    35                        
    36                         // Left Trim spaces
    37                         while (c.charAt(0) === " ") {
    38                                 c = c.substring(1, c.length);
    39                         }
    40                         eqIndex = c.indexOf("=");
    41                         if (eqIndex > 0) {
    42                                 name = c.substring(0, eqIndex);
    43                                 value = c.substring(eqIndex + 1);
    44                                 postParams[name] = value;
    45                         }
    46                 }
    47                
    48                 if (sendToFlash) {
    49                         this.setPostParams(postParams);
    50                 }
    51         };
    52 
    53 }
  • src/wp-includes/js/swfupload/plugins/swfupload.queue.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.cookies.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    1 /*
    2         Queue Plug-in
    3        
    4         Features:
    5                 *Adds a cancelQueue() method for cancelling the entire queue.
    6                 *All queued files are uploaded when startUpload() is called.
    7                 *If false is returned from uploadComplete then the queue upload is stopped.
    8                  If false is not returned (strict comparison) then the queue upload is continued.
    9                 *Adds a QueueComplete event that is fired when all the queued files have finished uploading.
    10                  Set the event handler with the queue_complete_handler setting.
    11                
    12         */
    13 
    14 var SWFUpload;
    15 if (typeof(SWFUpload) === "function") {
    16         SWFUpload.queue = {};
    17        
    18         SWFUpload.prototype.initSettings = (function (oldInitSettings) {
    19                 return function () {
    20                         if (typeof(oldInitSettings) === "function") {
    21                                 oldInitSettings.call(this);
    22                         }
    23                        
    24                         this.queueSettings = {};
    25                        
    26                         this.queueSettings.queue_cancelled_flag = false;
    27                         this.queueSettings.queue_upload_count = 0;
    28                        
    29                         this.queueSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
    30                         this.queueSettings.user_upload_start_handler = this.settings.upload_start_handler;
    31                         this.settings.upload_complete_handler = SWFUpload.queue.uploadCompleteHandler;
    32                         this.settings.upload_start_handler = SWFUpload.queue.uploadStartHandler;
    33                        
    34                         this.settings.queue_complete_handler = this.settings.queue_complete_handler || null;
    35                 };
    36         })(SWFUpload.prototype.initSettings);
    37 
    38         SWFUpload.prototype.startUpload = function (fileID) {
    39                 this.queueSettings.queue_cancelled_flag = false;
    40                 this.callFlash("StartUpload", [fileID]);
    41         };
    42 
    43         SWFUpload.prototype.cancelQueue = function () {
    44                 this.queueSettings.queue_cancelled_flag = true;
    45                 this.stopUpload();
    46                
    47                 var stats = this.getStats();
    48                 while (stats.files_queued > 0) {
    49                         this.cancelUpload();
    50                         stats = this.getStats();
    51                 }
    52         };
    53        
    54         SWFUpload.queue.uploadStartHandler = function (file) {
    55                 var returnValue;
    56                 if (typeof(this.queueSettings.user_upload_start_handler) === "function") {
    57                         returnValue = this.queueSettings.user_upload_start_handler.call(this, file);
    58                 }
    59                
    60                 // To prevent upload a real "FALSE" value must be returned, otherwise default to a real "TRUE" value.
    61                 returnValue = (returnValue === false) ? false : true;
    62                
    63                 this.queueSettings.queue_cancelled_flag = !returnValue;
    64 
    65                 return returnValue;
    66         };
    67        
    68         SWFUpload.queue.uploadCompleteHandler = function (file) {
    69                 var user_upload_complete_handler = this.queueSettings.user_upload_complete_handler;
    70                 var continueUpload;
    71                
    72                 if (file.filestatus === SWFUpload.FILE_STATUS.COMPLETE) {
    73                         this.queueSettings.queue_upload_count++;
    74                 }
    75 
    76                 if (typeof(user_upload_complete_handler) === "function") {
    77                         continueUpload = (user_upload_complete_handler.call(this, file) === false) ? false : true;
    78                 } else if (file.filestatus === SWFUpload.FILE_STATUS.QUEUED) {
    79                         // If the file was stopped and re-queued don't restart the upload
    80                         continueUpload = false;
    81                 } else {
    82                         continueUpload = true;
    83                 }
    84                
    85                 if (continueUpload) {
    86                         var stats = this.getStats();
    87                         if (stats.files_queued > 0 && this.queueSettings.queue_cancelled_flag === false) {
    88                                 this.startUpload();
    89                         } else if (this.queueSettings.queue_cancelled_flag === false) {
    90                                 this.queueEvent("queue_complete_handler", [this.queueSettings.queue_upload_count]);
    91                                 this.queueSettings.queue_upload_count = 0;
    92                         } else {
    93                                 this.queueSettings.queue_cancelled_flag = false;
    94                                 this.queueSettings.queue_upload_count = 0;
    95                         }
    96                 }
    97         };
    98 }
  • src/wp-includes/js/swfupload/plugins/swfupload.speed.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.queue.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    1 /*
    2         Speed Plug-in
    3        
    4         Features:
    5                 *Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.
    6                         - currentSpeed -- String indicating the upload speed, bytes per second
    7                         - averageSpeed -- Overall average upload speed, bytes per second
    8                         - movingAverageSpeed -- Speed over averaged over the last several measurements, bytes per second
    9                         - timeRemaining -- Estimated remaining upload time in seconds
    10                         - timeElapsed -- Number of seconds passed for this upload
    11                         - percentUploaded -- Percentage of the file uploaded (0 to 100)
    12                         - sizeUploaded -- Formatted size uploaded so far, bytes
    13                
    14                 *Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.
    15                
    16                 *Adds several Formatting functions for formatting that values provided on the file object.
    17                         - SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)
    18                         - SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)
    19                         - SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )
    20                         - SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)
    21                         - SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)
    22                                 - Formats a number using the division array to determine how to apply the labels in the Label Array
    23                                 - factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)
    24                                     or as several numbers labeled with units (time)
    25         */
    26 
    27 var SWFUpload;
    28 if (typeof(SWFUpload) === "function") {
    29         SWFUpload.speed = {};
    30        
    31         SWFUpload.prototype.initSettings = (function (oldInitSettings) {
    32                 return function () {
    33                         if (typeof(oldInitSettings) === "function") {
    34                                 oldInitSettings.call(this);
    35                         }
    36                        
    37                         this.ensureDefault = function (settingName, defaultValue) {
    38                                 this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
    39                         };
    40 
    41                         // List used to keep the speed stats for the files we are tracking
    42                         this.fileSpeedStats = {};
    43                         this.speedSettings = {};
    44 
    45                         this.ensureDefault("moving_average_history_size", "10");
    46                        
    47                         this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;
    48                         this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;
    49                         this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;
    50                         this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;
    51                         this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;
    52                         this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;
    53                         this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
    54                        
    55                         this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;
    56                         this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;
    57                         this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;
    58                         this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;
    59                         this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;
    60                         this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;
    61                         this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;
    62                        
    63                         delete this.ensureDefault;
    64                 };
    65         })(SWFUpload.prototype.initSettings);
    66 
    67        
    68         SWFUpload.speed.fileQueuedHandler = function (file) {
    69                 if (typeof this.speedSettings.user_file_queued_handler === "function") {
    70                         file = SWFUpload.speed.extendFile(file);
    71                        
    72                         return this.speedSettings.user_file_queued_handler.call(this, file);
    73                 }
    74         };
    75        
    76         SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {
    77                 if (typeof this.speedSettings.user_file_queue_error_handler === "function") {
    78                         file = SWFUpload.speed.extendFile(file);
    79                        
    80                         return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);
    81                 }
    82         };
    83 
    84         SWFUpload.speed.uploadStartHandler = function (file) {
    85                 if (typeof this.speedSettings.user_upload_start_handler === "function") {
    86                         file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    87                         return this.speedSettings.user_upload_start_handler.call(this, file);
    88                 }
    89         };
    90        
    91         SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {
    92                 file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    93                 SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
    94 
    95                 if (typeof this.speedSettings.user_upload_error_handler === "function") {
    96                         return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);
    97                 }
    98         };
    99         SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {
    100                 this.updateTracking(file, bytesComplete);
    101                 file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    102 
    103                 if (typeof this.speedSettings.user_upload_progress_handler === "function") {
    104                         return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);
    105                 }
    106         };
    107        
    108         SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {
    109                 if (typeof this.speedSettings.user_upload_success_handler === "function") {
    110                         file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    111                         return this.speedSettings.user_upload_success_handler.call(this, file, serverData);
    112                 }
    113         };
    114         SWFUpload.speed.uploadCompleteHandler = function (file) {
    115                 file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    116                 SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
    117 
    118                 if (typeof this.speedSettings.user_upload_complete_handler === "function") {
    119                         return this.speedSettings.user_upload_complete_handler.call(this, file);
    120                 }
    121         };
    122        
    123         // Private: extends the file object with the speed plugin values
    124         SWFUpload.speed.extendFile = function (file, trackingList) {
    125                 var tracking;
    126                
    127                 if (trackingList) {
    128                         tracking = trackingList[file.id];
    129                 }
    130                
    131                 if (tracking) {
    132                         file.currentSpeed = tracking.currentSpeed;
    133                         file.averageSpeed = tracking.averageSpeed;
    134                         file.movingAverageSpeed = tracking.movingAverageSpeed;
    135                         file.timeRemaining = tracking.timeRemaining;
    136                         file.timeElapsed = tracking.timeElapsed;
    137                         file.percentUploaded = tracking.percentUploaded;
    138                         file.sizeUploaded = tracking.bytesUploaded;
    139 
    140                 } else {
    141                         file.currentSpeed = 0;
    142                         file.averageSpeed = 0;
    143                         file.movingAverageSpeed = 0;
    144                         file.timeRemaining = 0;
    145                         file.timeElapsed = 0;
    146                         file.percentUploaded = 0;
    147                         file.sizeUploaded = 0;
    148                 }
    149                
    150                 return file;
    151         };
    152        
    153         // Private: Updates the speed tracking object, or creates it if necessary
    154         SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {
    155                 var tracking = this.fileSpeedStats[file.id];
    156                 if (!tracking) {
    157                         this.fileSpeedStats[file.id] = tracking = {};
    158                 }
    159                
    160                 // Sanity check inputs
    161                 bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;
    162                 if (bytesUploaded < 0) {
    163                         bytesUploaded = 0;
    164                 }
    165                 if (bytesUploaded > file.size) {
    166                         bytesUploaded = file.size;
    167                 }
    168                
    169                 var tickTime = (new Date()).getTime();
    170                 if (!tracking.startTime) {
    171                         tracking.startTime = (new Date()).getTime();
    172                         tracking.lastTime = tracking.startTime;
    173                         tracking.currentSpeed = 0;
    174                         tracking.averageSpeed = 0;
    175                         tracking.movingAverageSpeed = 0;
    176                         tracking.movingAverageHistory = [];
    177                         tracking.timeRemaining = 0;
    178                         tracking.timeElapsed = 0;
    179                         tracking.percentUploaded = bytesUploaded / file.size;
    180                         tracking.bytesUploaded = bytesUploaded;
    181                 } else if (tracking.startTime > tickTime) {
    182                         this.debug("When backwards in time");
    183                 } else {
    184                         // Get time and deltas
    185                         var now = (new Date()).getTime();
    186                         var lastTime = tracking.lastTime;
    187                         var deltaTime = now - lastTime;
    188                         var deltaBytes = bytesUploaded - tracking.bytesUploaded;
    189                        
    190                         if (deltaBytes === 0 || deltaTime === 0) {
    191                                 return tracking;
    192                         }
    193                        
    194                         // Update tracking object
    195                         tracking.lastTime = now;
    196                         tracking.bytesUploaded = bytesUploaded;
    197                        
    198                         // Calculate speeds
    199                         tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);
    200                         tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);
    201 
    202                         // Calculate moving average
    203                         tracking.movingAverageHistory.push(tracking.currentSpeed);
    204                         if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {
    205                                 tracking.movingAverageHistory.shift();
    206                         }
    207                        
    208                         tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);
    209                        
    210                         // Update times
    211                         tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;
    212                         tracking.timeElapsed = (now - tracking.startTime) / 1000;
    213                        
    214                         // Update percent
    215                         tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);
    216                 }
    217                
    218                 return tracking;
    219         };
    220         SWFUpload.speed.removeTracking = function (file, trackingList) {
    221                 try {
    222                         trackingList[file.id] = null;
    223                         delete trackingList[file.id];
    224                 } catch (ex) {
    225                 }
    226         };
    227        
    228         SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {
    229                 var i, unit, unitDivisor, unitLabel;
    230 
    231                 if (baseNumber === 0) {
    232                         return "0 " + unitLabels[unitLabels.length - 1];
    233                 }
    234                
    235                 if (singleFractional) {
    236                         unit = baseNumber;
    237                         unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";
    238                         for (i = 0; i < unitDivisors.length; i++) {
    239                                 if (baseNumber >= unitDivisors[i]) {
    240                                         unit = (baseNumber / unitDivisors[i]).toFixed(2);
    241                                         unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";
    242                                         break;
    243                                 }
    244                         }
    245                        
    246                         return unit + unitLabel;
    247                 } else {
    248                         var formattedStrings = [];
    249                         var remainder = baseNumber;
    250                        
    251                         for (i = 0; i < unitDivisors.length; i++) {
    252                                 unitDivisor = unitDivisors[i];
    253                                 unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";
    254                                
    255                                 unit = remainder / unitDivisor;
    256                                 if (i < unitDivisors.length -1) {
    257                                         unit = Math.floor(unit);
    258                                 } else {
    259                                         unit = unit.toFixed(2);
    260                                 }
    261                                 if (unit > 0) {
    262                                         remainder = remainder % unitDivisor;
    263                                        
    264                                         formattedStrings.push(unit + unitLabel);
    265                                 }
    266                         }
    267                        
    268                         return formattedStrings.join(" ");
    269                 }
    270         };
    271        
    272         SWFUpload.speed.formatBPS = function (baseNumber) {
    273                 var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];
    274                 return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);
    275        
    276         };
    277         SWFUpload.speed.formatTime = function (baseNumber) {
    278                 var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];
    279                 return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);
    280        
    281         };
    282         SWFUpload.speed.formatBytes = function (baseNumber) {
    283                 var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];
    284                 return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);
    285        
    286         };
    287         SWFUpload.speed.formatPercent = function (baseNumber) {
    288                 return baseNumber.toFixed(2) + " %";
    289         };
    290        
    291         SWFUpload.speed.calculateMovingAverage = function (history) {
    292                 var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;
    293                 var i;
    294                 var mSum = 0, mCount = 0;
    295                
    296                 size = history.length;
    297                
    298                 // Check for sufficient data
    299                 if (size >= 8) {
    300                         // Clone the array and Calculate sum of the values
    301                         for (i = 0; i < size; i++) {
    302                                 vals[i] = history[i];
    303                                 sum += vals[i];
    304                         }
    305 
    306                         mean = sum / size;
    307 
    308                         // Calculate variance for the set
    309                         for (i = 0; i < size; i++) {
    310                                 varianceTemp += Math.pow((vals[i] - mean), 2);
    311                         }
    312 
    313                         variance = varianceTemp / size;
    314                         standardDev = Math.sqrt(variance);
    315                        
    316                         //Standardize the Data
    317                         for (i = 0; i < size; i++) {
    318                                 vals[i] = (vals[i] - mean) / standardDev;
    319                         }
    320 
    321                         // Calculate the average excluding outliers
    322                         var deviationRange = 2.0;
    323                         for (i = 0; i < size; i++) {
    324                                
    325                                 if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {
    326                                         mCount++;
    327                                         mSum += history[i];
    328                                 }
    329                         }
    330                        
    331                 } else {
    332                         // Calculate the average (not enough data points to remove outliers)
    333                         mCount = size;
    334                         for (i = 0; i < size; i++) {
    335                                 mSum += history[i];
    336                         }
    337                 }
    338 
    339                 return mSum / mCount;
    340         };
    341        
    342 }
    343  No newline at end of file
  • src/wp-includes/js/swfupload/plugins/swfupload.swfobject.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.speed.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    1 /*
    2         SWFUpload.SWFObject Plugin
    3 
    4         Summary:
    5                 This plugin uses SWFObject to embed SWFUpload dynamically in the page.  SWFObject provides accurate Flash Player detection and DOM Ready loading.
    6                 This plugin replaces the Graceful Degradation plugin.
    7 
    8         Features:
    9                 * swfupload_load_failed_hander event
    10                 * swfupload_pre_load_handler event
    11                 * minimum_flash_version setting (default: "9.0.28")
    12                 * SWFUpload.onload event for early loading
    13 
    14         Usage:
    15                 Provide handlers and settings as needed.  When using the SWFUpload.SWFObject plugin you should initialize SWFUploading
    16                 in SWFUpload.onload rather than in window.onload.  When initialized this way SWFUpload can load earlier preventing the UI flicker
    17                 that was seen using the Graceful Degradation plugin.
    18 
    19                 <script type="text/javascript">
    20                         var swfu;
    21                         SWFUpload.onload = function () {
    22                                 swfu = new SWFUpload({
    23                                         minimum_flash_version: "9.0.28",
    24                                         swfupload_pre_load_handler: swfuploadPreLoad,
    25                                         swfupload_load_failed_handler: swfuploadLoadFailed
    26                                 });
    27                         };
    28                 </script>
    29                
    30         Notes:
    31                 You must provide set minimum_flash_version setting to "8" if you are using SWFUpload for Flash Player 8.
    32                 The swfuploadLoadFailed event is only fired if the minimum version of Flash Player is not met.  Other issues such as missing SWF files, browser bugs
    33                  or corrupt Flash Player installations will not trigger this event.
    34                 The swfuploadPreLoad event is fired as soon as the minimum version of Flash Player is found.  It does not wait for SWFUpload to load and can
    35                  be used to prepare the SWFUploadUI and hide alternate content.
    36                 swfobject's onDomReady event is cross-browser safe but will default to the window.onload event when DOMReady is not supported by the browser.
    37                  Early DOM Loading is supported in major modern browsers but cannot be guaranteed for every browser ever made.
    38 */
    39 
    40 
    41 // SWFObject v2.1 must be loaded
    42        
    43 var SWFUpload;
    44 if (typeof(SWFUpload) === "function") {
    45         SWFUpload.onload = function () {};
    46 
    47         swfobject.addDomLoadEvent(function () {
    48                 if (typeof(SWFUpload.onload) === "function") {
    49                         setTimeout(function(){SWFUpload.onload.call(window);}, 200);
    50                 }
    51         });
    52 
    53         SWFUpload.prototype.initSettings = (function (oldInitSettings) {
    54                 return function () {
    55                         if (typeof(oldInitSettings) === "function") {
    56                                 oldInitSettings.call(this);
    57                         }
    58 
    59                         this.ensureDefault = function (settingName, defaultValue) {
    60                                 this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
    61                         };
    62 
    63                         this.ensureDefault("minimum_flash_version", "9.0.28");
    64                         this.ensureDefault("swfupload_pre_load_handler", null);
    65                         this.ensureDefault("swfupload_load_failed_handler", null);
    66 
    67                         delete this.ensureDefault;
    68 
    69                 };
    70         })(SWFUpload.prototype.initSettings);
    71 
    72 
    73         SWFUpload.prototype.loadFlash = function (oldLoadFlash) {
    74                 return function () {
    75                         var hasFlash = swfobject.hasFlashPlayerVersion(this.settings.minimum_flash_version);
    76                        
    77                         if (hasFlash) {
    78                                 this.queueEvent("swfupload_pre_load_handler");
    79                                 if (typeof(oldLoadFlash) === "function") {
    80                                         oldLoadFlash.call(this);
    81                                 }
    82                         } else {
    83                                 this.queueEvent("swfupload_load_failed_handler");
    84                         }
    85                 };
    86                
    87         }(SWFUpload.prototype.loadFlash);
    88                        
    89         SWFUpload.prototype.displayDebugInfo = function (oldDisplayDebugInfo) {
    90                 return function () {
    91                         if (typeof(oldDisplayDebugInfo) === "function") {
    92                                 oldDisplayDebugInfo.call(this);
    93                         }
    94                        
    95                         this.debug(
    96                                 [
    97                                         "SWFUpload.SWFObject Plugin settings:", "\n",
    98                                         "\t", "minimum_flash_version:                      ", this.settings.minimum_flash_version, "\n",
    99                                         "\t", "swfupload_pre_load_handler assigned:     ", (typeof(this.settings.swfupload_pre_load_handler) === "function").toString(), "\n",
    100                                         "\t", "swfupload_load_failed_handler assigned:     ", (typeof(this.settings.swfupload_load_failed_handler) === "function").toString(), "\n",
    101                                 ].join("")
    102                         );
    103                 };     
    104         }(SWFUpload.prototype.displayDebugInfo);
    105 }
  • src/wp-includes/js/swfupload/plugins

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.swfobject.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
  • src/wp-includes/js/swfupload/plugins/swfupload.cookies.js

    Property changes on: src/wp-includes/js/swfupload/plugins
    ___________________________________________________________________
    Deleted: bugtraq:number
    ## -1 +0,0 ##
    -true
    \ No newline at end of property
     
    1 /*
    2         Cookie Plug-in
    3        
    4         This plug in automatically gets all the cookies for this site and adds them to the post_params.
    5         Cookies are loaded only on initialization.  The refreshCookies function can be called to update the post_params.
    6         The cookies will override any other post params with the same name.
    7 */
    8 
    9 var SWFUpload;
    10 if (typeof(SWFUpload) === "function") {
    11         SWFUpload.prototype.initSettings = function (oldInitSettings) {
    12                 return function () {
    13                         if (typeof(oldInitSettings) === "function") {
    14                                 oldInitSettings.call(this);
    15                         }
    16                        
    17                         this.refreshCookies(false);     // The false parameter must be sent since SWFUpload has not initialzed at this point
    18                 };
    19         }(SWFUpload.prototype.initSettings);
    20        
    21         // refreshes the post_params and updates SWFUpload.  The sendToFlash parameters is optional and defaults to True
    22         SWFUpload.prototype.refreshCookies = function (sendToFlash) {
    23                 if (sendToFlash === undefined) {
    24                         sendToFlash = true;
    25                 }
    26                 sendToFlash = !!sendToFlash;
    27                
    28                 // Get the post_params object
    29                 var postParams = this.settings.post_params;
    30                
    31                 // Get the cookies
    32                 var i, cookieArray = document.cookie.split(';'), caLength = cookieArray.length, c, eqIndex, name, value;
    33                 for (i = 0; i < caLength; i++) {
    34                         c = cookieArray[i];
    35                        
    36                         // Left Trim spaces
    37                         while (c.charAt(0) === " ") {
    38                                 c = c.substring(1, c.length);
    39                         }
    40                         eqIndex = c.indexOf("=");
    41                         if (eqIndex > 0) {
    42                                 name = c.substring(0, eqIndex);
    43                                 value = c.substring(eqIndex + 1);
    44                                 postParams[name] = value;
    45                         }
    46                 }
    47                
    48                 if (sendToFlash) {
    49                         this.setPostParams(postParams);
    50                 }
    51         };
    52 
    53 }
  • src/wp-includes/js/swfupload/plugins/swfupload.queue.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.cookies.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    1 /*
    2         Queue Plug-in
    3        
    4         Features:
    5                 *Adds a cancelQueue() method for cancelling the entire queue.
    6                 *All queued files are uploaded when startUpload() is called.
    7                 *If false is returned from uploadComplete then the queue upload is stopped.
    8                  If false is not returned (strict comparison) then the queue upload is continued.
    9                 *Adds a QueueComplete event that is fired when all the queued files have finished uploading.
    10                  Set the event handler with the queue_complete_handler setting.
    11                
    12         */
    13 
    14 var SWFUpload;
    15 if (typeof(SWFUpload) === "function") {
    16         SWFUpload.queue = {};
    17        
    18         SWFUpload.prototype.initSettings = (function (oldInitSettings) {
    19                 return function () {
    20                         if (typeof(oldInitSettings) === "function") {
    21                                 oldInitSettings.call(this);
    22                         }
    23                        
    24                         this.queueSettings = {};
    25                        
    26                         this.queueSettings.queue_cancelled_flag = false;
    27                         this.queueSettings.queue_upload_count = 0;
    28                        
    29                         this.queueSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
    30                         this.queueSettings.user_upload_start_handler = this.settings.upload_start_handler;
    31                         this.settings.upload_complete_handler = SWFUpload.queue.uploadCompleteHandler;
    32                         this.settings.upload_start_handler = SWFUpload.queue.uploadStartHandler;
    33                        
    34                         this.settings.queue_complete_handler = this.settings.queue_complete_handler || null;
    35                 };
    36         })(SWFUpload.prototype.initSettings);
    37 
    38         SWFUpload.prototype.startUpload = function (fileID) {
    39                 this.queueSettings.queue_cancelled_flag = false;
    40                 this.callFlash("StartUpload", [fileID]);
    41         };
    42 
    43         SWFUpload.prototype.cancelQueue = function () {
    44                 this.queueSettings.queue_cancelled_flag = true;
    45                 this.stopUpload();
    46                
    47                 var stats = this.getStats();
    48                 while (stats.files_queued > 0) {
    49                         this.cancelUpload();
    50                         stats = this.getStats();
    51                 }
    52         };
    53        
    54         SWFUpload.queue.uploadStartHandler = function (file) {
    55                 var returnValue;
    56                 if (typeof(this.queueSettings.user_upload_start_handler) === "function") {
    57                         returnValue = this.queueSettings.user_upload_start_handler.call(this, file);
    58                 }
    59                
    60                 // To prevent upload a real "FALSE" value must be returned, otherwise default to a real "TRUE" value.
    61                 returnValue = (returnValue === false) ? false : true;
    62                
    63                 this.queueSettings.queue_cancelled_flag = !returnValue;
    64 
    65                 return returnValue;
    66         };
    67        
    68         SWFUpload.queue.uploadCompleteHandler = function (file) {
    69                 var user_upload_complete_handler = this.queueSettings.user_upload_complete_handler;
    70                 var continueUpload;
    71                
    72                 if (file.filestatus === SWFUpload.FILE_STATUS.COMPLETE) {
    73                         this.queueSettings.queue_upload_count++;
    74                 }
    75 
    76                 if (typeof(user_upload_complete_handler) === "function") {
    77                         continueUpload = (user_upload_complete_handler.call(this, file) === false) ? false : true;
    78                 } else if (file.filestatus === SWFUpload.FILE_STATUS.QUEUED) {
    79                         // If the file was stopped and re-queued don't restart the upload
    80                         continueUpload = false;
    81                 } else {
    82                         continueUpload = true;
    83                 }
    84                
    85                 if (continueUpload) {
    86                         var stats = this.getStats();
    87                         if (stats.files_queued > 0 && this.queueSettings.queue_cancelled_flag === false) {
    88                                 this.startUpload();
    89                         } else if (this.queueSettings.queue_cancelled_flag === false) {
    90                                 this.queueEvent("queue_complete_handler", [this.queueSettings.queue_upload_count]);
    91                                 this.queueSettings.queue_upload_count = 0;
    92                         } else {
    93                                 this.queueSettings.queue_cancelled_flag = false;
    94                                 this.queueSettings.queue_upload_count = 0;
    95                         }
    96                 }
    97         };
    98 }
  • src/wp-includes/js/swfupload/plugins/swfupload.speed.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.queue.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    1 /*
    2         Speed Plug-in
    3        
    4         Features:
    5                 *Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.
    6                         - currentSpeed -- String indicating the upload speed, bytes per second
    7                         - averageSpeed -- Overall average upload speed, bytes per second
    8                         - movingAverageSpeed -- Speed over averaged over the last several measurements, bytes per second
    9                         - timeRemaining -- Estimated remaining upload time in seconds
    10                         - timeElapsed -- Number of seconds passed for this upload
    11                         - percentUploaded -- Percentage of the file uploaded (0 to 100)
    12                         - sizeUploaded -- Formatted size uploaded so far, bytes
    13                
    14                 *Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.
    15                
    16                 *Adds several Formatting functions for formatting that values provided on the file object.
    17                         - SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)
    18                         - SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)
    19                         - SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )
    20                         - SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)
    21                         - SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)
    22                                 - Formats a number using the division array to determine how to apply the labels in the Label Array
    23                                 - factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)
    24                                     or as several numbers labeled with units (time)
    25         */
    26 
    27 var SWFUpload;
    28 if (typeof(SWFUpload) === "function") {
    29         SWFUpload.speed = {};
    30        
    31         SWFUpload.prototype.initSettings = (function (oldInitSettings) {
    32                 return function () {
    33                         if (typeof(oldInitSettings) === "function") {
    34                                 oldInitSettings.call(this);
    35                         }
    36                        
    37                         this.ensureDefault = function (settingName, defaultValue) {
    38                                 this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
    39                         };
    40 
    41                         // List used to keep the speed stats for the files we are tracking
    42                         this.fileSpeedStats = {};
    43                         this.speedSettings = {};
    44 
    45                         this.ensureDefault("moving_average_history_size", "10");
    46                        
    47                         this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;
    48                         this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;
    49                         this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;
    50                         this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;
    51                         this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;
    52                         this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;
    53                         this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
    54                        
    55                         this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;
    56                         this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;
    57                         this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;
    58                         this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;
    59                         this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;
    60                         this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;
    61                         this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;
    62                        
    63                         delete this.ensureDefault;
    64                 };
    65         })(SWFUpload.prototype.initSettings);
    66 
    67        
    68         SWFUpload.speed.fileQueuedHandler = function (file) {
    69                 if (typeof this.speedSettings.user_file_queued_handler === "function") {
    70                         file = SWFUpload.speed.extendFile(file);
    71                        
    72                         return this.speedSettings.user_file_queued_handler.call(this, file);
    73                 }
    74         };
    75        
    76         SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {
    77                 if (typeof this.speedSettings.user_file_queue_error_handler === "function") {
    78                         file = SWFUpload.speed.extendFile(file);
    79                        
    80                         return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);
    81                 }
    82         };
    83 
    84         SWFUpload.speed.uploadStartHandler = function (file) {
    85                 if (typeof this.speedSettings.user_upload_start_handler === "function") {
    86                         file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    87                         return this.speedSettings.user_upload_start_handler.call(this, file);
    88                 }
    89         };
    90        
    91         SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {
    92                 file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    93                 SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
    94 
    95                 if (typeof this.speedSettings.user_upload_error_handler === "function") {
    96                         return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);
    97                 }
    98         };
    99         SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {
    100                 this.updateTracking(file, bytesComplete);
    101                 file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    102 
    103                 if (typeof this.speedSettings.user_upload_progress_handler === "function") {
    104                         return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);
    105                 }
    106         };
    107        
    108         SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {
    109                 if (typeof this.speedSettings.user_upload_success_handler === "function") {
    110                         file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    111                         return this.speedSettings.user_upload_success_handler.call(this, file, serverData);
    112                 }
    113         };
    114         SWFUpload.speed.uploadCompleteHandler = function (file) {
    115                 file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
    116                 SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
    117 
    118                 if (typeof this.speedSettings.user_upload_complete_handler === "function") {
    119                         return this.speedSettings.user_upload_complete_handler.call(this, file);
    120                 }
    121         };
    122        
    123         // Private: extends the file object with the speed plugin values
    124         SWFUpload.speed.extendFile = function (file, trackingList) {
    125                 var tracking;
    126                
    127                 if (trackingList) {
    128                         tracking = trackingList[file.id];
    129                 }
    130                
    131                 if (tracking) {
    132                         file.currentSpeed = tracking.currentSpeed;
    133                         file.averageSpeed = tracking.averageSpeed;
    134                         file.movingAverageSpeed = tracking.movingAverageSpeed;
    135                         file.timeRemaining = tracking.timeRemaining;
    136                         file.timeElapsed = tracking.timeElapsed;
    137                         file.percentUploaded = tracking.percentUploaded;
    138                         file.sizeUploaded = tracking.bytesUploaded;
    139 
    140                 } else {
    141                         file.currentSpeed = 0;
    142                         file.averageSpeed = 0;
    143                         file.movingAverageSpeed = 0;
    144                         file.timeRemaining = 0;
    145                         file.timeElapsed = 0;
    146                         file.percentUploaded = 0;
    147                         file.sizeUploaded = 0;
    148                 }
    149                
    150                 return file;
    151         };
    152        
    153         // Private: Updates the speed tracking object, or creates it if necessary
    154         SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {
    155                 var tracking = this.fileSpeedStats[file.id];
    156                 if (!tracking) {
    157                         this.fileSpeedStats[file.id] = tracking = {};
    158                 }
    159                
    160                 // Sanity check inputs
    161                 bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;
    162                 if (bytesUploaded < 0) {
    163                         bytesUploaded = 0;
    164                 }
    165                 if (bytesUploaded > file.size) {
    166                         bytesUploaded = file.size;
    167                 }
    168                
    169                 var tickTime = (new Date()).getTime();
    170                 if (!tracking.startTime) {
    171                         tracking.startTime = (new Date()).getTime();
    172                         tracking.lastTime = tracking.startTime;
    173                         tracking.currentSpeed = 0;
    174                         tracking.averageSpeed = 0;
    175                         tracking.movingAverageSpeed = 0;
    176                         tracking.movingAverageHistory = [];
    177                         tracking.timeRemaining = 0;
    178                         tracking.timeElapsed = 0;
    179                         tracking.percentUploaded = bytesUploaded / file.size;
    180                         tracking.bytesUploaded = bytesUploaded;
    181                 } else if (tracking.startTime > tickTime) {
    182                         this.debug("When backwards in time");
    183                 } else {
    184                         // Get time and deltas
    185                         var now = (new Date()).getTime();
    186                         var lastTime = tracking.lastTime;
    187                         var deltaTime = now - lastTime;
    188                         var deltaBytes = bytesUploaded - tracking.bytesUploaded;
    189                        
    190                         if (deltaBytes === 0 || deltaTime === 0) {
    191                                 return tracking;
    192                         }
    193                        
    194                         // Update tracking object
    195                         tracking.lastTime = now;
    196                         tracking.bytesUploaded = bytesUploaded;
    197                        
    198                         // Calculate speeds
    199                         tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);
    200                         tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);
    201 
    202                         // Calculate moving average
    203                         tracking.movingAverageHistory.push(tracking.currentSpeed);
    204                         if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {
    205                                 tracking.movingAverageHistory.shift();
    206                         }
    207                        
    208                         tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);
    209                        
    210                         // Update times
    211                         tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;
    212                         tracking.timeElapsed = (now - tracking.startTime) / 1000;
    213                        
    214                         // Update percent
    215                         tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);
    216                 }
    217                
    218                 return tracking;
    219         };
    220         SWFUpload.speed.removeTracking = function (file, trackingList) {
    221                 try {
    222                         trackingList[file.id] = null;
    223                         delete trackingList[file.id];
    224                 } catch (ex) {
    225                 }
    226         };
    227        
    228         SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {
    229                 var i, unit, unitDivisor, unitLabel;
    230 
    231                 if (baseNumber === 0) {
    232                         return "0 " + unitLabels[unitLabels.length - 1];
    233                 }
    234                
    235                 if (singleFractional) {
    236                         unit = baseNumber;
    237                         unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";
    238                         for (i = 0; i < unitDivisors.length; i++) {
    239                                 if (baseNumber >= unitDivisors[i]) {
    240                                         unit = (baseNumber / unitDivisors[i]).toFixed(2);
    241                                         unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";
    242                                         break;
    243                                 }
    244                         }
    245                        
    246                         return unit + unitLabel;
    247                 } else {
    248                         var formattedStrings = [];
    249                         var remainder = baseNumber;
    250                        
    251                         for (i = 0; i < unitDivisors.length; i++) {
    252                                 unitDivisor = unitDivisors[i];
    253                                 unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";
    254                                
    255                                 unit = remainder / unitDivisor;
    256                                 if (i < unitDivisors.length -1) {
    257                                         unit = Math.floor(unit);
    258                                 } else {
    259                                         unit = unit.toFixed(2);
    260                                 }
    261                                 if (unit > 0) {
    262                                         remainder = remainder % unitDivisor;
    263                                        
    264                                         formattedStrings.push(unit + unitLabel);
    265                                 }
    266                         }
    267                        
    268                         return formattedStrings.join(" ");
    269                 }
    270         };
    271        
    272         SWFUpload.speed.formatBPS = function (baseNumber) {
    273                 var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];
    274                 return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);
    275        
    276         };
    277         SWFUpload.speed.formatTime = function (baseNumber) {
    278                 var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];
    279                 return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);
    280        
    281         };
    282         SWFUpload.speed.formatBytes = function (baseNumber) {
    283                 var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];
    284                 return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);
    285        
    286         };
    287         SWFUpload.speed.formatPercent = function (baseNumber) {
    288                 return baseNumber.toFixed(2) + " %";
    289         };
    290        
    291         SWFUpload.speed.calculateMovingAverage = function (history) {
    292                 var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;
    293                 var i;
    294                 var mSum = 0, mCount = 0;
    295                
    296                 size = history.length;
    297                
    298                 // Check for sufficient data
    299                 if (size >= 8) {
    300                         // Clone the array and Calculate sum of the values
    301                         for (i = 0; i < size; i++) {
    302                                 vals[i] = history[i];
    303                                 sum += vals[i];
    304                         }
    305 
    306                         mean = sum / size;
    307 
    308                         // Calculate variance for the set
    309                         for (i = 0; i < size; i++) {
    310                                 varianceTemp += Math.pow((vals[i] - mean), 2);
    311                         }
    312 
    313                         variance = varianceTemp / size;
    314                         standardDev = Math.sqrt(variance);
    315                        
    316                         //Standardize the Data
    317                         for (i = 0; i < size; i++) {
    318                                 vals[i] = (vals[i] - mean) / standardDev;
    319                         }
    320 
    321                         // Calculate the average excluding outliers
    322                         var deviationRange = 2.0;
    323                         for (i = 0; i < size; i++) {
    324                                
    325                                 if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {
    326                                         mCount++;
    327                                         mSum += history[i];
    328                                 }
    329                         }
    330                        
    331                 } else {
    332                         // Calculate the average (not enough data points to remove outliers)
    333                         mCount = size;
    334                         for (i = 0; i < size; i++) {
    335                                 mSum += history[i];
    336                         }
    337                 }
    338 
    339                 return mSum / mCount;
    340         };
    341        
    342 }
    343  No newline at end of file
  • src/wp-includes/js/swfupload/plugins/swfupload.swfobject.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.speed.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    1 /*
    2         SWFUpload.SWFObject Plugin
    3 
    4         Summary:
    5                 This plugin uses SWFObject to embed SWFUpload dynamically in the page.  SWFObject provides accurate Flash Player detection and DOM Ready loading.
    6                 This plugin replaces the Graceful Degradation plugin.
    7 
    8         Features:
    9                 * swfupload_load_failed_hander event
    10                 * swfupload_pre_load_handler event
    11                 * minimum_flash_version setting (default: "9.0.28")
    12                 * SWFUpload.onload event for early loading
    13 
    14         Usage:
    15                 Provide handlers and settings as needed.  When using the SWFUpload.SWFObject plugin you should initialize SWFUploading
    16                 in SWFUpload.onload rather than in window.onload.  When initialized this way SWFUpload can load earlier preventing the UI flicker
    17                 that was seen using the Graceful Degradation plugin.
    18 
    19                 <script type="text/javascript">
    20                         var swfu;
    21                         SWFUpload.onload = function () {
    22                                 swfu = new SWFUpload({
    23                                         minimum_flash_version: "9.0.28",
    24                                         swfupload_pre_load_handler: swfuploadPreLoad,
    25                                         swfupload_load_failed_handler: swfuploadLoadFailed
    26                                 });
    27                         };
    28                 </script>
    29                
    30         Notes:
    31                 You must provide set minimum_flash_version setting to "8" if you are using SWFUpload for Flash Player 8.
    32                 The swfuploadLoadFailed event is only fired if the minimum version of Flash Player is not met.  Other issues such as missing SWF files, browser bugs
    33                  or corrupt Flash Player installations will not trigger this event.
    34                 The swfuploadPreLoad event is fired as soon as the minimum version of Flash Player is found.  It does not wait for SWFUpload to load and can
    35                  be used to prepare the SWFUploadUI and hide alternate content.
    36                 swfobject's onDomReady event is cross-browser safe but will default to the window.onload event when DOMReady is not supported by the browser.
    37                  Early DOM Loading is supported in major modern browsers but cannot be guaranteed for every browser ever made.
    38 */
    39 
    40 
    41 // SWFObject v2.1 must be loaded
    42        
    43 var SWFUpload;
    44 if (typeof(SWFUpload) === "function") {
    45         SWFUpload.onload = function () {};
    46 
    47         swfobject.addDomLoadEvent(function () {
    48                 if (typeof(SWFUpload.onload) === "function") {
    49                         setTimeout(function(){SWFUpload.onload.call(window);}, 200);
    50                 }
    51         });
    52 
    53         SWFUpload.prototype.initSettings = (function (oldInitSettings) {
    54                 return function () {
    55                         if (typeof(oldInitSettings) === "function") {
    56                                 oldInitSettings.call(this);
    57                         }
    58 
    59                         this.ensureDefault = function (settingName, defaultValue) {
    60                                 this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
    61                         };
    62 
    63                         this.ensureDefault("minimum_flash_version", "9.0.28");
    64                         this.ensureDefault("swfupload_pre_load_handler", null);
    65                         this.ensureDefault("swfupload_load_failed_handler", null);
    66 
    67                         delete this.ensureDefault;
    68 
    69                 };
    70         })(SWFUpload.prototype.initSettings);
    71 
    72 
    73         SWFUpload.prototype.loadFlash = function (oldLoadFlash) {
    74                 return function () {
    75                         var hasFlash = swfobject.hasFlashPlayerVersion(this.settings.minimum_flash_version);
    76                        
    77                         if (hasFlash) {
    78                                 this.queueEvent("swfupload_pre_load_handler");
    79                                 if (typeof(oldLoadFlash) === "function") {
    80                                         oldLoadFlash.call(this);
    81                                 }
    82                         } else {
    83                                 this.queueEvent("swfupload_load_failed_handler");
    84                         }
    85                 };
    86                
    87         }(SWFUpload.prototype.loadFlash);
    88                        
    89         SWFUpload.prototype.displayDebugInfo = function (oldDisplayDebugInfo) {
    90                 return function () {
    91                         if (typeof(oldDisplayDebugInfo) === "function") {
    92                                 oldDisplayDebugInfo.call(this);
    93                         }
    94                        
    95                         this.debug(
    96                                 [
    97                                         "SWFUpload.SWFObject Plugin settings:", "\n",
    98                                         "\t", "minimum_flash_version:                      ", this.settings.minimum_flash_version, "\n",
    99                                         "\t", "swfupload_pre_load_handler assigned:     ", (typeof(this.settings.swfupload_pre_load_handler) === "function").toString(), "\n",
    100                                         "\t", "swfupload_load_failed_handler assigned:     ", (typeof(this.settings.swfupload_load_failed_handler) === "function").toString(), "\n",
    101                                 ].join("")
    102                         );
    103                 };     
    104         }(SWFUpload.prototype.displayDebugInfo);
    105 }
  • src/wp-includes/js/swfupload/swfupload.js

    Property changes on: src/wp-includes/js/swfupload/plugins/swfupload.swfobject.js
    ___________________________________________________________________
    Deleted: svn:eol-style
    ## -1 +0,0 ##
    -native
    \ No newline at end of property
     
    11/**
    2  * SWFUpload: http://www.swfupload.org, http://swfupload.googlecode.com
     2 * SWFUpload fallback
    33 *
    4  * mmSWFUpload 1.0: Flash upload dialog - http://profandesign.se/swfupload/,  http://www.vinterwebb.se/
    5  *
    6  * SWFUpload is (c) 2006-2007 Lars Huring, Olov Nilzén and Mammon Media and is released under the MIT License:
    7  * http://www.opensource.org/licenses/mit-license.php
    8  *
    9  * SWFUpload 2 is (c) 2007-2008 Jake Roberts and is released under the MIT License:
    10  * http://www.opensource.org/licenses/mit-license.php
    11  *
     4 * @since 4.9.0
    125 */
    136
    14 
    15 /* ******************* */
    16 /* Constructor & Init  */
    17 /* ******************* */
    187var SWFUpload;
    198
    20 if (SWFUpload == undefined) {
    21         SWFUpload = function (settings) {
    22                 this.initSWFUpload(settings);
    23         };
    24 }
     9( function () {
     10        function noop() {}
    2511
    26 SWFUpload.prototype.initSWFUpload = function (settings) {
    27         try {
    28                 this.customSettings = {};       // A container where developers can place their own settings associated with this instance.
    29                 this.settings = settings;
    30                 this.eventQueue = [];
    31                 this.movieName = "SWFUpload_" + SWFUpload.movieCount++;
    32                 this.movieElement = null;
    33 
    34 
    35                 // Setup global control tracking
    36                 SWFUpload.instances[this.movieName] = this;
    37 
    38                 // Load the settings.  Load the Flash movie.
    39                 this.initSettings();
    40                 this.loadFlash();
    41                 this.displayDebugInfo();
    42         } catch (ex) {
    43                 delete SWFUpload.instances[this.movieName];
    44                 throw ex;
     12        if (SWFUpload == undefined) {
     13                SWFUpload = function (settings) {
     14                        this.initSWFUpload(settings);
     15                };
    4516        }
    46 };
    4717
    48 /* *************** */
    49 /* Static Members  */
    50 /* *************** */
    51 SWFUpload.instances = {};
    52 SWFUpload.movieCount = 0;
    53 SWFUpload.version = "2.2.0 2009-03-25";
    54 SWFUpload.QUEUE_ERROR = {
    55         QUEUE_LIMIT_EXCEEDED                    : -100,
    56         FILE_EXCEEDS_SIZE_LIMIT                 : -110,
    57         ZERO_BYTE_FILE                                  : -120,
    58         INVALID_FILETYPE                                : -130
    59 };
    60 SWFUpload.UPLOAD_ERROR = {
    61         HTTP_ERROR                                              : -200,
    62         MISSING_UPLOAD_URL                      : -210,
    63         IO_ERROR                                                : -220,
    64         SECURITY_ERROR                                  : -230,
    65         UPLOAD_LIMIT_EXCEEDED                   : -240,
    66         UPLOAD_FAILED                                   : -250,
    67         SPECIFIED_FILE_ID_NOT_FOUND             : -260,
    68         FILE_VALIDATION_FAILED                  : -270,
    69         FILE_CANCELLED                                  : -280,
    70         UPLOAD_STOPPED                                  : -290
    71 };
    72 SWFUpload.FILE_STATUS = {
    73         QUEUED           : -1,
    74         IN_PROGRESS      : -2,
    75         ERROR            : -3,
    76         COMPLETE         : -4,
    77         CANCELLED        : -5
    78 };
    79 SWFUpload.BUTTON_ACTION = {
    80         SELECT_FILE  : -100,
    81         SELECT_FILES : -110,
    82         START_UPLOAD : -120
    83 };
    84 SWFUpload.CURSOR = {
    85         ARROW : -1,
    86         HAND : -2
    87 };
    88 SWFUpload.WINDOW_MODE = {
    89         WINDOW : "window",
    90         TRANSPARENT : "transparent",
    91         OPAQUE : "opaque"
    92 };
     18        SWFUpload.prototype.initSWFUpload = function ( settings ) {
     19                function fallback() {
     20                        var $ = window.jQuery;
     21                        var $placeholder = settings.button_placeholder_id ? $( '#' + settings.button_placeholder_id ) : $( settings.button_placeholder );
    9322
    94 // Private: takes a URL, determines if it is relative and converts to an absolute URL
    95 // using the current site. Only processes the URL if it can, otherwise returns the URL untouched
    96 SWFUpload.completeURL = function(url) {
    97         if (typeof(url) !== "string" || url.match(/^https?:\/\//i) || url.match(/^\//)) {
    98                 return url;
    99         }
    100        
    101         var currentURL = window.location.protocol + "//" + window.location.hostname + (window.location.port ? ":" + window.location.port : "");
    102        
    103         var indexSlash = window.location.pathname.lastIndexOf("/");
    104         if (indexSlash <= 0) {
    105                 path = "/";
    106         } else {
    107                 path = window.location.pathname.substr(0, indexSlash) + "/";
    108         }
    109        
    110         return /*currentURL +*/ path + url;
    111        
    112 };
    113 
    114 
    115 /* ******************** */
    116 /* Instance Members  */
    117 /* ******************** */
    118 
    119 // Private: initSettings ensures that all the
    120 // settings are set, getting a default value if one was not assigned.
    121 SWFUpload.prototype.initSettings = function () {
    122         this.ensureDefault = function (settingName, defaultValue) {
    123                 this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
    124         };
    125        
    126         // Upload backend settings
    127         this.ensureDefault("upload_url", "");
    128         this.ensureDefault("preserve_relative_urls", false);
    129         this.ensureDefault("file_post_name", "Filedata");
    130         this.ensureDefault("post_params", {});
    131         this.ensureDefault("use_query_string", false);
    132         this.ensureDefault("requeue_on_error", false);
    133         this.ensureDefault("http_success", []);
    134         this.ensureDefault("assume_success_timeout", 0);
    135        
    136         // File Settings
    137         this.ensureDefault("file_types", "*.*");
    138         this.ensureDefault("file_types_description", "All Files");
    139         this.ensureDefault("file_size_limit", 0);       // Default zero means "unlimited"
    140         this.ensureDefault("file_upload_limit", 0);
    141         this.ensureDefault("file_queue_limit", 0);
    142 
    143         // Flash Settings
    144         this.ensureDefault("flash_url", "swfupload.swf");
    145         this.ensureDefault("prevent_swf_caching", true);
    146        
    147         // Button Settings
    148         this.ensureDefault("button_image_url", "");
    149         this.ensureDefault("button_width", 1);
    150         this.ensureDefault("button_height", 1);
    151         this.ensureDefault("button_text", "");
    152         this.ensureDefault("button_text_style", "color: #000000; font-size: 16pt;");
    153         this.ensureDefault("button_text_top_padding", 0);
    154         this.ensureDefault("button_text_left_padding", 0);
    155         this.ensureDefault("button_action", SWFUpload.BUTTON_ACTION.SELECT_FILES);
    156         this.ensureDefault("button_disabled", false);
    157         this.ensureDefault("button_placeholder_id", "");
    158         this.ensureDefault("button_placeholder", null);
    159         this.ensureDefault("button_cursor", SWFUpload.CURSOR.ARROW);
    160         this.ensureDefault("button_window_mode", SWFUpload.WINDOW_MODE.WINDOW);
    161        
    162         // Debug Settings
    163         this.ensureDefault("debug", false);
    164         this.settings.debug_enabled = this.settings.debug;      // Here to maintain v2 API
    165        
    166         // Event Handlers
    167         this.settings.return_upload_start_handler = this.returnUploadStart;
    168         this.ensureDefault("swfupload_loaded_handler", null);
    169         this.ensureDefault("file_dialog_start_handler", null);
    170         this.ensureDefault("file_queued_handler", null);
    171         this.ensureDefault("file_queue_error_handler", null);
    172         this.ensureDefault("file_dialog_complete_handler", null);
    173        
    174         this.ensureDefault("upload_start_handler", null);
    175         this.ensureDefault("upload_progress_handler", null);
    176         this.ensureDefault("upload_error_handler", null);
    177         this.ensureDefault("upload_success_handler", null);
    178         this.ensureDefault("upload_complete_handler", null);
    179        
    180         this.ensureDefault("debug_handler", this.debugMessage);
    181 
    182         this.ensureDefault("custom_settings", {});
    183 
    184         // Other settings
    185         this.customSettings = this.settings.custom_settings;
    186        
    187         // Update the flash url if needed
    188         if (!!this.settings.prevent_swf_caching) {
    189                 this.settings.flash_url = this.settings.flash_url + (this.settings.flash_url.indexOf("?") < 0 ? "?" : "&") + "preventswfcaching=" + new Date().getTime();
    190         }
    191        
    192         if (!this.settings.preserve_relative_urls) {
    193                 //this.settings.flash_url = SWFUpload.completeURL(this.settings.flash_url);     // Don't need to do this one since flash doesn't look at it
    194                 this.settings.upload_url = SWFUpload.completeURL(this.settings.upload_url);
    195                 this.settings.button_image_url = SWFUpload.completeURL(this.settings.button_image_url);
    196         }
    197        
    198         delete this.ensureDefault;
    199 };
    200 
    201 // Private: loadFlash replaces the button_placeholder element with the flash movie.
    202 SWFUpload.prototype.loadFlash = function () {
    203         var targetElement, tempParent;
    204 
    205         // Make sure an element with the ID we are going to use doesn't already exist
    206         if (document.getElementById(this.movieName) !== null) {
    207                 throw "ID " + this.movieName + " is already in use. The Flash Object could not be added";
    208         }
    209 
    210         // Get the element where we will be placing the flash movie
    211         targetElement = document.getElementById(this.settings.button_placeholder_id) || this.settings.button_placeholder;
    212 
    213         if (targetElement == undefined) {
    214                 throw "Could not find the placeholder element: " + this.settings.button_placeholder_id;
    215         }
    216 
    217         // Append the container and load the flash
    218         tempParent = document.createElement("div");
    219         tempParent.innerHTML = this.getFlashHTML();     // Using innerHTML is non-standard but the only sensible way to dynamically add Flash in IE (and maybe other browsers)
    220         targetElement.parentNode.replaceChild(tempParent.firstChild, targetElement);
    221 
    222         // Fix IE Flash/Form bug
    223         if (window[this.movieName] == undefined) {
    224                 window[this.movieName] = this.getMovieElement();
    225         }
    226        
    227 };
    228 
    229 // Private: getFlashHTML generates the object tag needed to embed the flash in to the document
    230 SWFUpload.prototype.getFlashHTML = function () {
    231         // Flash Satay object syntax: http://www.alistapart.com/articles/flashsatay
    232         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">',
    233                                 '<param name="wmode" value="', this.settings.button_window_mode, '" />',
    234                                 '<param name="movie" value="', this.settings.flash_url, '" />',
    235                                 '<param name="quality" value="high" />',
    236                                 '<param name="menu" value="false" />',
    237                                 '<param name="allowScriptAccess" value="always" />',
    238                                 '<param name="flashvars" value="' + this.getFlashVars() + '" />',
    239                                 '</object>'].join("");
    240 };
    241 
    242 // Private: getFlashVars builds the parameter string that will be passed
    243 // to flash in the flashvars param.
    244 SWFUpload.prototype.getFlashVars = function () {
    245         // Build a string from the post param object
    246         var paramString = this.buildParamString();
    247         var httpSuccessString = this.settings.http_success.join(",");
    248        
    249         // Build the parameter string
    250         return ["movieName=", encodeURIComponent(this.movieName),
    251                         "&amp;uploadURL=", encodeURIComponent(this.settings.upload_url),
    252                         "&amp;useQueryString=", encodeURIComponent(this.settings.use_query_string),
    253                         "&amp;requeueOnError=", encodeURIComponent(this.settings.requeue_on_error),
    254                         "&amp;httpSuccess=", encodeURIComponent(httpSuccessString),
    255                         "&amp;assumeSuccessTimeout=", encodeURIComponent(this.settings.assume_success_timeout),
    256                         "&amp;params=", encodeURIComponent(paramString),
    257                         "&amp;filePostName=", encodeURIComponent(this.settings.file_post_name),
    258                         "&amp;fileTypes=", encodeURIComponent(this.settings.file_types),
    259                         "&amp;fileTypesDescription=", encodeURIComponent(this.settings.file_types_description),
    260                         "&amp;fileSizeLimit=", encodeURIComponent(this.settings.file_size_limit),
    261                         "&amp;fileUploadLimit=", encodeURIComponent(this.settings.file_upload_limit),
    262                         "&amp;fileQueueLimit=", encodeURIComponent(this.settings.file_queue_limit),
    263                         "&amp;debugEnabled=", encodeURIComponent(this.settings.debug_enabled),
    264                         "&amp;buttonImageURL=", encodeURIComponent(this.settings.button_image_url),
    265                         "&amp;buttonWidth=", encodeURIComponent(this.settings.button_width),
    266                         "&amp;buttonHeight=", encodeURIComponent(this.settings.button_height),
    267                         "&amp;buttonText=", encodeURIComponent(this.settings.button_text),
    268                         "&amp;buttonTextTopPadding=", encodeURIComponent(this.settings.button_text_top_padding),
    269                         "&amp;buttonTextLeftPadding=", encodeURIComponent(this.settings.button_text_left_padding),
    270                         "&amp;buttonTextStyle=", encodeURIComponent(this.settings.button_text_style),
    271                         "&amp;buttonAction=", encodeURIComponent(this.settings.button_action),
    272                         "&amp;buttonDisabled=", encodeURIComponent(this.settings.button_disabled),
    273                         "&amp;buttonCursor=", encodeURIComponent(this.settings.button_cursor)
    274                 ].join("");
    275 };
    276 
    277 // Public: getMovieElement retrieves the DOM reference to the Flash element added by SWFUpload
    278 // The element is cached after the first lookup
    279 SWFUpload.prototype.getMovieElement = function () {
    280         if (this.movieElement == undefined) {
    281                 this.movieElement = document.getElementById(this.movieName);
    282         }
    283 
    284         if (this.movieElement === null) {
    285                 throw "Could not find Flash element";
    286         }
    287        
    288         return this.movieElement;
    289 };
    290 
    291 // Private: buildParamString takes the name/value pairs in the post_params setting object
    292 // and joins them up in to a string formatted "name=value&amp;name=value"
    293 SWFUpload.prototype.buildParamString = function () {
    294         var postParams = this.settings.post_params;
    295         var paramStringPairs = [];
    296 
    297         if (typeof(postParams) === "object") {
    298                 for (var name in postParams) {
    299                         if (postParams.hasOwnProperty(name)) {
    300                                 paramStringPairs.push(encodeURIComponent(name.toString()) + "=" + encodeURIComponent(postParams[name].toString()));
     23                        if ( ! $placeholder.length ) {
     24                                return;
    30125                        }
    302                 }
    303         }
    30426
    305         return paramStringPairs.join("&amp;");
    306 };
     27                        var $form = $placeholder.closest( 'form' );
    30728
    308 // Public: Used to remove a SWFUpload instance from the page. This method strives to remove
    309 // all references to the SWF, and other objects so memory is properly freed.
    310 // Returns true if everything was destroyed. Returns a false if a failure occurs leaving SWFUpload in an inconsistant state.
    311 // Credits: Major improvements provided by steffen
    312 SWFUpload.prototype.destroy = function () {
    313         try {
    314                 // Make sure Flash is done before we try to remove it
    315                 this.cancelUpload(null, false);
    316                
    317 
    318                 // Remove the SWFUpload DOM nodes
    319                 var movieElement = null;
    320                 movieElement = this.getMovieElement();
    321                
    322                 if (movieElement && typeof(movieElement.CallFunction) === "unknown") { // We only want to do this in IE
    323                         // Loop through all the movie's properties and remove all function references (DOM/JS IE 6/7 memory leak workaround)
    324                         for (var i in movieElement) {
    325                                 try {
    326                                         if (typeof(movieElement[i]) === "function") {
    327                                                 movieElement[i] = null;
    328                                         }
    329                                 } catch (ex1) {}
     29                        if ( ! $form.length ) {
     30                                $form = $( '<form enctype="multipart/form-data" method="post">' );
     31                                $form.attr( 'action', settings.upload_url );
     32                                $form.insertAfter( $placeholder ).append( $placeholder );
    33033                        }
    33134
    332                         // Remove the Movie Element from the page
    333                         try {
    334                                 movieElement.parentNode.removeChild(movieElement);
    335                         } catch (ex) {}
     35                        $placeholder.replaceWith(
     36                                $( '<div>' )
     37                                        .append(
     38                                                $( '<input type="file" multiple />' ).attr({
     39                                                        name: settings.file_post_name || 'async-upload',
     40                                                        accepts: settings.file_types || '*.*'
     41                                                })
     42                                        ).append(
     43                                                $( '<input type="submit" name="html-upload" class="button" value="Upload" />' )
     44                                        )
     45                        );
    33646                }
    337                
    338                 // Remove IE form fix reference
    339                 window[this.movieName] = null;
    34047
    341                 // Destroy other references
    342                 SWFUpload.instances[this.movieName] = null;
    343                 delete SWFUpload.instances[this.movieName];
     48                try {
     49                        // Try the built-in fallback.
     50                        if ( typeof settings.swfupload_load_failed_handler === 'function' && settings.custom_settings ) {
    34451
    345                 this.movieElement = null;
    346                 this.settings = null;
    347                 this.customSettings = null;
    348                 this.eventQueue = null;
    349                 this.movieName = null;
    350                
    351                
    352                 return true;
    353         } catch (ex2) {
    354                 return false;
    355         }
    356 };
     52                                window.swfu = {
     53                                        customSettings: settings.custom_settings
     54                                };
    35755
    358 
    359 // Public: displayDebugInfo prints out settings and configuration
    360 // information about this SWFUpload instance.
    361 // This function (and any references to it) can be deleted when placing
    362 // SWFUpload in production.
    363 SWFUpload.prototype.displayDebugInfo = function () {
    364         this.debug(
    365                 [
    366                         "---SWFUpload Instance Info---\n",
    367                         "Version: ", SWFUpload.version, "\n",
    368                         "Movie Name: ", this.movieName, "\n",
    369                         "Settings:\n",
    370                         "\t", "upload_url:               ", this.settings.upload_url, "\n",
    371                         "\t", "flash_url:                ", this.settings.flash_url, "\n",
    372                         "\t", "use_query_string:         ", this.settings.use_query_string.toString(), "\n",
    373                         "\t", "requeue_on_error:         ", this.settings.requeue_on_error.toString(), "\n",
    374                         "\t", "http_success:             ", this.settings.http_success.join(", "), "\n",
    375                         "\t", "assume_success_timeout:   ", this.settings.assume_success_timeout, "\n",
    376                         "\t", "file_post_name:           ", this.settings.file_post_name, "\n",
    377                         "\t", "post_params:              ", this.settings.post_params.toString(), "\n",
    378                         "\t", "file_types:               ", this.settings.file_types, "\n",
    379                         "\t", "file_types_description:   ", this.settings.file_types_description, "\n",
    380                         "\t", "file_size_limit:          ", this.settings.file_size_limit, "\n",
    381                         "\t", "file_upload_limit:        ", this.settings.file_upload_limit, "\n",
    382                         "\t", "file_queue_limit:         ", this.settings.file_queue_limit, "\n",
    383                         "\t", "debug:                    ", this.settings.debug.toString(), "\n",
    384 
    385                         "\t", "prevent_swf_caching:      ", this.settings.prevent_swf_caching.toString(), "\n",
    386 
    387                         "\t", "button_placeholder_id:    ", this.settings.button_placeholder_id.toString(), "\n",
    388                         "\t", "button_placeholder:       ", (this.settings.button_placeholder ? "Set" : "Not Set"), "\n",
    389                         "\t", "button_image_url:         ", this.settings.button_image_url.toString(), "\n",
    390                         "\t", "button_width:             ", this.settings.button_width.toString(), "\n",
    391                         "\t", "button_height:            ", this.settings.button_height.toString(), "\n",
    392                         "\t", "button_text:              ", this.settings.button_text.toString(), "\n",
    393                         "\t", "button_text_style:        ", this.settings.button_text_style.toString(), "\n",
    394                         "\t", "button_text_top_padding:  ", this.settings.button_text_top_padding.toString(), "\n",
    395                         "\t", "button_text_left_padding: ", this.settings.button_text_left_padding.toString(), "\n",
    396                         "\t", "button_action:            ", this.settings.button_action.toString(), "\n",
    397                         "\t", "button_disabled:          ", this.settings.button_disabled.toString(), "\n",
    398 
    399                         "\t", "custom_settings:          ", this.settings.custom_settings.toString(), "\n",
    400                         "Event Handlers:\n",
    401                         "\t", "swfupload_loaded_handler assigned:  ", (typeof this.settings.swfupload_loaded_handler === "function").toString(), "\n",
    402                         "\t", "file_dialog_start_handler assigned: ", (typeof this.settings.file_dialog_start_handler === "function").toString(), "\n",
    403                         "\t", "file_queued_handler assigned:       ", (typeof this.settings.file_queued_handler === "function").toString(), "\n",
    404                         "\t", "file_queue_error_handler assigned:  ", (typeof this.settings.file_queue_error_handler === "function").toString(), "\n",
    405                         "\t", "upload_start_handler assigned:      ", (typeof this.settings.upload_start_handler === "function").toString(), "\n",
    406                         "\t", "upload_progress_handler assigned:   ", (typeof this.settings.upload_progress_handler === "function").toString(), "\n",
    407                         "\t", "upload_error_handler assigned:      ", (typeof this.settings.upload_error_handler === "function").toString(), "\n",
    408                         "\t", "upload_success_handler assigned:    ", (typeof this.settings.upload_success_handler === "function").toString(), "\n",
    409                         "\t", "upload_complete_handler assigned:   ", (typeof this.settings.upload_complete_handler === "function").toString(), "\n",
    410                         "\t", "debug_handler assigned:             ", (typeof this.settings.debug_handler === "function").toString(), "\n"
    411                 ].join("")
    412         );
    413 };
    414 
    415 /* Note: addSetting and getSetting are no longer used by SWFUpload but are included
    416         the maintain v2 API compatibility
    417 */
    418 // Public: (Deprecated) addSetting adds a setting value. If the value given is undefined or null then the default_value is used.
    419 SWFUpload.prototype.addSetting = function (name, value, default_value) {
    420     if (value == undefined) {
    421         return (this.settings[name] = default_value);
    422     } else {
    423         return (this.settings[name] = value);
    424         }
    425 };
    426 
    427 // Public: (Deprecated) getSetting gets a setting. Returns an empty string if the setting was not found.
    428 SWFUpload.prototype.getSetting = function (name) {
    429     if (this.settings[name] != undefined) {
    430         return this.settings[name];
    431         }
    432 
    433     return "";
    434 };
    435 
    436 
    437 
    438 // Private: callFlash handles function calls made to the Flash element.
    439 // Calls are made with a setTimeout for some functions to work around
    440 // bugs in the ExternalInterface library.
    441 SWFUpload.prototype.callFlash = function (functionName, argumentArray) {
    442         argumentArray = argumentArray || [];
    443        
    444         var movieElement = this.getMovieElement();
    445         var returnValue, returnString;
    446 
    447         // Flash's method if calling ExternalInterface methods (code adapted from MooTools).
    448         try {
    449                 returnString = movieElement.CallFunction('<invoke name="' + functionName + '" returntype="javascript">' + __flash__argumentsToXML(argumentArray, 0) + '</invoke>');
    450                 returnValue = eval(returnString);
    451         } catch (ex) {
    452                 throw "Call to " + functionName + " failed";
    453         }
    454        
    455         // Unescape file post param values
    456         if (returnValue != undefined && typeof returnValue.post === "object") {
    457                 returnValue = this.unescapeFilePostParams(returnValue);
    458         }
    459 
    460         return returnValue;
    461 };
    462 
    463 /* *****************************
    464         -- Flash control methods --
    465         Your UI should use these
    466         to operate SWFUpload
    467    ***************************** */
    468 
    469 // WARNING: this function does not work in Flash Player 10
    470 // Public: selectFile causes a File Selection Dialog window to appear.  This
    471 // dialog only allows 1 file to be selected.
    472 SWFUpload.prototype.selectFile = function () {
    473         this.callFlash("SelectFile");
    474 };
    475 
    476 // WARNING: this function does not work in Flash Player 10
    477 // Public: selectFiles causes a File Selection Dialog window to appear/ This
    478 // dialog allows the user to select any number of files
    479 // Flash Bug Warning: Flash limits the number of selectable files based on the combined length of the file names.
    480 // If the selection name length is too long the dialog will fail in an unpredictable manner.  There is no work-around
    481 // for this bug.
    482 SWFUpload.prototype.selectFiles = function () {
    483         this.callFlash("SelectFiles");
    484 };
    485 
    486 
    487 // Public: startUpload starts uploading the first file in the queue unless
    488 // the optional parameter 'fileID' specifies the ID
    489 SWFUpload.prototype.startUpload = function (fileID) {
    490         this.callFlash("StartUpload", [fileID]);
    491 };
    492 
    493 // Public: cancelUpload cancels any queued file.  The fileID parameter may be the file ID or index.
    494 // If you do not specify a fileID the current uploading file or first file in the queue is cancelled.
    495 // If you do not want the uploadError event to trigger you can specify false for the triggerErrorEvent parameter.
    496 SWFUpload.prototype.cancelUpload = function (fileID, triggerErrorEvent) {
    497         if (triggerErrorEvent !== false) {
    498                 triggerErrorEvent = true;
    499         }
    500         this.callFlash("CancelUpload", [fileID, triggerErrorEvent]);
    501 };
    502 
    503 // Public: stopUpload stops the current upload and requeues the file at the beginning of the queue.
    504 // If nothing is currently uploading then nothing happens.
    505 SWFUpload.prototype.stopUpload = function () {
    506         this.callFlash("StopUpload");
    507 };
    508 
    509 /* ************************
    510  * Settings methods
    511  *   These methods change the SWFUpload settings.
    512  *   SWFUpload settings should not be changed directly on the settings object
    513  *   since many of the settings need to be passed to Flash in order to take
    514  *   effect.
    515  * *********************** */
    516 
    517 // Public: getStats gets the file statistics object.
    518 SWFUpload.prototype.getStats = function () {
    519         return this.callFlash("GetStats");
    520 };
    521 
    522 // Public: setStats changes the SWFUpload statistics.  You shouldn't need to
    523 // change the statistics but you can.  Changing the statistics does not
    524 // affect SWFUpload accept for the successful_uploads count which is used
    525 // by the upload_limit setting to determine how many files the user may upload.
    526 SWFUpload.prototype.setStats = function (statsObject) {
    527         this.callFlash("SetStats", [statsObject]);
    528 };
    529 
    530 // Public: getFile retrieves a File object by ID or Index.  If the file is
    531 // not found then 'null' is returned.
    532 SWFUpload.prototype.getFile = function (fileID) {
    533         if (typeof(fileID) === "number") {
    534                 return this.callFlash("GetFileByIndex", [fileID]);
    535         } else {
    536                 return this.callFlash("GetFile", [fileID]);
    537         }
    538 };
    539 
    540 // Public: addFileParam sets a name/value pair that will be posted with the
    541 // file specified by the Files ID.  If the name already exists then the
    542 // exiting value will be overwritten.
    543 SWFUpload.prototype.addFileParam = function (fileID, name, value) {
    544         return this.callFlash("AddFileParam", [fileID, name, value]);
    545 };
    546 
    547 // Public: removeFileParam removes a previously set (by addFileParam) name/value
    548 // pair from the specified file.
    549 SWFUpload.prototype.removeFileParam = function (fileID, name) {
    550         this.callFlash("RemoveFileParam", [fileID, name]);
    551 };
    552 
    553 // Public: setUploadUrl changes the upload_url setting.
    554 SWFUpload.prototype.setUploadURL = function (url) {
    555         this.settings.upload_url = url.toString();
    556         this.callFlash("SetUploadURL", [url]);
    557 };
    558 
    559 // Public: setPostParams changes the post_params setting
    560 SWFUpload.prototype.setPostParams = function (paramsObject) {
    561         this.settings.post_params = paramsObject;
    562         this.callFlash("SetPostParams", [paramsObject]);
    563 };
    564 
    565 // Public: addPostParam adds post name/value pair.  Each name can have only one value.
    566 SWFUpload.prototype.addPostParam = function (name, value) {
    567         this.settings.post_params[name] = value;
    568         this.callFlash("SetPostParams", [this.settings.post_params]);
    569 };
    570 
    571 // Public: removePostParam deletes post name/value pair.
    572 SWFUpload.prototype.removePostParam = function (name) {
    573         delete this.settings.post_params[name];
    574         this.callFlash("SetPostParams", [this.settings.post_params]);
    575 };
    576 
    577 // Public: setFileTypes changes the file_types setting and the file_types_description setting
    578 SWFUpload.prototype.setFileTypes = function (types, description) {
    579         this.settings.file_types = types;
    580         this.settings.file_types_description = description;
    581         this.callFlash("SetFileTypes", [types, description]);
    582 };
    583 
    584 // Public: setFileSizeLimit changes the file_size_limit setting
    585 SWFUpload.prototype.setFileSizeLimit = function (fileSizeLimit) {
    586         this.settings.file_size_limit = fileSizeLimit;
    587         this.callFlash("SetFileSizeLimit", [fileSizeLimit]);
    588 };
    589 
    590 // Public: setFileUploadLimit changes the file_upload_limit setting
    591 SWFUpload.prototype.setFileUploadLimit = function (fileUploadLimit) {
    592         this.settings.file_upload_limit = fileUploadLimit;
    593         this.callFlash("SetFileUploadLimit", [fileUploadLimit]);
    594 };
    595 
    596 // Public: setFileQueueLimit changes the file_queue_limit setting
    597 SWFUpload.prototype.setFileQueueLimit = function (fileQueueLimit) {
    598         this.settings.file_queue_limit = fileQueueLimit;
    599         this.callFlash("SetFileQueueLimit", [fileQueueLimit]);
    600 };
    601 
    602 // Public: setFilePostName changes the file_post_name setting
    603 SWFUpload.prototype.setFilePostName = function (filePostName) {
    604         this.settings.file_post_name = filePostName;
    605         this.callFlash("SetFilePostName", [filePostName]);
    606 };
    607 
    608 // Public: setUseQueryString changes the use_query_string setting
    609 SWFUpload.prototype.setUseQueryString = function (useQueryString) {
    610         this.settings.use_query_string = useQueryString;
    611         this.callFlash("SetUseQueryString", [useQueryString]);
    612 };
    613 
    614 // Public: setRequeueOnError changes the requeue_on_error setting
    615 SWFUpload.prototype.setRequeueOnError = function (requeueOnError) {
    616         this.settings.requeue_on_error = requeueOnError;
    617         this.callFlash("SetRequeueOnError", [requeueOnError]);
    618 };
    619 
    620 // Public: setHTTPSuccess changes the http_success setting
    621 SWFUpload.prototype.setHTTPSuccess = function (http_status_codes) {
    622         if (typeof http_status_codes === "string") {
    623                 http_status_codes = http_status_codes.replace(" ", "").split(",");
    624         }
    625        
    626         this.settings.http_success = http_status_codes;
    627         this.callFlash("SetHTTPSuccess", [http_status_codes]);
    628 };
    629 
    630 // Public: setHTTPSuccess changes the http_success setting
    631 SWFUpload.prototype.setAssumeSuccessTimeout = function (timeout_seconds) {
    632         this.settings.assume_success_timeout = timeout_seconds;
    633         this.callFlash("SetAssumeSuccessTimeout", [timeout_seconds]);
    634 };
    635 
    636 // Public: setDebugEnabled changes the debug_enabled setting
    637 SWFUpload.prototype.setDebugEnabled = function (debugEnabled) {
    638         this.settings.debug_enabled = debugEnabled;
    639         this.callFlash("SetDebugEnabled", [debugEnabled]);
    640 };
    641 
    642 // Public: setButtonImageURL loads a button image sprite
    643 SWFUpload.prototype.setButtonImageURL = function (buttonImageURL) {
    644         if (buttonImageURL == undefined) {
    645                 buttonImageURL = "";
    646         }
    647        
    648         this.settings.button_image_url = buttonImageURL;
    649         this.callFlash("SetButtonImageURL", [buttonImageURL]);
    650 };
    651 
    652 // Public: setButtonDimensions resizes the Flash Movie and button
    653 SWFUpload.prototype.setButtonDimensions = function (width, height) {
    654         this.settings.button_width = width;
    655         this.settings.button_height = height;
    656        
    657         var movie = this.getMovieElement();
    658         if (movie != undefined) {
    659                 movie.style.width = width + "px";
    660                 movie.style.height = height + "px";
    661         }
    662        
    663         this.callFlash("SetButtonDimensions", [width, height]);
    664 };
    665 // Public: setButtonText Changes the text overlaid on the button
    666 SWFUpload.prototype.setButtonText = function (html) {
    667         this.settings.button_text = html;
    668         this.callFlash("SetButtonText", [html]);
    669 };
    670 // Public: setButtonTextPadding changes the top and left padding of the text overlay
    671 SWFUpload.prototype.setButtonTextPadding = function (left, top) {
    672         this.settings.button_text_top_padding = top;
    673         this.settings.button_text_left_padding = left;
    674         this.callFlash("SetButtonTextPadding", [left, top]);
    675 };
    676 
    677 // Public: setButtonTextStyle changes the CSS used to style the HTML/Text overlaid on the button
    678 SWFUpload.prototype.setButtonTextStyle = function (css) {
    679         this.settings.button_text_style = css;
    680         this.callFlash("SetButtonTextStyle", [css]);
    681 };
    682 // Public: setButtonDisabled disables/enables the button
    683 SWFUpload.prototype.setButtonDisabled = function (isDisabled) {
    684         this.settings.button_disabled = isDisabled;
    685         this.callFlash("SetButtonDisabled", [isDisabled]);
    686 };
    687 // Public: setButtonAction sets the action that occurs when the button is clicked
    688 SWFUpload.prototype.setButtonAction = function (buttonAction) {
    689         this.settings.button_action = buttonAction;
    690         this.callFlash("SetButtonAction", [buttonAction]);
    691 };
    692 
    693 // Public: setButtonCursor changes the mouse cursor displayed when hovering over the button
    694 SWFUpload.prototype.setButtonCursor = function (cursor) {
    695         this.settings.button_cursor = cursor;
    696         this.callFlash("SetButtonCursor", [cursor]);
    697 };
    698 
    699 /* *******************************
    700         Flash Event Interfaces
    701         These functions are used by Flash to trigger the various
    702         events.
    703        
    704         All these functions a Private.
    705        
    706         Because the ExternalInterface library is buggy the event calls
    707         are added to a queue and the queue then executed by a setTimeout.
    708         This ensures that events are executed in a determinate order and that
    709         the ExternalInterface bugs are avoided.
    710 ******************************* */
    711 
    712 SWFUpload.prototype.queueEvent = function (handlerName, argumentArray) {
    713         // Warning: Don't call this.debug inside here or you'll create an infinite loop
    714        
    715         if (argumentArray == undefined) {
    716                 argumentArray = [];
    717         } else if (!(argumentArray instanceof Array)) {
    718                 argumentArray = [argumentArray];
    719         }
    720        
    721         var self = this;
    722         if (typeof this.settings[handlerName] === "function") {
    723                 // Queue the event
    724                 this.eventQueue.push(function () {
    725                         this.settings[handlerName].apply(this, argumentArray);
    726                 });
    727                
    728                 // Execute the next queued event
    729                 setTimeout(function () {
    730                         self.executeNextEvent();
    731                 }, 0);
    732                
    733         } else if (this.settings[handlerName] !== null) {
    734                 throw "Event handler " + handlerName + " is unknown or is not a function";
    735         }
    736 };
    737 
    738 // Private: Causes the next event in the queue to be executed.  Since events are queued using a setTimeout
    739 // we must queue them in order to garentee that they are executed in order.
    740 SWFUpload.prototype.executeNextEvent = function () {
    741         // Warning: Don't call this.debug inside here or you'll create an infinite loop
    742 
    743         var  f = this.eventQueue ? this.eventQueue.shift() : null;
    744         if (typeof(f) === "function") {
    745                 f.apply(this);
    746         }
    747 };
    748 
    749 // Private: unescapeFileParams is part of a workaround for a flash bug where objects passed through ExternalInterface cannot have
    750 // properties that contain characters that are not valid for JavaScript identifiers. To work around this
    751 // the Flash Component escapes the parameter names and we must unescape again before passing them along.
    752 SWFUpload.prototype.unescapeFilePostParams = function (file) {
    753         var reg = /[$]([0-9a-f]{4})/i;
    754         var unescapedPost = {};
    755         var uk;
    756 
    757         if (file != undefined) {
    758                 for (var k in file.post) {
    759                         if (file.post.hasOwnProperty(k)) {
    760                                 uk = k;
    761                                 var match;
    762                                 while ((match = reg.exec(uk)) !== null) {
    763                                         uk = uk.replace(match[0], String.fromCharCode(parseInt("0x" + match[1], 16)));
    764                                 }
    765                                 unescapedPost[uk] = file.post[k];
     56                                settings.swfupload_load_failed_handler();
     57                        } else {
     58                                fallback();
    76659                        }
     60                } catch ( ex ) {
     61                        fallback();
    76762                }
     63        };
    76864
    769                 file.post = unescapedPost;
    770         }
     65        SWFUpload.instances = {};
     66        SWFUpload.movieCount = 0;
     67        SWFUpload.version = "0";
     68        SWFUpload.QUEUE_ERROR = {};
     69        SWFUpload.UPLOAD_ERROR = {};
     70        SWFUpload.FILE_STATUS = {};
     71        SWFUpload.BUTTON_ACTION = {};
     72        SWFUpload.CURSOR = {};
     73        SWFUpload.WINDOW_MODE = {};
    77174
    772         return file;
    773 };
    774 
    775 // Private: Called by Flash to see if JS can call in to Flash (test if External Interface is working)
    776 SWFUpload.prototype.testExternalInterface = function () {
    777         try {
    778                 return this.callFlash("TestExternalInterface");
    779         } catch (ex) {
    780                 return false;
    781         }
    782 };
    783 
    784 // Private: This event is called by Flash when it has finished loading. Don't modify this.
    785 // Use the swfupload_loaded_handler event setting to execute custom code when SWFUpload has loaded.
    786 SWFUpload.prototype.flashReady = function () {
    787         // Check that the movie element is loaded correctly with its ExternalInterface methods defined
    788         var movieElement = this.getMovieElement();
    789 
    790         if (!movieElement) {
    791                 this.debug("Flash called back ready but the flash movie can't be found.");
    792                 return;
    793         }
    794 
    795         this.cleanUp(movieElement);
    796        
    797         this.queueEvent("swfupload_loaded_handler");
    798 };
    799 
    800 // Private: removes Flash added fuctions to the DOM node to prevent memory leaks in IE.
    801 // This function is called by Flash each time the ExternalInterface functions are created.
    802 SWFUpload.prototype.cleanUp = function (movieElement) {
    803         // Pro-actively unhook all the Flash functions
    804         try {
    805                 if (this.movieElement && typeof(movieElement.CallFunction) === "unknown") { // We only want to do this in IE
    806                         this.debug("Removing Flash functions hooks (this should only run in IE and should prevent memory leaks)");
    807                         for (var key in movieElement) {
    808                                 try {
    809                                         if (typeof(movieElement[key]) === "function") {
    810                                                 movieElement[key] = null;
    811                                         }
    812                                 } catch (ex) {
    813                                 }
    814                         }
    815                 }
    816         } catch (ex1) {
    817        
    818         }
    819 
    820         // Fix Flashes own cleanup code so if the SWFMovie was removed from the page
    821         // it doesn't display errors.
    822         window["__flash__removeCallback"] = function (instance, name) {
    823                 try {
    824                         if (instance) {
    825                                 instance[name] = null;
    826                         }
    827                 } catch (flashEx) {
    828                
    829                 }
     75        SWFUpload.completeURL = noop;
     76        SWFUpload.prototype.initSettings = noop;
     77        SWFUpload.prototype.loadFlash = noop;
     78        SWFUpload.prototype.getFlashHTML = noop;
     79        SWFUpload.prototype.getFlashVars = noop;
     80        SWFUpload.prototype.getMovieElement = noop;
     81        SWFUpload.prototype.buildParamString = noop;
     82        SWFUpload.prototype.destroy = noop;
     83        SWFUpload.prototype.displayDebugInfo = noop;
     84        SWFUpload.prototype.addSetting = noop;
     85        SWFUpload.prototype.getSetting = noop;
     86        SWFUpload.prototype.callFlash = noop;
     87        SWFUpload.prototype.selectFile = noop;
     88        SWFUpload.prototype.selectFiles = noop;
     89        SWFUpload.prototype.startUpload = noop;
     90        SWFUpload.prototype.cancelUpload = noop;
     91        SWFUpload.prototype.stopUpload = noop;
     92        SWFUpload.prototype.getStats = noop;
     93        SWFUpload.prototype.setStats = noop;
     94        SWFUpload.prototype.getFile = noop;
     95        SWFUpload.prototype.addFileParam = noop;
     96        SWFUpload.prototype.removeFileParam = noop;
     97        SWFUpload.prototype.setUploadURL = noop;
     98        SWFUpload.prototype.setPostParams = noop;
     99        SWFUpload.prototype.addPostParam = noop;
     100        SWFUpload.prototype.removePostParam = noop;
     101        SWFUpload.prototype.setFileTypes = noop;
     102        SWFUpload.prototype.setFileSizeLimit = noop;
     103        SWFUpload.prototype.setFileUploadLimit = noop;
     104        SWFUpload.prototype.setFileQueueLimit = noop;
     105        SWFUpload.prototype.setFilePostName = noop;
     106        SWFUpload.prototype.setUseQueryString = noop;
     107        SWFUpload.prototype.setRequeueOnError = noop;
     108        SWFUpload.prototype.setHTTPSuccess = noop;
     109        SWFUpload.prototype.setAssumeSuccessTimeout = noop;
     110        SWFUpload.prototype.setDebugEnabled = noop;
     111        SWFUpload.prototype.setButtonImageURL = noop;
     112        SWFUpload.prototype.setButtonDimensions = noop;
     113        SWFUpload.prototype.setButtonText = noop;
     114        SWFUpload.prototype.setButtonTextPadding = noop;
     115        SWFUpload.prototype.setButtonTextStyle = noop;
     116        SWFUpload.prototype.setButtonDisabled = noop;
     117        SWFUpload.prototype.setButtonAction = noop;
     118        SWFUpload.prototype.setButtonCursor = noop;
     119        SWFUpload.prototype.queueEvent = noop;
     120        SWFUpload.prototype.executeNextEvent = noop;
     121        SWFUpload.prototype.unescapeFilePostParams = noop;
     122        SWFUpload.prototype.testExternalInterface = noop;
     123        SWFUpload.prototype.flashReady = noop;
     124        SWFUpload.prototype.cleanUp = noop;
     125        SWFUpload.prototype.fileDialogStart = noop;
     126        SWFUpload.prototype.fileQueued = noop;
     127        SWFUpload.prototype.fileQueueError = noop;
     128        SWFUpload.prototype.fileDialogComplete = noop;
     129        SWFUpload.prototype.uploadStart = noop;
     130        SWFUpload.prototype.returnUploadStart = noop;
     131        SWFUpload.prototype.uploadProgress = noop;
     132        SWFUpload.prototype.uploadError = noop;
     133        SWFUpload.prototype.uploadSuccess = noop;
     134        SWFUpload.prototype.uploadComplete = noop;
     135        SWFUpload.prototype.debug = noop;
     136        SWFUpload.prototype.debugMessage = noop;
     137        SWFUpload.Console = {
     138                writeLine: noop
    830139        };
    831 
    832 };
    833 
    834 
    835 /* This is a chance to do something before the browse window opens */
    836 SWFUpload.prototype.fileDialogStart = function () {
    837         this.queueEvent("file_dialog_start_handler");
    838 };
    839 
    840 
    841 /* Called when a file is successfully added to the queue. */
    842 SWFUpload.prototype.fileQueued = function (file) {
    843         file = this.unescapeFilePostParams(file);
    844         this.queueEvent("file_queued_handler", file);
    845 };
    846 
    847 
    848 /* Handle errors that occur when an attempt to queue a file fails. */
    849 SWFUpload.prototype.fileQueueError = function (file, errorCode, message) {
    850         file = this.unescapeFilePostParams(file);
    851         this.queueEvent("file_queue_error_handler", [file, errorCode, message]);
    852 };
    853 
    854 /* Called after the file dialog has closed and the selected files have been queued.
    855         You could call startUpload here if you want the queued files to begin uploading immediately. */
    856 SWFUpload.prototype.fileDialogComplete = function (numFilesSelected, numFilesQueued, numFilesInQueue) {
    857         this.queueEvent("file_dialog_complete_handler", [numFilesSelected, numFilesQueued, numFilesInQueue]);
    858 };
    859 
    860 SWFUpload.prototype.uploadStart = function (file) {
    861         file = this.unescapeFilePostParams(file);
    862         this.queueEvent("return_upload_start_handler", file);
    863 };
    864 
    865 SWFUpload.prototype.returnUploadStart = function (file) {
    866         var returnValue;
    867         if (typeof this.settings.upload_start_handler === "function") {
    868                 file = this.unescapeFilePostParams(file);
    869                 returnValue = this.settings.upload_start_handler.call(this, file);
    870         } else if (this.settings.upload_start_handler != undefined) {
    871                 throw "upload_start_handler must be a function";
    872         }
    873 
    874         // Convert undefined to true so if nothing is returned from the upload_start_handler it is
    875         // interpretted as 'true'.
    876         if (returnValue === undefined) {
    877                 returnValue = true;
    878         }
    879        
    880         returnValue = !!returnValue;
    881        
    882         this.callFlash("ReturnUploadStart", [returnValue]);
    883 };
    884 
    885 
    886 
    887 SWFUpload.prototype.uploadProgress = function (file, bytesComplete, bytesTotal) {
    888         file = this.unescapeFilePostParams(file);
    889         this.queueEvent("upload_progress_handler", [file, bytesComplete, bytesTotal]);
    890 };
    891 
    892 SWFUpload.prototype.uploadError = function (file, errorCode, message) {
    893         file = this.unescapeFilePostParams(file);
    894         this.queueEvent("upload_error_handler", [file, errorCode, message]);
    895 };
    896 
    897 SWFUpload.prototype.uploadSuccess = function (file, serverData, responseReceived) {
    898         file = this.unescapeFilePostParams(file);
    899         this.queueEvent("upload_success_handler", [file, serverData, responseReceived]);
    900 };
    901 
    902 SWFUpload.prototype.uploadComplete = function (file) {
    903         file = this.unescapeFilePostParams(file);
    904         this.queueEvent("upload_complete_handler", file);
    905 };
    906 
    907 /* Called by SWFUpload JavaScript and Flash functions when debug is enabled. By default it writes messages to the
    908    internal debug console.  You can override this event and have messages written where you want. */
    909 SWFUpload.prototype.debug = function (message) {
    910         this.queueEvent("debug_handler", message);
    911 };
    912 
    913 
    914 /* **********************************
    915         Debug Console
    916         The debug console is a self contained, in page location
    917         for debug message to be sent.  The Debug Console adds
    918         itself to the body if necessary.
    919 
    920         The console is automatically scrolled as messages appear.
    921        
    922         If you are using your own debug handler or when you deploy to production and
    923         have debug disabled you can remove these functions to reduce the file size
    924         and complexity.
    925 ********************************** */
    926    
    927 // Private: debugMessage is the default debug_handler.  If you want to print debug messages
    928 // call the debug() function.  When overriding the function your own function should
    929 // check to see if the debug setting is true before outputting debug information.
    930 SWFUpload.prototype.debugMessage = function (message) {
    931         if (this.settings.debug) {
    932                 var exceptionMessage, exceptionValues = [];
    933 
    934                 // Check for an exception object and print it nicely
    935                 if (typeof message === "object" && typeof message.name === "string" && typeof message.message === "string") {
    936                         for (var key in message) {
    937                                 if (message.hasOwnProperty(key)) {
    938                                         exceptionValues.push(key + ": " + message[key]);
    939                                 }
    940                         }
    941                         exceptionMessage = exceptionValues.join("\n") || "";
    942                         exceptionValues = exceptionMessage.split("\n");
    943                         exceptionMessage = "EXCEPTION: " + exceptionValues.join("\nEXCEPTION: ");
    944                         SWFUpload.Console.writeLine(exceptionMessage);
    945                 } else {
    946                         SWFUpload.Console.writeLine(message);
    947                 }
    948         }
    949 };
    950 
    951 SWFUpload.Console = {};
    952 SWFUpload.Console.writeLine = function (message) {
    953         var console, documentForm;
    954 
    955         try {
    956                 console = document.getElementById("SWFUpload_Console");
    957 
    958                 if (!console) {
    959                         documentForm = document.createElement("form");
    960                         document.getElementsByTagName("body")[0].appendChild(documentForm);
    961 
    962                         console = document.createElement("textarea");
    963                         console.id = "SWFUpload_Console";
    964                         console.style.fontFamily = "monospace";
    965                         console.setAttribute("wrap", "off");
    966                         console.wrap = "off";
    967                         console.style.overflow = "auto";
    968                         console.style.width = "700px";
    969                         console.style.height = "350px";
    970                         console.style.margin = "5px";
    971                         documentForm.appendChild(console);
    972                 }
    973 
    974                 console.value += message + "\n";
    975 
    976                 console.scrollTop = console.scrollHeight - console.clientHeight;
    977         } catch (ex) {
    978                 alert("Exception: " + ex.name + " Message: " + ex.message);
    979         }
    980 };
     140}() );
  • src/wp-includes/js/swfupload/swfupload.swf

    Cannot display: file marked as a binary type.
    svn:mime-type = application/octet-stream