Changeset 7253


Ignore:
Timestamp:
12/13/12 13:14:37 (7 years ago)
Author:
kent1
Message:

Update de la librairie de jfu à la dernière version utilisable (ensuite elle nécessite jQuery UI 1.9.1)

Location:
plugins_spip/jquery_file_upload/trunk/javascript/jquery_file_upload/js
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • plugins_spip/jquery_file_upload/trunk/javascript/jquery_file_upload/js/jquery.fileupload-fp.js

    r6644 r7253  
    11/*
    2  * jQuery File Upload File Processing Plugin 1.0
     2 * jQuery File Upload File Processing Plugin 1.1
    33 * https://github.com/blueimp/jQuery-File-Upload
    44 *
     
    7171        processActions: {
    7272            // Loads the image given via data.files and data.index
    73             // as canvas element.
     73            // as img element if the browser supports canvas.
    7474            // Accepts the options fileTypes (regular expression)
    7575            // and maxFileSize (integer) to limit the files to load:
     
    8686                    loadImage(
    8787                        file,
    88                         function (canvas) {
    89                             data.canvas = canvas;
     88                        function (img) {
     89                            data.img = img;
    9090                            dfd.resolveWith(that, [data]);
    91                         },
    92                         {canvas: true}
     91                        }
    9392                    );
    9493                } else {
     
    9796                return dfd.promise();
    9897            },
    99             // Resizes the image given as data.canvas and updates
    100             // data.canvas with the resized image.
     98            // Resizes the image given as data.img and updates
     99            // data.canvas with the resized image as canvas element.
    101100            // Accepts the options maxWidth, maxHeight, minWidth and
    102101            // minHeight to scale the given image:
    103102            resize: function (data, options) {
    104                 if (data.canvas) {
    105                     var canvas = loadImage.scale(data.canvas, options);
    106                     if (canvas.width !== data.canvas.width ||
    107                             canvas.height !== data.canvas.height) {
     103                var img = data.img,
     104                    canvas;
     105                options = $.extend({canvas: true}, options);
     106                if (img) {
     107                    canvas = loadImage.scale(img, options);
     108                    if (canvas.width !== img.width ||
     109                            canvas.height !== img.height) {
    108110                        data.canvas = canvas;
    109                         data.processed = true;
    110111                    }
    111112                }
     
    116117            save: function (data, options) {
    117118                // Do nothing if no processing has happened:
    118                 if (!data.canvas || !data.processed) {
     119                if (!data.canvas) {
    119120                    return data;
    120121                }
  • plugins_spip/jquery_file_upload/trunk/javascript/jquery_file_upload/js/jquery.fileupload-ui.js

    r6949 r7253  
    11/*
    2  * jQuery File Upload User Interface Plugin 6.9.4
     2 * jQuery File Upload User Interface Plugin 6.9.7
    33 * https://github.com/blueimp/jQuery-File-Upload
    44 *
     
    145145                    data.context.each(function (index) {
    146146                        var file = ($.isArray(data.result) &&
    147                                 data.result[index]) || {error: 'emptyResult'};
     147                                data.result[index]) ||
     148                                    {error: 'Empty file upload result'};
    148149                        if (file.error) {
    149150                            that._adjustMaxNumberOfFiles(1);
     
    399400            // maxNumberOfFiles is below 0 (instead of below 1):
    400401            if (this.options.maxNumberOfFiles < 0) {
    401                 return 'maxNumberOfFiles';
     402                return 'Maximum number of files exceeded';
    402403            }
    403404            // Files are accepted if either the file type or the file name
     
    406407            if (!(this.options.acceptFileTypes.test(file.type) ||
    407408                    this.options.acceptFileTypes.test(file.name))) {
    408                 return 'acceptFileTypes';
     409                return 'Filetype not allowed';
    409410            }
    410411            if (this.options.maxFileSize &&
    411412                    file.size > this.options.maxFileSize) {
    412                 return 'maxFileSize';
     413                return 'File is too big';
    413414            }
    414415            if (typeof file.size === 'number' &&
    415416                    file.size < this.options.minFileSize) {
    416                 return 'minFileSize';
     417                return 'File is too small';
    417418            }
    418419            return null;
     
    721722
    722723        enable: function () {
     724            var wasDisabled = false;
     725            if (this.options.disabled) {
     726                wasDisabled = true;
     727            }
    723728            parentWidget.prototype.enable.call(this);
    724             this.element.find('input, button').prop('disabled', false);
    725             this._enableFileInputButton();
     729            if (wasDisabled) {
     730                this.element.find('input, button').prop('disabled', false);
     731                this._enableFileInputButton();
     732            }
    726733        },
    727734
    728735        disable: function () {
    729             this.element.find('input, button').prop('disabled', true);
    730             this._disableFileInputButton();
     736            if (!this.options.disabled) {
     737                this.element.find('input, button').prop('disabled', true);
     738                this._disableFileInputButton();
     739            }
    731740            parentWidget.prototype.disable.call(this);
    732741        }
  • plugins_spip/jquery_file_upload/trunk/javascript/jquery_file_upload/js/jquery.fileupload.js

    r6949 r7253  
    11/*
    2  * jQuery File Upload Plugin 5.16.3
     2 * jQuery File Upload Plugin 5.18
    33 * https://github.com/blueimp/jQuery-File-Upload
    44 *
     
    4545
    4646        options: {
    47             // The namespace used for event handler binding on the dropZone and
    48             // fileInput collections.
     47            // The namespace used for event handler binding on the fileInput,
     48            // dropZone and pasteZone document nodes.
    4949            // If not set, the name of the widget ("fileupload") is used.
    5050            namespace: undefined,
    51             // The drop target collection, by the default the complete document.
    52             // Set to null or an empty collection to disable drag & drop support:
     51            // The drop target element(s), by the default the complete document.
     52            // Set to null to disable drag & drop support:
    5353            dropZone: $(document),
    54             // The file input field collection, that is listened for change events.
     54            // The paste target element(s), by the default the complete document.
     55            // Set to null to disable paste support:
     56            pasteZone: $(document),
     57            // The file input field(s), that are listened to for change events.
    5558            // If undefined, it is set to the file input fields inside
    5659            // of the widget element on plugin initialization.
    57             // Set to null or an empty collection to disable the change listener.
     60            // Set to null to disable the change listener.
    5861            fileInput: undefined,
    5962            // By default, the file input field is replaced with a clone after
     
    160163            // Callback for uploads stop, equivalent to the global ajaxStop event:
    161164            // stop: function (e) {}, // .bind('fileuploadstop', func);
    162             // Callback for change events of the fileInput collection:
     165            // Callback for change events of the fileInput(s):
    163166            // change: function (e, data) {}, // .bind('fileuploadchange', func);
    164             // Callback for paste events to the dropZone collection:
     167            // Callback for paste events to the pasteZone(s):
    165168            // paste: function (e, data) {}, // .bind('fileuploadpaste', func);
    166             // Callback for drop events of the dropZone collection:
     169            // Callback for drop events of the dropZone(s):
    167170            // drop: function (e, data) {}, // .bind('fileuploaddrop', func);
    168             // Callback for dragover events of the dropZone collection:
     171            // Callback for dragover events of the dropZone(s):
    169172            // dragover: function (e) {}, // .bind('fileuploaddragover', func);
    170173
     
    179182        _refreshOptionsList: [
    180183            'namespace',
     184            'fileInput',
    181185            'dropZone',
    182             'fileInput',
     186            'pasteZone',
    183187            'multipart',
    184188            'forceIframeTransport'
     
    302306                multipart = options.multipart || !$.support.xhrFileUpload,
    303307                paramName = options.paramName[0];
    304             if (!multipart || options.blob) {
    305                 // For non-multipart uploads and chunked uploads,
    306                 // file meta data is not part of the request body,
    307                 // so we transmit this data as part of the HTTP headers.
    308                 // For cross domain requests, these headers must be allowed
    309                 // via Access-Control-Allow-Headers or removed using
    310                 // the beforeSend callback:
    311                 options.headers = $.extend(options.headers, {
    312                     'X-File-Name': file.name,
    313                     'X-File-Type': file.type,
    314                     'X-File-Size': file.size
    315                 });
    316                 if (!options.blob) {
    317                     // Non-chunked non-multipart upload:
    318                     options.contentType = file.type;
    319                     options.data = file;
    320                 } else if (!multipart) {
    321                     // Chunked non-multipart upload:
    322                     options.contentType = 'application/octet-stream';
    323                     options.data = options.blob;
    324                 }
    325             }
    326             if (multipart && $.support.xhrFormDataFileUpload) {
     308            options.headers = options.headers || {};
     309            if (options.contentRange) {
     310                options.headers['Content-Range'] = options.contentRange;
     311            }
     312            if (!multipart) {
     313                // For cross domain requests, the X-File-Name header
     314                // must be allowed via Access-Control-Allow-Headers
     315                // or removed using the beforeSend callback:
     316                options.headers['X-File-Name'] = file.name;
     317                options.contentType = file.type;
     318                options.data = options.blob || file;
     319            } else if ($.support.xhrFormDataFileUpload) {
    327320                if (options.postMessage) {
    328321                    // window.postMessage does not allow sending FormData
     
    354347                    }
    355348                    if (options.blob) {
     349                        // For cross domain requests, the X-File-* headers
     350                        // must be allowed via Access-Control-Allow-Headers
     351                        // or removed using the beforeSend callback:
     352                        options.headers['X-File-Name'] = file.name;
     353                        options.headers['X-File-Type'] = file.type;
    356354                        formData.append(paramName, options.blob, file.name);
    357355                    } else {
     
    437435            if (!options.form || !options.form.length) {
    438436                options.form = $(options.fileInput.prop('form'));
     437                // If the given file input doesn't have an associated form,
     438                // use the default widget file input's form:
     439                if (!options.form.length) {
     440                    options.form = $(this.options.fileInput.prop('form'));
     441                }
    439442            }
    440443            options.paramName = this._getParamName(options);
     
    482485            promise.abort = dfd.promise;
    483486            return this._enhancePromise(promise);
     487        },
     488
     489        // Parses the Range header from the server response
     490        // and returns the uploaded bytes:
     491        _getUploadedBytes: function (jqXHR) {
     492            var range = jqXHR.getResponseHeader('Range'),
     493                parts = range && range.split('-'),
     494                upperBytesPos = parts && parts.length > 1 &&
     495                    parseInt(parts[1], 10);
     496            return upperBytesPos && upperBytesPos + 1;
    484497        },
    485498
     
    495508                ub = options.uploadedBytes = options.uploadedBytes || 0,
    496509                mcs = options.maxChunkSize || fs,
    497                 // Use the Blob methods with the slice implementation
    498                 // according to the W3C Blob API specification:
    499                 slice = file.webkitSlice || file.mozSlice || file.slice,
    500                 upload,
    501                 n,
     510                slice = file.slice || file.webkitSlice || file.mozSlice,
     511                dfd = $.Deferred(),
     512                promise = dfd.promise(),
    502513                jqXHR,
    503                 pipe;
     514                upload;
    504515            if (!(this._isXHRUpload(options) && slice && (ub || mcs < fs)) ||
    505516                    options.data) {
     
    510521            }
    511522            if (ub >= fs) {
    512                 file.error = 'uploadedBytes';
     523                file.error = 'Uploaded bytes exceed file size';
    513524                return this._getXHRPromise(
    514525                    false,
     
    517528                );
    518529            }
    519             // n is the number of blobs to upload,
    520             // calculated via filesize, uploaded bytes and max chunk size:
    521             n = Math.ceil((fs - ub) / mcs);
    522             // The chunk upload method accepting the chunk number as parameter:
     530            // The chunk upload method:
    523531            upload = function (i) {
    524                 if (!i) {
    525                     return that._getXHRPromise(true, options.context);
    526                 }
    527                 // Upload the blobs in sequential order:
    528                 return upload(i -= 1).pipe(function () {
    529                     // Clone the options object for each chunk upload:
    530                     var o = $.extend({}, options);
    531                     o.blob = slice.call(
    532                         file,
    533                         ub + i * mcs,
    534                         ub + (i + 1) * mcs
    535                     );
    536                     // Expose the chunk index:
    537                     o.chunkIndex = i;
    538                     // Expose the number of chunks:
    539                     o.chunksNumber = n;
    540                     // Store the current chunk size, as the blob itself
    541                     // will be dereferenced after data processing:
    542                     o.chunkSize = o.blob.size;
    543                     // Process the upload data (the blob and potential form data):
    544                     that._initXHRData(o);
    545                     // Add progress listeners for this chunk upload:
    546                     that._initProgressListener(o);
    547                     jqXHR = ($.ajax(o) || that._getXHRPromise(false, o.context))
    548                         .done(function () {
    549                             // Create a progress event if upload is done and
    550                             // no progress event has been invoked for this chunk:
    551                             if (!o.loaded) {
    552                                 that._onProgress($.Event('progress', {
    553                                     lengthComputable: true,
    554                                     loaded: o.chunkSize,
    555                                     total: o.chunkSize
    556                                 }), o);
    557                             }
    558                             options.uploadedBytes = o.uploadedBytes +=
    559                                 o.chunkSize;
    560                         });
    561                     return jqXHR;
    562                 });
     532                // Clone the options object for each chunk upload:
     533                var o = $.extend({}, options);
     534                o.blob = slice.call(
     535                    file,
     536                    ub,
     537                    ub + mcs
     538                );
     539                // Store the current chunk size, as the blob itself
     540                // will be dereferenced after data processing:
     541                o.chunkSize = o.blob.size;
     542                // Expose the chunk bytes position range:
     543                o.contentRange = 'bytes ' + ub + '-' +
     544                    (ub + o.chunkSize - 1) + '/' + fs;
     545                // Process the upload data (the blob and potential form data):
     546                that._initXHRData(o);
     547                // Add progress listeners for this chunk upload:
     548                that._initProgressListener(o);
     549                jqXHR = ($.ajax(o) || that._getXHRPromise(false, o.context))
     550                    .done(function (result, textStatus, jqXHR) {
     551                        ub = that._getUploadedBytes(jqXHR) ||
     552                            (ub + o.chunkSize);
     553                        // Create a progress event if upload is done and
     554                        // no progress event has been invoked for this chunk:
     555                        if (!o.loaded) {
     556                            that._onProgress($.Event('progress', {
     557                                lengthComputable: true,
     558                                loaded: ub - o.uploadedBytes,
     559                                total: ub - o.uploadedBytes
     560                            }), o);
     561                        }
     562                        options.uploadedBytes = o.uploadedBytes = ub;
     563                        if (ub < fs) {
     564                            // File upload not yet complete,
     565                            // continue with the next chunk:
     566                            upload();
     567                        } else {
     568                            dfd.resolveWith(
     569                                o.context,
     570                                [result, textStatus, jqXHR]
     571                            );
     572                        }
     573                    })
     574                    .fail(function (jqXHR, textStatus, errorThrown) {
     575                        dfd.rejectWith(
     576                            o.context,
     577                            [jqXHR, textStatus, errorThrown]
     578                        );
     579                    });
    563580            };
    564             // Return the piped Promise object, enhanced with an abort method,
    565             // which is delegated to the jqXHR object of the current upload,
    566             // and jqXHR callbacks mapped to the equivalent Promise methods:
    567             pipe = upload(n);
    568             pipe.abort = function () {
     581            this._enhancePromise(promise);
     582            promise.abort = function () {
    569583                return jqXHR.abort();
    570584            };
    571             return this._enhancePromise(pipe);
     585            upload();
     586            return promise;
    572587        },
    573588
     
    767782            $.cleanData(input.unbind('remove'));
    768783            // Replace the original file input element in the fileInput
    769             // collection with the clone, which has been copied including
     784            // elements set with the clone, which has been copied including
    770785            // event handlers:
    771786            this.options.fileInput = this.options.fileInput.map(function (i, el) {
     
    785800            var that = this,
    786801                dfd = $.Deferred(),
    787                 errorHandler = function () {
    788                     dfd.reject();
     802                errorHandler = function (e) {
     803                    if (e && !e.entry) {
     804                        e.entry = entry;
     805                    }
     806                    // Since $.when returns immediately if one
     807                    // Deferred is rejected, we use resolve instead.
     808                    // This allows valid files and invalid items
     809                    // to be returned together in one set:
     810                    dfd.resolve([e]);
    789811                },
    790812                dirReader;
    791813            path = path || '';
    792814            if (entry.isFile) {
    793                 entry.file(function (file) {
    794                     file.relativePath = path;
    795                     dfd.resolve(file);
    796                 }, errorHandler);
     815                if (entry._file) {
     816                    // Workaround for Chrome bug #149735
     817                    entry._file.relativePath = path;
     818                    dfd.resolve(entry._file);
     819                } else {
     820                    entry.file(function (file) {
     821                        file.relativePath = path;
     822                        dfd.resolve(file);
     823                    }, errorHandler);
     824                }
    797825            } else if (entry.isDirectory) {
    798826                dirReader = entry.createReader();
     
    806834                }, errorHandler);
    807835            } else {
    808                 errorHandler();
     836                // Return an empy list for file system items
     837                // other than files or directories:
     838                dfd.resolve([]);
    809839            }
    810840            return dfd.promise();
     
    833863                return this._handleFileTreeEntries(
    834864                    $.map(items, function (item) {
     865                        var entry;
    835866                        if (item.webkitGetAsEntry) {
    836                             return item.webkitGetAsEntry();
     867                            entry = item.webkitGetAsEntry();
     868                            if (entry) {
     869                                // Workaround for Chrome bug #149735:
     870                                entry._file = item.getAsFile();
     871                            }
     872                            return entry;
    837873                        }
    838874                        return item.getAsEntry();
     
    845881        },
    846882
    847         _getFileInputFiles: function (fileInput) {
     883        _getSingleFileInputFiles: function (fileInput) {
    848884            fileInput = $(fileInput);
    849885            var entries = fileInput.prop('webkitEntries') ||
     
    858894                value = fileInput.prop('value');
    859895                if (!value) {
    860                     return $.Deferred().reject([]).promise();
     896                    return $.Deferred().resolve([]).promise();
    861897                }
    862898                // If the files property is not available, the browser does not
     
    866902            }
    867903            return $.Deferred().resolve(files).promise();
     904        },
     905
     906        _getFileInputFiles: function (fileInput) {
     907            if (!(fileInput instanceof $) || fileInput.length === 1) {
     908                return this._getSingleFileInputFiles(fileInput);
     909            }
     910            return $.when.apply(
     911                $,
     912                $.map(fileInput, this._getSingleFileInputFiles)
     913            ).pipe(function () {
     914                return Array.prototype.concat.apply(
     915                    [],
     916                    arguments
     917                );
     918            });
    868919        },
    869920
     
    932983                this.options.dropZone
    933984                    .bind('dragover.' + ns, {fileupload: this}, this._onDragOver)
    934                     .bind('drop.' + ns, {fileupload: this}, this._onDrop)
     985                    .bind('drop.' + ns, {fileupload: this}, this._onDrop);
     986                this.options.pasteZone
    935987                    .bind('paste.' + ns, {fileupload: this}, this._onPaste);
    936988            }
     
    943995            this.options.dropZone
    944996                .unbind('dragover.' + ns, this._onDragOver)
    945                 .unbind('drop.' + ns, this._onDrop)
     997                .unbind('drop.' + ns, this._onDrop);
     998            this.options.pasteZone
    946999                .unbind('paste.' + ns, this._onPaste);
    9471000            this.options.fileInput
     
    9711024            if (!(options.dropZone instanceof $)) {
    9721025                options.dropZone = $(options.dropZone);
     1026            }
     1027            if (!(options.pasteZone instanceof $)) {
     1028                options.pasteZone = $(options.pasteZone);
    9731029            }
    9741030        },
     
    9921048
    9931049        enable: function () {
     1050            var wasDisabled = false;
     1051            if (this.options.disabled) {
     1052                wasDisabled = true;
     1053            }
    9941054            $.Widget.prototype.enable.call(this);
    995             this._initEventHandlers();
     1055            if (wasDisabled) {
     1056                this._initEventHandlers();
     1057            }
    9961058        },
    9971059
    9981060        disable: function () {
    999             this._destroyEventHandlers();
     1061            if (!this.options.disabled) {
     1062                this._destroyEventHandlers();
     1063            }
    10001064            $.Widget.prototype.disable.call(this);
    10011065        },
Note: See TracChangeset for help on using the changeset viewer.