Вход Регистрация
Файл: wordpress/wp-includes/js/plupload/wp-plupload.js
Строк: 416
<?php
/* global pluploadL10n, plupload, _wpPluploadSettings */

window.wp window.wp || {};

( function( 
exports, $ ) {
    var 
Uploader;

    if ( 
typeof _wpPluploadSettings === 'undefined' ) {
        return;
    }

    
/**
     * A WordPress uploader.
     *
     * The Plupload library provides cross-browser uploader UI integration.
     * This object bridges the Plupload API to integrate uploads into the
     * WordPress back-end and the WordPress media experience.
     *
     * @param {object} options           The options passed to the new plupload instance.
     * @param {object} options.container The id of uploader container.
     * @param {object} options.browser   The id of button to trigger the file select.
     * @param {object} options.dropzone  The id of file drop target.
     * @param {object} options.plupload  An object of parameters to pass to the plupload instance.
     * @param {object} options.params    An object of parameters to pass to $_POST when uploading the file.
     *                                   Extends this.plupload.multipart_params under the hood.
     */
    
Uploader = function( options ) {
        var 
self this,
            
isIE navigator.userAgent.indexOf('Trident/') != -|| navigator.userAgent.indexOf('MSIE ') != -1,
            
elements = {
                
container'container',
                
browser:   'browse_button',
                
dropzone:  'drop_element'
            
},
            
keyerror;

        
this.supports = {
            
uploadUploader.browser.supported
        
};

        
this.supported this.supports.upload;

        if ( ! 
this.supported ) {
            return;
        }

        
// Arguments to send to pluplad.Uploader().
        // Use deep extend to ensure that multipart_params and other objects are cloned.
        
this.plupload = $.extendtrue, { multipart_params: {} }, Uploader.defaults );
        
this.container document.body// Set default container.

        // Extend the instance with options.
        //
        // Use deep extend to allow options.plupload to override individual
        // default plupload keys.
        
$.extendtruethisoptions );

        
// Proxy all methods so this always refers to the current instance.
        
for ( key in this ) {
            if ( $.
isFunctionthiskey ] ) ) {
                
thiskey ] = $.proxythiskey ], this );
            }
        }

        
// Ensure all elements are jQuery elements and have id attributes,
        // then set the proper plupload arguments to the ids.
        
for ( key in elements ) {
            if ( ! 
thiskey ] ) {
                continue;
            }

            
thiskey ] = $( thiskey ] ).first();

            if ( ! 
thiskey ].length ) {
                
delete thiskey ];
                continue;
            }

            if ( ! 
thiskey ].prop('id') ) {
                
thiskey ].prop'id''__wp-uploader-id-' Uploader.uuid++ );
            }

            
this.pluploadelementskey ] ] = thiskey ].prop('id');
        }

        
// If the uploader has neither a browse button nor a dropzone, bail.
        
if ( ! ( this.browser && this.browser.length ) && ! ( this.dropzone && this.dropzone.length ) ) {
            return;
        }

        
// Make sure flash sends cookies (seems in IE it does without switching to urlstream mode)
        
if ( ! isIE && 'flash' === plupload.predictRuntimethis.plupload ) &&
            ( ! 
this.plupload.required_features || ! this.plupload.required_features.hasOwnProperty'send_binary_string' ) ) ) {

            
this.plupload.required_features this.plupload.required_features || {};
            
this.plupload.required_features.send_binary_string true;
        }

        
// Initialize the plupload instance.
        
this.uploader = new plupload.Uploaderthis.plupload );
        
delete this.plupload;

        
// Set default params and remove this.params alias.
        
this.paramthis.params || {} );
        
delete this.params;

        
/**
         * Custom error callback.
         *
         * Add a new error to the errors collection, so other modules can track
         * and display errors. @see wp.Uploader.errors.
         *
         * @param  {string}        message
         * @param  {object}        data
         * @param  {plupload.File} file     File that was uploaded.
         */
        
error = function( messagedatafile ) {
            if ( 
file.attachment ) {
                
file.attachment.destroy();
            }

            
Uploader.errors.unshift({
                
messagemessage || pluploadL10n.default_error,
                
data:    data,
                
file:    file
            
});

            
self.errormessagedatafile );
        };

        
/**
         * After the Uploader has been initialized, initialize some behaviors for the dropzone.
         *
         * @param {plupload.Uploader} uploader Uploader instance.
         */
        
