← Back to branch summary

~ubuntu-branches/debian/sid/wordpress/sid

« back to all changes in this revision

Viewing changes to debian/missing-sources/plupload-1.5.7/javascript/plupload.browserplus.js

  • Committer: Package Import Robot
  • Author(s): Raphaël Hertzog
  • Date: 2013-09-04 23:18:58 UTC
  • mfrom: (1.2.28)
  • Revision ID: package-import@ubuntu.com-20130904231858-nljmn1buzswh63jk
Tags: 3.6+dfsg-1
* New upstream release.
* Improve wp-settings to verify that $_SERVER['HTTP_X_FORWARDED_PROTO']
  exists before accessing it (avoids a PHP notice).
  Thanks to Paul Dreik <slask@pauldreik.se> for the report and the patch.
* Document in README.Debian the need to login to /wp-admin/ to complete
  an upgrade.
* Drop useless debian/README.source
* Drop 008CVE2008-2392.patch since upstream now disables unfiltered
  uploads by default. See http://core.trac.wordpress.org/ticket/10692
* Drop 009CVE2008-6767.patch since the backto parameter is validated
  against a whitelist, and externally triggered upgrades are not a
  security problem as long as they work.
* Update debian/missing-sources with latest versions.
* Update upstream l10n.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/missing-sources/plupload-1.5.7/javascript/plupload.browserplus.js
 
1
/**
 
2
 * plupload.browserplus.js
 
3
 *
 
4
 * Copyright 2009, Moxiecode Systems AB
 
5
 * Released under GPL License.
 
6
 *
 
7
 * License: http://www.plupload.com/license
 
8
 * Contributing: http://www.plupload.com/contributing
 
9
 */
 
10
 
 
11
// JSLint defined globals
 
12
/*global plupload:false, BrowserPlus:false, window:false */
 
