WordPress.org

Make WordPress Core

Ticket #41752: 41752.patch

File 41752.patch, 91.8 KB (added by azaozz, 5 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