jquery-file-upload-rails 1.0.0

data/vendor/assets/javascripts/jquery-file-upload/vendor/load-image/load-image-meta.js

@@ -0,0 +1,137 @@
+/*
+ * JavaScript Load Image Meta 1.0.1
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Image meta data handling implementation
+ * based on the help and contribution of
+ * Achim Stöhr.
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint continue:true */
+/*global define, window, DataView, Blob, Uint8Array, console */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define(['load-image'], factory);
+    } else {
+        // Browser globals:
+        factory(window.loadImage);
+    }
+}(function (loadImage) {
+    'use strict';
+
+    var hasblobSlice = window.Blob && (Blob.prototype.slice ||
+            Blob.prototype.webkitSlice || Blob.prototype.mozSlice);
+
+    loadImage.blobSlice = hasblobSlice && function () {
+        var slice = this.slice || this.webkitSlice || this.mozSlice;
+        return slice.apply(this, arguments);
+    };
+
+    loadImage.metaDataParsers = {
+        jpeg: {
+            0xffe1: [] // APP1 marker
+        }
+    };
+
+    // Parses image meta data and calls the callback with an object argument
+    // with the following properties:
+    // * imageHead: The complete image head as ArrayBuffer (Uint8Array for IE10)
+    // The options arguments accepts an object and supports the following properties:
+    // * maxMetaDataSize: Defines the maximum number of bytes to parse.
+    // * disableImageHead: Disables creating the imageHead property.
+    loadImage.parseMetaData = function (file, callback, options) {
+        options = options || {};
+        var that = this,
+            // 256 KiB should contain all EXIF/ICC/IPTC segments:
+            maxMetaDataSize = options.maxMetaDataSize || 262144,
+            data = {},
+            noMetaData = !(window.DataView  && file && file.size >= 12 &&
+                file.type === 'image/jpeg' && loadImage.blobSlice);
+        if (noMetaData || !loadImage.readFile(
+                loadImage.blobSlice.call(file, 0, maxMetaDataSize),
+                function (e) {
+                    // Note on endianness:
+                    // Since the marker and length bytes in JPEG files are always
+                    // stored in big endian order, we can leave the endian parameter
+                    // of the DataView methods undefined, defaulting to big endian.
+                    var buffer = e.target.result,
+                        dataView = new DataView(buffer),
+                        offset = 2,
+                        maxOffset = dataView.byteLength - 4,
+                        headLength = offset,
+                        markerBytes,
+                        markerLength,
+                        parsers,
+                        i;
+                    // Check for the JPEG marker (0xffd8):
+                    if (dataView.getUint16(0) === 0xffd8) {
+                        while (offset < maxOffset) {
+                            markerBytes = dataView.getUint16(offset);
+                            // Search for APPn (0xffeN) and COM (0xfffe) markers,
+                            // which contain application-specific meta-data like
+                            // Exif, ICC and IPTC data and text comments:
+                            if ((markerBytes >= 0xffe0 && markerBytes <= 0xffef) ||
+                                    markerBytes === 0xfffe) {
+                                // The marker bytes (2) are always followed by
+                                // the length bytes (2), indicating the length of the
+                                // marker segment, which includes the length bytes,
+                                // but not the marker bytes, so we add 2:
+                                markerLength = dataView.getUint16(offset + 2) + 2;
+                                if (offset + markerLength > dataView.byteLength) {
+                                    console.log('Invalid meta data: Invalid segment size.');
+                                    break;
+                                }
+                                parsers = loadImage.metaDataParsers.jpeg[markerBytes];
+                                if (parsers) {
+                                    for (i = 0; i < parsers.length; i += 1) {
+                                        parsers[i].call(
+                                            that,
+                                            dataView,
+                                            offset,
+                                            markerLength,
+                                            data,
+                                            options
+                                        );
+                                    }
+                                }
+                                offset += markerLength;
+                                headLength = offset;
+                            } else {
+                                // Not an APPn or COM marker, probably safe to
+                                // assume that this is the end of the meta data
+                                break;
+                            }
+                        }
+                        // Meta length must be longer than JPEG marker (2)
+                        // plus APPn marker (2), followed by length bytes (2):
+                        if (!options.disableImageHead && headLength > 6) {
+                            if (buffer.slice) {
+                                data.imageHead = buffer.slice(0, headLength);
+                            } else {
+                                // Workaround for IE10, which does not yet
+                                // support ArrayBuffer.slice:
+                                data.imageHead = new Uint8Array(buffer)
+                                    .subarray(0, headLength);
+                            }
+                        }
+                    } else {
+                        console.log('Invalid JPEG file: Missing JPEG marker.');
+                    }
+                    callback(data);
+                },
+                'readAsArrayBuffer'
+            )) {
+            callback(data);
+        }
+    };
+
+}));

