jQuery file upload process to upload pictures

First trigger _onChange] [jquery.fileupload.js

_onChange: function (e) {
var that = this,
data = {
fileInput: $(e.target),
form: $(e.target.form)
};
this._getFileInputFiles(data.fileInput).always(function (files) {
data.files = files;
if (that.options.replaceFileInput) {
that._replaceFileInput(data);
}
if (that._trigger(
'change',
$.Event('change', {delegatedEvent: e}),
data
) !== false) {
that._onAdd(e, data);
}
});
},

Then trigger _onAdd] [jquery.fileupload.js

$.each(fileSet || files, function (index, element) {
var newData = $.extend({}, data);
newData.files = fileSet ? element : [element];
newData.paramName = paramNameSet[index];
that._initResponseObject(newData);
that._initProgressObject(newData);
that._addConvenienceMethods(e, newData);
result = that._trigger(
'add',
$.Event('add', {delegatedEvent: e}),
newData
);
return result;
});

Then trigger add [jquery.fileupload-process.js]

add: function (e, data) {
var $this = $(this);
data.process(function () {
return $this.fileupload('process', data);
});
originalAdd.call(this, e, data);
}

Then data.process] [jquery.fileupload.js

// Adds convenience methods to the data callback argument:
_addConvenienceMethods: function (e, data) {
var that = this,
getPromise = function (args) {
return $.Deferred().resolveWith(that, args).promise();
};
data.process = function (resolveFunc, rejectFunc) {
if (resolveFunc || rejectFunc) {
data._processQueue = this._processQueue =
(this._processQueue || getPromise([this])).then(
function () {
if (data.errorThrown) {
return $.Deferred()
.rejectWith(that, [data]).promise();
}
return getPromise(arguments);
}
).then(resolveFunc, rejectFunc);
}
return this._processQueue || getPromise([this]);
};

then the definition in [] jquery.js

then: function( /* fnDone, fnFail, fnProgress */ ) {
var fns = arguments;
return jQuery.Deferred(function( newDefer ) {
jQuery.each( tuples, function( i, tuple ) {
var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
// deferred[ done | fail | progress ] for forwarding actions to newDefer
deferred[ tuple[1] ](function() {
var returned = fn && fn.apply( this, arguments );
if ( returned && jQuery.isFunction( returned.promise ) ) {
returned.promise()
.done( newDefer.resolve )
.fail( newDefer.reject )
.progress( newDefer.notify );
} else {
newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
}
});
});
fns = null;
}).promise();
},

Then back to add function before calling $ this.fileupload

add: function (e, data) {
var $this = $(this);
data.process(function () {
return $this.fileupload('process', data);
});
originalAdd.call(this, e, data);
}

[Then] jquery.fileupload-process.js

// Processes the files given as files property of the data parameter,
// returns a Promise object that allows to bind callbacks:
process: function (data) {
var that = this,
options = $.extend({}, this.options, data);
if (options.processQueue && options.processQueue.length) {
this._transformProcessQueue(options);

Or [jquery.fileupload-process.js]

// Replaces the settings of each processQueue item that
// are strings starting with an "@", using the remaining
// substring as key for the option map,
// e.g. "@autoUpload" is replaced with options.autoUpload:
_transformProcessQueue: function (options) {
var processQueue = [];

Then back] [jquery.fileupload.js

// The add callback is invoked as soon as files are added to the fileupload
// widget (via file input selection, drag & drop, paste or add API call).
// If the singleFileUploads option is enabled, this callback will be
// called once for each file in the selection for XHR file uploads, else
// once for each file selection.
//
// The upload starts when the submit method is invoked on the data parameter.
// The data object contains a files property holding the added files
// and allows you to override plugin options as well as define ajax settings.
//
// Listeners for this callback can also be bound the following way:
// .bind('fileuploadadd', func);
//
// data.submit() returns a Promise object and allows to attach additional
// handlers using jQuery's Deferred callbacks:
// data.submit().done(func).fail(func).always(func);
add: function (e, data) {
if (e.isDefaultPrevented()) {
return false;
}

Go back

add: function (e, data) {
var $this = $(this);
data.process(function () {
return $this.fileupload('process', data);
});
originalAdd.call(this, e, data);
}

 

 

on('fileuploadadd', function (e, data) {
console.log(data.files);
console.log(data.files.length);
// add a <div/> under files container
data.context = $('<div/>').appendTo('#files');
$.each(data.files, function (index, file) {
console.log(index);
console.log(file);
//add a <p/> under div
var node = $('<p/>')
.append($('<span/>').text(file.name));

var flag = !index;
console.log(flag);
if (flag) {
//if upload multi files and split them by <br/>
node
.append('<br>')
//clone a button
.append(uploadButton.clone(true).data(data));
}
node.appendTo(data.context);
});

 

The image preview function by jquery.fileupload-image.js defined inside processQueue automatically processed

$.blueimp.fileupload.prototype.options.processQueue.unshift(
    {
        action: 'loadImageMetaData',
        disableImageHead: '@',
        disableExif: '@',
        disableExifThumbnail: '@',
        disableExifSub: '@',
        disableExifGps: '@',
        disabled: '@disableImageMetaDataLoad'
    },

 processQueue dependent on the definition of jquery.fileupload-process.js

$.widget('blueimp.fileupload', $.blueimp.fileupload, {

    options: {
        // The list of processing actions:
        processQueue: [
            /*
            {
                action: 'log',
                type: 'debug'
            }
            */
        ],

loadImage.parseMetaData Yi 赖于 load-image-meta.js medium-specific parseMetaData

loadImageMetaData: function (data, options) {
    if (options.disabled) {
        return data;
    }
    var that = this,
        dfd = $.Deferred();
    loadImage.parseMetaData(data.files[data.index], function (result) {
        $.extend(data, result);
        dfd.resolveWith(that, [data]);
    }, options);
    return dfd.promise();
},

load-image-meta.js is dependent on the load-image.js loadImage.blobSlice

jquery.fileupload-image.js in resizeImage function is dependent on loadImage.scale load-image-scale.js

if (img) {
resolve(loadImage.scale(img, options));
return dfd.promise();
}