13
 
 
14
(function(plupload) {
 
15
        /**
 
16
         * Yahoo BrowserPlus implementation. This runtime supports these features: dragdrop, jpgresize, pngresize.
 
17
         *
 
18
         * @static
 
19
         * @class plupload.runtimes.BrowserPlus
 
20
         * @extends plupload.Runtime
 
21
         */
 
22
        plupload.runtimes.BrowserPlus = plupload.addRuntime("browserplus", {
 
23
                /**
 
24
                 * Returns a list of supported features for the runtime.
 
25
                 *
 
26
                 * @return {Object} Name/value object with supported features.
 
27
                 */
 
28
                getFeatures : function() {
 
29
                        return {
 
30
                                dragdrop : true,
 
31
                                jpgresize : true,
 
32
                                pngresize : true,
 
33
                                chunks : true,
 
34
                                progress: true,
 
35
                                multipart: true,
 
36
                                multi_selection: true
 
37
                        };
 
38
                },
 
39
 
 
40
                /**
 
41
                 * Initializes the browserplus runtime.
 
42
                 *
 
43
                 * @method init
 
44
                 * @param {plupload.Uploader} uploader Uploader instance that needs to be initialized.
 
45
                 * @param {function} callback Callback to execute when the runtime initializes or fails to initialize. If it succeeds an object with a parameter name success will be set to true.
 
46
                 */
 
47
                init : function(uploader, callback) {
 
48
                        var browserPlus = window.BrowserPlus, browserPlusFiles = {}, settings = uploader.settings, resize = settings.resize;
 
49
 
 
50
                        function addSelectedFiles(native_files) {
 
51
                                var files, i, selectedFiles = [], file, id;
 
52
 
 
53
                                // Add the native files and setup plupload files
 
54
                                for (i = 0; i < native_files.length; i++) {
 
55
                                        file = native_files[i];
 
56
                                        id = plupload.guid();
 
57
                                        browserPlusFiles[id] = file;
 
58
 
 
59
                                        selectedFiles.push(new plupload.File(id, file.name, file.size));
 
60
                                }
 
61
 
 
62
                                // Any files selected fire event
 
63
                                if (i) {
 
64
                                        uploader.trigger("FilesAdded", selectedFiles);
 
65
                                }
 
66
                        }
 
67
 
 
68
                        // Setup event listeners if browserplus was initialized
 
69
                        function setup() {
 
70
                                var disabled = false;
 
71
                                
 
72
                                // Add drop handler
 
73
                                uploader.bind("PostInit", function() {
 
74
                                        var dropTargetElm, dropElmId = settings.drop_element,
 
75
                                                dropTargetId = uploader.id + '_droptarget',
 
76
                                                dropElm = document.getElementById(dropElmId),
 
77
                                                lastState;
 
78
 
 
79
                                        // Enable/disable drop support for the drop target
 
80
                                        // this is needed to resolve IE bubbeling issues and make it possible to drag/drop
 
81
                                        // files into gears runtimes on the same page
 
82
                                        function addDropHandler(id, end_callback) {
 
83
                                                // Add drop target and listener
 
84
                                                browserPlus.DragAndDrop.AddDropTarget({id : id}, function(res) {
 
85
                                                        browserPlus.DragAndDrop.AttachCallbacks({
 
86
                                                                id : id,
 
87
                                                                hover : function(res) {
 
88
                                                                        if (!res && end_callback) {
 
89
                                                                                end_callback();
 
90
                                                                        }
 
91
                                                                },
 
92
                                                                drop : function(res) {
 
93
                                                                        if (end_callback) {
 
94
                                                                                end_callback();
 
95
                                                                        }
 
96
 
 
97
                                                                        addSelectedFiles(res);
 
98
                                                                }
 
99
                                                        }, function() {
 
100
                                                        });
 
101
                                                });
 
102
                                        }
 
103
 
 
104
                                        function hide() {
 
105
                                                document.getElementById(dropTargetId).style.top = '-1000px';
 
106
                                        }
 
107
 
 
108
                                        if (dropElm) {
 
109
                                                // Since IE has issues with bubbeling when it comes to the drop of files
 
110
                                                // we need to do this hack where we show a drop target div element while dropping
 
111
                                                if (document.attachEvent && (/MSIE/gi).test(navigator.userAgent)) {
 
112
                                                        // Create drop target
 
113
                                                        dropTargetElm = document.createElement('div');
 
114
                                                        dropTargetElm.setAttribute('id', dropTargetId);
 
115
                                                        plupload.extend(dropTargetElm.style, {
 
116
                                                                position : 'absolute',
 
117
                                                                top : '-1000px',
 
118
                                                                background : 'red',
 
119
                                                                filter : 'alpha(opacity=0)',
 
120
                                                                opacity : 0
 
121
                                                        });
 
122
 
 
123
                                                        document.body.appendChild(dropTargetElm);
 
124
 
 
125
                                                        plupload.addEvent(dropElm, 'dragenter', function(e) {
 
126
                                                                var dropElm, dropElmPos;
 
127
 
 
128
                                                                dropElm = document.getElementById(dropElmId);
 
129
                                                                dropElmPos = plupload.getPos(dropElm);
 
130
 
 
131
                                                                plupload.extend(document.getElementById(dropTargetId).style, {
 
132
                                                                        top : dropElmPos.y + 'px',
 
133
                                                                        left : dropElmPos.x + 'px',
 
134
                                                                        width : dropElm.offsetWidth + 'px',
 
135
                                                                        height : dropElm.offsetHeight + 'px'
 
136
                                                                });
 
137
                                                        });
 
138
 
 
139
                                                        addDropHandler(dropTargetId, hide);
 
140
                                                } else {
 
141
                                                        addDropHandler(dropElmId);
 
142
                                                }
 
143
                                        }
 
144
 
 
145
                                        plupload.addEvent(document.getElementById(settings.browse_button), 'click', function(e) {
 
146
                                                var mimes = [], i, a, filters = settings.filters, ext, type;
 
147
 
 
148
                                                e.preventDefault();
 
149
                                                
 
150
                                                if (disabled) {
 
151
                                                        return; 
 
152
                                                }
 
153
 
 
154
                                                // Convert extensions to mimetypes
 
155
                                                no_type_restriction:
 
156
                                                for (i = 0; i < filters.length; i++) {
 
157
                                                        ext = filters[i].extensions.split(',');
 
158
 
 
159
                                                        for (a = 0; a < ext.length; a++) {
 
160
                                                                if (ext[a] === '*') {
 
161
                                                                        mimes = [];
 
162
                                                                        break no_type_restriction;
 
163
                                                                }
 
164
                                                                type = plupload.mimeTypes[ext[a]];
 
165
                                                                
 
166
                                                                if (type && plupload.inArray(type, mimes) === -1) {
 
167
                                                                        mimes.push(plupload.mimeTypes[ext[a]]);
 
168
                                                                }
 
169
                                                        }
 
170
                                                }
 
171
 
 
172
                                                browserPlus.FileBrowse.OpenBrowseDialog({
 
173
                                                        mimeTypes : mimes
 
174
                                                }, function(res) {
 
175
                                                        if (res.success) {
 
176
                                                                addSelectedFiles(res.value);
 
177
                                                        }
 
178
                                                });
 
179
                                        });
 
180
 
 
181
                                        // Prevent IE leaks
 
182
                                        dropElm = dropTargetElm = null;
 
183
                                });
 
184
                                
 
185
                                uploader.bind("CancelUpload", function() {
 
186
                                        browserPlus.Uploader.cancel({}, function(){});
 
187
                                });
 
188
                                
 
189
                                uploader.bind("DisableBrowse", function(up, state) {
 
190
                                        disabled = state;
 
191
                                });
 
192
 
 
193
                                uploader.bind("UploadFile", function(up, file) {
 
194
                                        var nativeFile = browserPlusFiles[file.id], reqParams = {},
 
195
                                            chunkSize = up.settings.chunk_size, loadProgress, chunkStack = [];
 
196
 
 
197
                                        function uploadFile(chunk, chunks) {
 
198
                                                var chunkFile;
 
199
 
 
200
                                                // Stop upload if file is maked as failed
 
201
                                                if (file.status == plupload.FAILED) {
 
202
                                                        return;
 
203
                                                }
 
204
 
 
205
                                                reqParams.name = file.target_name || file.name;
 
206
 
 
207
                                                // Only send chunk parameters if chunk size is defined
 
208
                                                if (chunkSize) {
 
209
                                                        reqParams.chunk = "" + chunk;
 
210
                                                        reqParams.chunks = "" + chunks;
 
211
                                                }
 
212
 
 
213
                                            chunkFile = chunkStack.shift();
 
214
 
 
215
                                                browserPlus.Uploader.upload({
 
216
                                                        url : up.settings.url,
 
217
                                                        files : {file : chunkFile},
 
218
                                                        cookies : document.cookies,
 
219
                                                        postvars : plupload.extend(reqParams, up.settings.multipart_params),
 
220
                                                        progressCallback : function(res) {
 
221
                                                                var i, loaded = 0;
 
222
 
 
223
                                                                // since more than 1 chunk can be sent at a time, keep track of how many bytes
 
224
                                                                // of each chunk was sent
 
225
                                                                loadProgress[chunk] = parseInt(res.filePercent * chunkFile.size / 100, 10);
 
226
                                                                for (i = 0; i < loadProgress.length; i++) {
 
227
                                                                        loaded += loadProgress[i];
 
228
                                                                }
 
229
 
 
230
                                                                file.loaded = loaded;
 
231
                                                                up.trigger('UploadProgress', file);
 
232
                                                        }
 
233
                                                }, function(res) {
 
234
                                                        var httpStatus, chunkArgs;
 
235
 
 
236
                                                        if (res.success) {
 
237
                                                                httpStatus = res.value.statusCode;
 
238
 
 
239
                                                                if (chunkSize) {
 
240
                                                                        up.trigger('ChunkUploaded', file, {
 
241
                                                                                chunk : chunk,
 
242
                                                                                chunks : chunks,
 
243
                                                                                response : res.value.body,
 
244
                                                                                status : httpStatus
 
245
                                                                        });
 
246
                                                                }
 
247
 
 
248
                                                            if (chunkStack.length > 0) {
 
249
                                                                        // More chunks to be uploaded
 
250
                                                                        uploadFile(++chunk, chunks);
 
251
                                                            } else {
 
252
                                                                        file.status = plupload.DONE;
 
253
 
 
254
                                                                        up.trigger('FileUploaded', file, {
 
255
                                                                                response : res.value.body,
 
256
                                                                                status : httpStatus
 
257
                                                                        });
 
258
 
 
259
                                                                        // Is error status
 
260
                                                                        if (httpStatus >= 400) {
 
261
                                                                                up.trigger('Error', {
 
262
                                                                                        code : plupload.HTTP_ERROR,
 
263
                                                                                        message : plupload.translate('HTTP Error.'),
 
264
                                                                                        file : file,
 
265
                                                                                        status : httpStatus
 
266
                                                                                });
 
267
                                                                        }
 
268
                                                            }
 
269
                                                        } else {
 
270
                                                                up.trigger('Error', {
 
271
                                                                        code : plupload.GENERIC_ERROR,
 
272
                                                                        message : plupload.translate('Generic Error.'),
 
273
                                                                        file : file,
 
274
                                                                        details : res.error
 
275
                                                                });
 
276
                                                        }
 
277
                                                });
 
278
                                        }
 
279
 
 
280
                                        function chunkAndUploadFile(native_file) {
 
281
                                                file.size = native_file.size;
 
282
                                                if (chunkSize) {
 
283
                                                        browserPlus.FileAccess.chunk({file : native_file, chunkSize : chunkSize}, function(cr) {
 
284
                                                                if (cr.success) {
 
285
                                                                        var chunks = cr.value, len = chunks.length;
 
286
 
 
287
                                                                        loadProgress = Array(len);
 
288
 
 
289
                                                                        for (var i = 0; i < len; i++) {
 
290
                                                                                loadProgress[i] = 0;
 
291
                                                                                chunkStack.push(chunks[i]);
 
292
                                                                        }
 
293
 
 
294
                                                                        uploadFile(0, len);
 
295
                                                                }
 
296
                                                        });
 
297
                                                } else {
 
298
                                                        loadProgress = Array(1);
 
299
                                                        chunkStack.push(native_file);
 
300
                                                        uploadFile(0, 1);
 
301
                                                }
 
302
                                        }
 
303
 
 
304
                                        // Resize image if it's a supported format and resize is enabled
 
305
                                        if (resize && /\.(png|jpg|jpeg)$/i.test(file.name)) {
 
306
                                                BrowserPlus.ImageAlter.transform({
 
307
                                                        file : nativeFile,
 
308
                                                        quality : resize.quality || 90,
 
309
                                                        actions : [{
 
310
                                                                scale : {
 
311
                                                                        maxwidth : resize.width,
 
312
                                                                        maxheight : resize.height
 
313
                                                                }
 
314
                                                        }]
 
315
                                                }, function(res) {
 
316
                                                        if (res.success) {
 
317
                                                                chunkAndUploadFile(res.value.file);
 
318
                                                        }
 
319
                                                });
 
320
                                        } else {
 
321
                                                chunkAndUploadFile(nativeFile);
 
322
                                        }
 
323
                                });
 
324
 
 
325
                                callback({success : true});
 
326
                        }
 
327
 
 
328
                        // Check for browserplus object
 
329
                        if (browserPlus) {
 
330
                                browserPlus.init(function(res) {
 
331
                                        var services = [
 
332
                                                {service: "Uploader", version: "3"},
 
333
                                                {service: "DragAndDrop", version: "1"},
 
334
                                                {service: "FileBrowse", version: "1"},
 
335
                                                {service: "FileAccess", version: "2"}
 
336
                                        ];
 
337
 
 
338
                                        if (resize) {
 
339
                                                services.push({service : 'ImageAlter', version : "4"});
 
340
                                        }
 
341
 
 
342
                                        if (res.success) {
 
343
                                                browserPlus.require({
 
344
                                                        services : services
 
345
                                                }, function(sres) {
 
346
                                                        if (sres.success) {
 
347
                                                                setup();
 
348
                                                        } else {
 
349
                                                                callback();
 
350
                                                        }
 
351
                                                });
 
352
                                        } else {
 
353
                                                callback();
 
354
                                        }
 
355
                                });
 
356
                        } else {
 
357
                                callback();
 
358
                        }
 
359
                }
 
360
        });
 
361
})(plupload);