data/vendor/assets/javascripts/jquery-file-upload/vendor/load-image/load-image-orientation.js

@@ -0,0 +1,159 @@
+/*
+ * JavaScript Load Image Orientation 1.0.0
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*global define, window */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define(['load-image'], factory);
+    } else {
+        // Browser globals:
+        factory(window.loadImage);
+    }
+}(function (loadImage) {
+    'use strict';
+
+    var originalHasCanvasOptionMethod = loadImage.hasCanvasOption;
+
+    // This method is used to determine if the target image
+    // should be a canvas element:
+    loadImage.hasCanvasOption = function (options) {
+        return originalHasCanvasOptionMethod(options) || options.orientation;
+    };
+
+    // Transform image orientation based on
+    // the given EXIF orientation option:
+    loadImage.transformCoordinates = function (canvas, options) {
+        var ctx = canvas.getContext('2d'),
+            width = canvas.width,
+            height = canvas.height,
+            orientation = options.orientation;
+        if (!orientation) {
+            return;
+        }
+        if (orientation > 4) {
+            canvas.width = height;
+            canvas.height = width;
+        }
+        switch (orientation) {
+        case 2:
+            // horizontal flip
+            ctx.translate(width, 0);
+            ctx.scale(-1, 1);
+            break;
+        case 3:
+            // 180° rotate left
+            ctx.translate(width, height);
+            ctx.rotate(Math.PI);
+            break;
+        case 4:
+            // vertical flip
+            ctx.translate(0, height);
+            ctx.scale(1, -1);
+            break;
+        case 5:
+            // vertical flip + 90 rotate right
+            ctx.rotate(0.5 * Math.PI);
+            ctx.scale(1, -1);
+            break;
+        case 6:
+            // 90° rotate right
+            ctx.rotate(0.5 * Math.PI);
+            ctx.translate(0, -height);
+            break;
+        case 7:
+            // horizontal flip + 90 rotate right
+            ctx.rotate(0.5 * Math.PI);
+            ctx.translate(width, -height);
+            ctx.scale(-1, 1);
+            break;
+        case 8:
+            // 90° rotate left
+            ctx.rotate(-0.5 * Math.PI);
+            ctx.translate(-width, 0);
+            break;
+        }
+    };
+
+    // Transforms coordinate and dimension options
+    // based on the given orientation option:
+    loadImage.getTransformedOptions = function (options) {
+        if (!options.orientation || options.orientation === 1) {
+            return options;
+        }
+        var newOptions = {},
+            i;
+        for (i in options) {
+            if (options.hasOwnProperty(i)) {
+                newOptions[i] = options[i];
+            }
+        }
+        switch (options.orientation) {
+        case 2:
+            // horizontal flip
+            newOptions.left = options.right;
+            newOptions.right = options.left;
+            break;
+        case 3:
+            // 180° rotate left
+            newOptions.left = options.right;
+            newOptions.top = options.bottom;
+            newOptions.right = options.left;
+            newOptions.bottom = options.top;
+            break;
+        case 4:
+            // vertical flip
+            newOptions.top = options.bottom;
+            newOptions.bottom = options.top;
+            break;
+        case 5:
+            // vertical flip + 90 rotate right
+            newOptions.left = options.top;
+            newOptions.top = options.left;
+            newOptions.right = options.bottom;
+            newOptions.bottom = options.right;
+            break;
+        case 6:
+            // 90° rotate right
+            newOptions.left = options.top;
+            newOptions.top = options.right;
+            newOptions.right = options.bottom;
+            newOptions.bottom = options.left;
+            break;
+        case 7:
+            // horizontal flip + 90 rotate right
+            newOptions.left = options.bottom;
+            newOptions.top = options.right;
+            newOptions.right = options.top;
+            newOptions.bottom = options.left;
+            break;
+        case 8:
+            // 90° rotate left
+            newOptions.left = options.bottom;
+            newOptions.top = options.left;
+            newOptions.right = options.top;
+            newOptions.bottom = options.right;
+            break;
+        }
+        if (options.orientation > 4) {
+            newOptions.maxWidth = options.maxHeight;
+            newOptions.maxHeight = options.maxWidth;
+            newOptions.minWidth = options.minHeight;
+            newOptions.minHeight = options.minWidth;
+            newOptions.sourceWidth = options.sourceHeight;
+            newOptions.sourceHeight = options.sourceWidth;
+        }
+        return newOptions;
+    };
+
+}));

