Subversion-Projekte lars-tiefland.webanos.zeldi.de

/*

 * jQuery File Upload Image Preview & Resize Plugin

 * https://github.com/blueimp/jQuery-File-Upload

 *

 * Copyright 2013, Sebastian Tschan

 * https://blueimp.net

 *

 * Licensed under the MIT license:

 * https://opensource.org/licenses/MIT

 */

/* global define, require */

(function (factory) {

  'use strict';

  if (typeof define === 'function' && define.amd) {

    // Register as an anonymous AMD module:

    define([

      'jquery',

      'load-image',

      'load-image-meta',

      'load-image-scale',

      'load-image-exif',

      'load-image-orientation',

      'canvas-to-blob',

      './jquery.fileupload-process'

    ], factory);

  } else if (typeof exports === 'object') {

    // Node/CommonJS:

    factory(

      require('jquery'),

      require('blueimp-load-image/js/load-image'),

      require('blueimp-load-image/js/load-image-meta'),

      require('blueimp-load-image/js/load-image-scale'),

      require('blueimp-load-image/js/load-image-exif'),

      require('blueimp-load-image/js/load-image-orientation'),

      require('blueimp-canvas-to-blob'),

      require('./jquery.fileupload-process')

    );

  } else {

    // Browser globals:

    factory(window.jQuery, window.loadImage);

  }

})(function ($, loadImage) {

  'use strict';

  // Prepend to the default processQueue:

  $.blueimp.fileupload.prototype.options.processQueue.unshift(

    {

      action: 'loadImageMetaData',

      maxMetaDataSize: '@',

      disableImageHead: '@',

      disableMetaDataParsers: '@',

      disableExif: '@',

      disableExifOffsets: '@',

      includeExifTags: '@',

      excludeExifTags: '@',

      disableIptc: '@',

      disableIptcOffsets: '@',

      includeIptcTags: '@',

      excludeIptcTags: '@',

      disabled: '@disableImageMetaDataLoad'

    },

    {

      action: 'loadImage',

      // Use the action as prefix for the "@" options:

      prefix: true,

      fileTypes: '@',

      maxFileSize: '@',

      noRevoke: '@',

      disabled: '@disableImageLoad'

    },

    {

      action: 'resizeImage',

      // Use "image" as prefix for the "@" options:

      prefix: 'image',

      maxWidth: '@',

      maxHeight: '@',

      minWidth: '@',

      minHeight: '@',

      crop: '@',

      orientation: '@',

      forceResize: '@',

      disabled: '@disableImageResize',

      imageSmoothingQuality: '@imageSmoothingQuality'

    },

    {

      action: 'saveImage',

      quality: '@imageQuality',

      type: '@imageType',

      disabled: '@disableImageResize'

    },

    {

      action: 'saveImageMetaData',

      disabled: '@disableImageMetaDataSave'

    },

    {

      action: 'resizeImage',

      // Use "preview" as prefix for the "@" options:

      prefix: 'preview',

      maxWidth: '@',

      maxHeight: '@',

      minWidth: '@',

      minHeight: '@',

      crop: '@',

      orientation: '@',

      thumbnail: '@',

      canvas: '@',

      disabled: '@disableImagePreview'

    },

    {

      action: 'setImage',

      name: '@imagePreviewName',

      disabled: '@disableImagePreview'

    },

    {

      action: 'deleteImageReferences',

      disabled: '@disableImageReferencesDeletion'

    }

  );

  // The File Upload Resize plugin extends the fileupload widget

  // with image resize functionality:

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

    options: {

      // The regular expression for the types of images to load:

      // matched against the file type:

      loadImageFileTypes: /^image\/(gif|jpeg|png|svg\+xml)$/,

      // The maximum file size of images to load:

      loadImageMaxFileSize: 10000000, // 10MB

      // The maximum width of resized images:

      imageMaxWidth: 1920,

      // The maximum height of resized images:

      imageMaxHeight: 1080,

      // Defines the image orientation (1-8) or takes the orientation

      // value from Exif data if set to true:

      imageOrientation: true,

      // Define if resized images should be cropped or only scaled:

      imageCrop: false,

      // Disable the resize image functionality by default:

      disableImageResize: true,

      // The maximum width of the preview images:

      previewMaxWidth: 80,

      // The maximum height of the preview images:

      previewMaxHeight: 80,

      // Defines the preview orientation (1-8) or takes the orientation

      // value from Exif data if set to true:

      previewOrientation: true,

      // Create the preview using the Exif data thumbnail:

      previewThumbnail: true,

      // Define if preview images should be cropped or only scaled:

      previewCrop: false,

      // Define if preview images should be resized as canvas elements:

      previewCanvas: true

    },

    processActions: {

      // Loads the image given via data.files and data.index

      // as img element, if the browser supports the File API.

      // Accepts the options fileTypes (regular expression)

      // and maxFileSize (integer) to limit the files to load:

      loadImage: function (data, options) {

        if (options.disabled) {

          return data;

        }

        var that = this,

          file = data.files[data.index],

          // eslint-disable-next-line new-cap

          dfd = $.Deferred();

        if (

          ($.type(options.maxFileSize) === 'number' &&

            file.size > options.maxFileSize) ||

          (options.fileTypes && !options.fileTypes.test(file.type)) ||

          !loadImage(

            file,

            function (img) {

              if (img.src) {

                data.img = img;

              }

              dfd.resolveWith(that, [data]);

            },

            options

          )

        ) {

          return data;

        }

        return dfd.promise();

      },

      // Resizes the image given as data.canvas or data.img

      // and updates data.canvas or data.img with the resized image.

      // Also stores the resized image as preview property.

      // Accepts the options maxWidth, maxHeight, minWidth,

      // minHeight, canvas and crop:

      resizeImage: function (data, options) {

        if (options.disabled || !(data.canvas || data.img)) {

          return data;

        }

        // eslint-disable-next-line no-param-reassign

        options = $.extend({ canvas: true }, options);

        var that = this,

          // eslint-disable-next-line new-cap

          dfd = $.Deferred(),

          img = (options.canvas && data.canvas) || data.img,

          resolve = function (newImg) {

            if (

              newImg &&

              (newImg.width !== img.width ||

                newImg.height !== img.height ||

                options.forceResize)

            ) {

              data[newImg.getContext ? 'canvas' : 'img'] = newImg;

            }

            data.preview = newImg;

            dfd.resolveWith(that, [data]);

          },

          thumbnail,

          thumbnailBlob;

        if (data.exif && options.thumbnail) {

          thumbnail = data.exif.get('Thumbnail');

          thumbnailBlob = thumbnail && thumbnail.get('Blob');

          if (thumbnailBlob) {

            options.orientation = data.exif.get('Orientation');

            loadImage(thumbnailBlob, resolve, options);

            return dfd.promise();

          }

        }

        if (data.orientation) {

          // Prevent orienting the same image twice:

          delete options.orientation;

        } else {

          data.orientation = options.orientation || loadImage.orientation;

        }

        if (img) {

          resolve(loadImage.scale(img, options, data));

          return dfd.promise();

        }

        return data;

      },

      // Saves the processed image given as data.canvas

      // inplace at data.index of data.files:

      saveImage: function (data, options) {

        if (!data.canvas || options.disabled) {

          return data;

        }

        var that = this,

          file = data.files[data.index],

          // eslint-disable-next-line new-cap

          dfd = $.Deferred();

        if (data.canvas.toBlob) {

          data.canvas.toBlob(

            function (blob) {

              if (!blob.name) {

                if (file.type === blob.type) {

                  blob.name = file.name;

                } else if (file.name) {

                  blob.name = file.name.replace(

                    /\.\w+$/,

                    '.' + blob.type.substr(6)

                  );

                }

              }

              // Don't restore invalid meta data:

              if (file.type !== blob.type) {

                delete data.imageHead;

              }

              // Store the created blob at the position

              // of the original file in the files list:

              data.files[data.index] = blob;

              dfd.resolveWith(that, [data]);

            },

            options.type || file.type,

            options.quality

          );

        } else {

          return data;

        }

        return dfd.promise();

      },

      loadImageMetaData: function (data, options) {

        if (options.disabled) {

          return data;

        }

        var that = this,

          // eslint-disable-next-line new-cap

          dfd = $.Deferred();

        loadImage.parseMetaData(

          data.files[data.index],

          function (result) {

            $.extend(data, result);

            dfd.resolveWith(that, [data]);

          },

          options

        );

        return dfd.promise();

      },

      saveImageMetaData: function (data, options) {

        if (

          !(

            data.imageHead &&

            data.canvas &&

            data.canvas.toBlob &&

            !options.disabled

          )

        ) {

          return data;

        }

        var that = this,

          file = data.files[data.index],

          // eslint-disable-next-line new-cap

          dfd = $.Deferred();

        if (data.orientation === true && data.exifOffsets) {

          // Reset Exif Orientation data:

          loadImage.writeExifData(data.imageHead, data, 'Orientation', 1);

        }

        loadImage.replaceHead(file, data.imageHead, function (blob) {

          blob.name = file.name;

          data.files[data.index] = blob;

          dfd.resolveWith(that, [data]);

        });

        return dfd.promise();

      },

      // Sets the resized version of the image as a property of the

      // file object, must be called after "saveImage":

      setImage: function (data, options) {

        if (data.preview && !options.disabled) {

          data.files[data.index][options.name || 'preview'] = data.preview;

        }

        return data;

      },

      deleteImageReferences: function (data, options) {

        if (!options.disabled) {

          delete data.img;

          delete data.canvas;

          delete data.preview;

          delete data.imageHead;

        }

        return data;

      }

    }

  });

});