this.uploader.bind'init', function( uploader ) {
            var 
timeractivedragdrop,
                
dropzone self.dropzone;

            
dragdrop self.supports.dragdrop uploader.features.dragdrop && ! Uploader.browser.mobile;

            
// Generate drag/drop helper classes.
            
if ( ! dropzone ) {
                return;
            }

            
dropzone.toggleClass'supports-drag-drop', !! dragdrop );

            if ( ! 
dragdrop ) {
                return 
dropzone.unbind('.wp-uploader');
            }

            
// 'dragenter' doesn't fire correctly, simulate it with a limited 'dragover'.
            
dropzone.bind'dragover.wp-uploader', function() {
                if ( 
timer ) {
                    
clearTimeouttimer );
                }

                if ( 
active ) {
                    return;
                }

                
dropzone.trigger('dropzone:enter').addClass('drag-over');
                
active true;
            });

            
dropzone.bind('dragleave.wp-uploader, drop.wp-uploader', function() {
                
// Using an instant timer prevents the drag-over class from
                // being quickly removed and re-added when elements inside the
                // dropzone are repositioned.
                //
                // @see https://core.trac.wordpress.org/ticket/21705
                
timer setTimeout( function() {
                    
active false;
                    
dropzone.trigger('dropzone:leave').removeClass('drag-over');
                }, 
);
            });

            
self.ready true;
            $(
self).trigger'uploader:ready' );
        });

        
this.uploader.init();

        if ( 
this.browser ) {
            
this.browser.on'mouseenter'this.refresh );
        } else {
            
this.uploader.disableBrowsetrue );
            
// If HTML5 mode, hide the auto-created file container.
            
$('#' this.uploader.id '_html5_container').hide();
        }

        
/**
         * After files were filtered and added to the queue, create a model for each.
         *
         * @event FilesAdded
         * @param {plupload.Uploader} uploader Uploader instance.
         * @param {Array}             files    Array of file objects that were added to queue by the user.
         */
        
this.uploader.bind'FilesAdded', function( upfiles ) {
            
_.eachfiles, function( file ) {
                var 
attributesimage;

                
// Ignore failed uploads.
                
if ( plupload.FAILED === file.status ) {
                    return;
                }

                
// Generate attributes for a new `Attachment` model.
                
attributes _.extend({
                    
file:      file,
                    
uploadingtrue,
                    
date:      new Date(),
                    
filename:  file.name,
                    
menuOrder0,
                    
uploadedTowp.media.model.settings.post.id
                
}, _.pickfile'loaded''size''percent' ) );

                
// Handle early mime type scanning for images.
                
image = /(?:jpe?g|png|gif)$/i.execfile.name );

                
// For images set the model's type and subtype attributes.
                
if ( image ) {
                    
attributes.type 'image';

                    
// `jpeg`, `png` and `gif` are valid subtypes.
                    // `jpg` is not, so map it to `jpeg`.
                    
attributes.subtype = ( 'jpg' === image[0] ) ? 'jpeg' image[0];
                }

                
// Create a model for the attachment, and add it to the Upload queue collection
                // so listeners to the upload queue can track and display upload progress.
                
file.attachment wp.media.model.Attachment.createattributes );
                
Uploader.queue.addfile.attachment );

                
self.addedfile.attachment );
            });

            
up.refresh();
            
up.start();
        });

        
this.uploader.bind'UploadProgress', function( upfile ) {
            
file.attachment.set_.pickfile'loaded''percent' ) );
            
self.progressfile.attachment );
        });

        
/**
         * After a file is successfully uploaded, update its model.
         *
         * @param {plupload.Uploader} uploader Uploader instance.
         * @param {plupload.File}     file     File that was uploaded.
         * @param {Object}            response Object with response properties.
         * @return {mixed}
         */
        
this.uploader.bind'FileUploaded', function( upfileresponse ) {
            var 
complete;

            try {
                
response JSON.parseresponse.response );
            } catch ( 
) {
                return 
errorpluploadL10n.default_errorefile );
            }

            if ( ! 
_.isObjectresponse ) || _.isUndefinedresponse.success ) )
                return 
errorpluploadL10n.default_errornullfile );
            else if ( ! 
response.success )
                return 
errorresponse.data && response.data.messageresponse.datafile );

            
_.each(['file','loaded','size','percent'], function( key ) {
                
file.attachment.unset( key );
            });

            
file.attachment.set_.extendresponse.data, { uploadingfalse }) );
            
wp.media.model.Attachment.getresponse.data.idfile.attachment );

            
complete Uploader.queue.all( function( attachment ) {
                return ! 
attachment.get('uploading');
            });

            if ( 
complete )
                