data/vendor/assets/javascripts/jquery-file-upload/vendor/load-image/load-image.js

@@ -0,0 +1,276 @@
+/*
+ * JavaScript Load Image 1.9.0
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2011, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint nomen: true */
+/*global define, window, document, URL, webkitURL, Blob, File, FileReader */
+
+(function ($) {
+    'use strict';
+
+    // Loads an image for a given File object.
+    // Invokes the callback with an img or optional canvas
+    // element (if supported by the browser) as parameter:
+    var loadImage = function (file, callback, options) {
+            var img = document.createElement('img'),
+                url,
+                oUrl;
+            img.onerror = callback;
+            img.onload = function () {
+                if (oUrl && !(options && options.noRevoke)) {
+                    loadImage.revokeObjectURL(oUrl);
+                }
+                if (callback) {
+                    callback(loadImage.scale(img, options));
+                }
+            };
+            if (loadImage.isInstanceOf('Blob', file) ||
+                    // Files are also Blob instances, but some browsers
+                    // (Firefox 3.6) support the File API but not Blobs:
+                    loadImage.isInstanceOf('File', file)) {
+                url = oUrl = loadImage.createObjectURL(file);
+                // Store the file type for resize processing:
+                img._type = file.type;
+            } else if (typeof file === 'string') {
+                url = file;
+                if (options && options.crossOrigin) {
+                    img.crossOrigin = options.crossOrigin;
+                }
+            } else {
+                return false;
+            }
+            if (url) {
+                img.src = url;
+                return img;
+            }
+            return loadImage.readFile(file, function (e) {
+                var target = e.target;
+                if (target && target.result) {
+                    img.src = target.result;
+                } else {
+                    if (callback) {
+                        callback(e);
+                    }
+                }
+            });
+        },
+        // The check for URL.revokeObjectURL fixes an issue with Opera 12,
+        // which provides URL.createObjectURL but doesn't properly implement it:
+        urlAPI = (window.createObjectURL && window) ||
+            (window.URL && URL.revokeObjectURL && URL) ||
+            (window.webkitURL && webkitURL);
+
+    loadImage.isInstanceOf = function (type, obj) {
+        // Cross-frame instanceof check
+        return Object.prototype.toString.call(obj) === '[object ' + type + ']';
+    };
+
+    // Transform image coordinates, allows to override e.g.
+    // the canvas orientation based on the orientation option,
+    // gets canvas, options passed as arguments:
+    loadImage.transformCoordinates = function () {
+        return;
+    };
+
+    // Returns transformed options, allows to override e.g.
+    // coordinate and dimension options based on the orientation:
+    loadImage.getTransformedOptions = function (options) {
+        return options;
+    };
+
+    // Canvas render method, allows to override the
+    // rendering e.g. to work around issues on iOS:
+    loadImage.renderImageToCanvas = function (
+        canvas,
+        img,
+        sourceX,
+        sourceY,
+        sourceWidth,
+        sourceHeight,
+        destX,
+        destY,
+        destWidth,
+        destHeight
+    ) {
+        canvas.getContext('2d').drawImage(
+            img,
+            sourceX,
+            sourceY,
+            sourceWidth,
+            sourceHeight,
+            destX,
+            destY,
+            destWidth,
+            destHeight
+        );
+        return canvas;
+    };
+
+    // This method is used to determine if the target image
+    // should be a canvas element:
+    loadImage.hasCanvasOption = function (options) {
+        return options.canvas || options.crop;
+    };
+
+    // Scales and/or crops the given image (img or canvas HTML element)
+    // using the given options.
+    // Returns a canvas object if the browser supports canvas
+    // and the hasCanvasOption method returns true or a canvas
+    // object is passed as image, else the scaled image:
+    loadImage.scale = function (img, options) {
+        options = options || {};
+        var canvas = document.createElement('canvas'),
+            useCanvas = img.getContext ||
+                (loadImage.hasCanvasOption(options) && canvas.getContext),
+            width = img.naturalWidth || img.width,
+            height = img.naturalHeight || img.height,
+            destWidth = width,
+            destHeight = height,
+            maxWidth,
+            maxHeight,
+            minWidth,
+            minHeight,
+            sourceWidth,
+            sourceHeight,
+            sourceX,
+            sourceY,
+            tmp,
+            scaleUp = function () {
+                var scale = Math.max(
+                    (minWidth || destWidth) / destWidth,
+                    (minHeight || destHeight) / destHeight
+                );
+                if (scale > 1) {
+                    destWidth = Math.ceil(destWidth * scale);
+                    destHeight = Math.ceil(destHeight * scale);
+                }
+            },
+            scaleDown = function () {
+                var scale = Math.min(
+                    (maxWidth || destWidth) / destWidth,
+                    (maxHeight || destHeight) / destHeight
+                );
+                if (scale < 1) {
+                    destWidth = Math.ceil(destWidth * scale);
+                    destHeight = Math.ceil(destHeight * scale);
+                }
+            };
+        if (useCanvas) {
+            options = loadImage.getTransformedOptions(options);
+            sourceX = options.left || 0;
+            sourceY = options.top || 0;
+            if (options.sourceWidth) {
+                sourceWidth = options.sourceWidth;
+                if (options.right !== undefined && options.left === undefined) {
+                    sourceX = width - sourceWidth - options.right;
+                }
+            } else {
+                sourceWidth = width - sourceX - (options.right || 0);
+            }
+            if (options.sourceHeight) {
+                sourceHeight = options.sourceHeight;
+                if (options.bottom !== undefined && options.top === undefined) {
+                    sourceY = height - sourceHeight - options.bottom;
+                }
+            } else {
+                sourceHeight = height - sourceY - (options.bottom || 0);
+            }
+            destWidth = sourceWidth;
+            destHeight = sourceHeight;
+        }
+        maxWidth = options.maxWidth;
+        maxHeight = options.maxHeight;
+        minWidth = options.minWidth;
+        minHeight = options.minHeight;
+        if (useCanvas && maxWidth && maxHeight && options.crop) {
+            destWidth = maxWidth;
+            destHeight = maxHeight;
+            tmp = sourceWidth / sourceHeight - maxWidth / maxHeight;
+            if (tmp < 0) {
+                sourceHeight = maxHeight * sourceWidth / maxWidth;
+                if (options.top === undefined && options.bottom === undefined) {
+                    sourceY = (height - sourceHeight) / 2;
+                }
+            } else if (tmp > 0) {
+                sourceWidth = maxWidth * sourceHeight / maxHeight;
+                if (options.left === undefined && options.right === undefined) {
+                    sourceX = (width - sourceWidth) / 2;
+                }
+            }
+        } else {
+            if (options.contain || options.cover) {
+                minWidth = maxWidth = maxWidth || minWidth;
+                minHeight = maxHeight = maxHeight || minHeight;
+            }
+            if (options.cover) {
+                scaleDown();
+                scaleUp();
+            } else {
+                scaleUp();
+                scaleDown();
+            }
+        }
+        if (useCanvas) {
+            canvas.width = destWidth;
+            canvas.height = destHeight;
+            loadImage.transformCoordinates(
+                canvas,
+                options
+            );
+            return loadImage.renderImageToCanvas(
+                canvas,
+                img,
+                sourceX,
+                sourceY,
+                sourceWidth,
+                sourceHeight,
+                0,
+                0,
+                destWidth,
+                destHeight
+            );
+        }
+        img.width = destWidth;
+        img.height = destHeight;
+        return img;
+    };
+
+    loadImage.createObjectURL = function (file) {
+        return urlAPI ? urlAPI.createObjectURL(file) : false;
+    };
+
+    loadImage.revokeObjectURL = function (url) {
+        return urlAPI ? urlAPI.revokeObjectURL(url) : false;
+    };
+
+    // Loads a given File object via FileReader interface,
+    // invokes the callback with the event object (load or error).
+    // The result can be read via event.target.result:
+    loadImage.readFile = function (file, callback, method) {
+        if (window.FileReader) {
+            var fileReader = new FileReader();
+            fileReader.onload = fileReader.onerror = callback;
+            method = method || 'readAsDataURL';
+            if (fileReader[method]) {
+                fileReader[method](file);
+                return fileReader;
+            }
+        }
+        return false;
+    };
+
+    if (typeof define === 'function' && define.amd) {
+        define(function () {
+            return loadImage;
+        });
+    } else {
+        $.loadImage = loadImage;
+    }
+}(this));