Uploader.queue.reset();

            
self.successfile.attachment );
        });

        
/**
         * When plupload surfaces an error, send it to the error handler.
         *
         * @param {plupload.Uploader} uploader Uploader instance.
         * @param {Object}            error    Contains code, message and sometimes file and other details.
         */
        
this.uploader.bind'Error', function( uppluploadError ) {
            var 
message pluploadL10n.default_error,
                
key;

            
// Check for plupload errors.
            
for ( key in Uploader.errorMap ) {
                if ( 
pluploadError.code === pluploadkey ] ) {
                    
message Uploader.errorMapkey ];

                    if ( 
_.isFunctionmessage ) ) {
                        
message messagepluploadError.filepluploadError );
                    }

                    break;
                }
            }

            
errormessagepluploadErrorpluploadError.file );
            
up.refresh();
        });

        
this.uploader.bind'PostInit', function() {
            
self.init();
        });
    };

    
// Adds the 'defaults' and 'browser' properties.
    
$.extendUploader_wpPluploadSettings );

    
Uploader.uuid 0;

    
// Map Plupload error codes to user friendly error messages.
    
Uploader.errorMap = {
        
'FAILED':                 pluploadL10n.upload_failed,
        
'FILE_EXTENSION_ERROR':   pluploadL10n.invalid_filetype,
        
'IMAGE_FORMAT_ERROR':     pluploadL10n.not_an_image,
        
'IMAGE_MEMORY_ERROR':     pluploadL10n.image_memory_exceeded,
        
'IMAGE_DIMENSIONS_ERROR'pluploadL10n.image_dimensions_exceeded,
        
'GENERIC_ERROR':          pluploadL10n.upload_failed,
        
'IO_ERROR':               pluploadL10n.io_error,
        
'HTTP_ERROR':             pluploadL10n.http_error,
        
'SECURITY_ERROR':         pluploadL10n.security_error,

        
'FILE_SIZE_ERROR': function( file ) {
            return 
pluploadL10n.file_exceeds_size_limit.replace('%s'file.name);
        }
    };

    $.
extendUploader.prototype, {
        
/**
         * Acts as a shortcut to extending the uploader's multipart_params object.
         *
         * param( key )
         *    Returns the value of the key.
         *
         * param( key, value )
         *    Sets the value of a key.
         *
         * param( map )
         *    Sets values for a map of data.
         */
        
param: function( keyvalue ) {
            if ( 
arguments.length === && typeof key === 'string' ) {
                return 
this.uploader.settings.multipart_paramskey ];
            }

            if ( 
arguments.length ) {
                
this.uploader.settings.multipart_paramskey ] = value;
            } else {
                $.
extendthis.uploader.settings.multipart_paramskey );
            }
        },

        
/**
         * Make a few internal event callbacks available on the wp.Uploader object
         * to change the Uploader internals if absolutely necessary.
         */
        
init:     function() {},
        
error:    function() {},
        
success:  function() {},
        
added:    function() {},
        
progress: function() {},
        
complete: function() {},
        
refresh:  function() {
            var 
nodeattachedcontainerid;

            if ( 
this.browser ) {
                
node this.browser[0];

                
// Check if the browser node is in the DOM.
                
while ( node ) {
                    if ( 
node === document.body ) {
                        
attached true;
                        break;
                    }
                    
node node.parentNode;
                }

                
// If the browser node is not attached to the DOM, use a
                // temporary container to house it, as the browser button
                // shims require the button to exist in the DOM at all times.
                
if ( ! attached ) {
                    
id 'wp-uploader-browser-' this.uploader.id;

                    
container = $( '#' id );
                    if ( ! 
container.length ) {
                        
container = $('<div class="wp-uploader-browser" />').css({
                            
position'fixed',
                            
top'-1000px',
                            
left'-1000px',
                            
height0,
                            
width0
                        
}).attr'id''wp-uploader-browser-' this.uploader.id ).appendTo('body');
                    }

                    
container.appendthis.browser );
                }
            }

            
this.uploader.refresh();
        }
    });

    
// Create a collection of attachments in the upload queue,
    // so that other modules can track and display upload progress.
    
Uploader.queue = new wp.media.model.Attachments( [], { queryfalse });

    
// Create a collection to collect errors incurred while attempting upload.
    
Uploader.errors = new Backbone.Collection();

    
exports.Uploader Uploader;
})( 
wpjQuery );
?>
Онлайн: 0
Реклама