blueimp-load-image-rails 1.8.0

data/vendor/assets/javascripts/load-image-ios.js

@@ -0,0 +1,174 @@
+/*
+ * JavaScript Load Image iOS scaling fixes 1.0.0
+ * https://github.com/blueimp/JavaScript-Load-Image
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * iOS image scaling fixes based on
+ * https://github.com/stomita/ios-imagefile-megapixel
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/*jslint nomen: true, bitwise: true */
+/*global define, window, document */
+
+(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';
+
+    // Only apply fixes on the iOS platform:
+    if (!window.navigator || !window.navigator.platform ||
+             !(/iP(hone|od|ad)/).test(window.navigator.platform)) {
+        return;
+    }
+
+    var originalRenderMethod = loadImage.renderImageToCanvas;
+
+    // Detects subsampling in JPEG images:
+    loadImage.detectSubsampling = function (img) {
+        var canvas,
+            context;
+        if (img.width * img.height > 1024 * 1024) { // only consider mexapixel images
+            canvas = document.createElement('canvas');
+            canvas.width = canvas.height = 1;
+            context = canvas.getContext('2d');
+            context.drawImage(img, -img.width + 1, 0);
+            // subsampled image becomes half smaller in rendering size.
+            // check alpha channel value to confirm image is covering edge pixel or not.
+            // if alpha value is 0 image is not covering, hence subsampled.
+            return context.getImageData(0, 0, 1, 1).data[3] === 0;
+        }
+        return false;
+    };
+
+    // Detects vertical squash in JPEG images:
+    loadImage.detectVerticalSquash = function (img, correctedHeight) {
+        var canvas = document.createElement('canvas'),
+            context = canvas.getContext('2d'),
+            data,
+            sy,
+            ey,
+            py,
+            alpha;
+        canvas.width = 1;
+        canvas.height = correctedHeight;
+        context.drawImage(img, 0, 0);
+        data = context.getImageData(0, 0, 1, correctedHeight).data;
+        // search image edge pixel position in case it is squashed vertically:
+        sy = 0;
+        ey = correctedHeight;
+        py = correctedHeight;
+        while (py > sy) {
+            alpha = data[(py - 1) * 4 + 3];
+            if (alpha === 0) {
+                ey = py;
+            } else {
+                sy = py;
+            }
+            py = (ey + sy) >> 1;
+        }
+        return (py / correctedHeight) || 1;
+    };
+
+    // Renders image to canvas while working around iOS image scaling bugs:
+    // https://github.com/blueimp/JavaScript-Load-Image/issues/13
+    loadImage.renderImageToCanvas = function (
+        canvas,
+        img,
+        sourceX,
+        sourceY,
+        sourceWidth,
+        sourceHeight,
+        destX,
+        destY,
+        destWidth,
+        destHeight
+    ) {
+        if (img._type === 'image/jpeg') {
+            var context = canvas.getContext('2d'),
+                tmpCanvas = document.createElement('canvas'),
+                tileSize = 1024,
+                tmpContext = tmpCanvas.getContext('2d'),
+                subSampled,
+                vertSquashRatio,
+                tileX,
+                tileY;
+            tmpCanvas.width = tileSize;
+            tmpCanvas.height = tileSize;
+            context.save();
+            subSampled = loadImage.detectSubsampling(img);
+            if (subSampled) {
+                sourceWidth /= 2;
+                sourceHeight /= 2;
+            }
+            vertSquashRatio = loadImage.detectVerticalSquash(img, sourceHeight);
+            if (subSampled && vertSquashRatio !== 1) {
+                destWidth = Math.ceil(tileSize * destWidth / sourceWidth);
+                destHeight = Math.ceil(
+                    tileSize * destHeight / sourceHeight / vertSquashRatio
+                );
+                destY = 0;
+                tileY = 0;
+                while (tileY < sourceHeight) {
+                    destX = 0;
+                    tileX = 0;
+                    while (tileX < sourceWidth) {
+                        tmpContext.clearRect(0, 0, tileSize, tileSize);
+                        tmpContext.drawImage(
+                            img,
+                            sourceX,
+                            sourceY,
+                            sourceWidth,
+                            sourceHeight,
+                            -tileX,
+                            -tileY,
+                            sourceWidth,
+                            sourceHeight
+                        );
+                        context.drawImage(
+                            tmpCanvas,
+                            0,
+                            0,
+                            tileSize,
+                            tileSize,
+                            destX,
+                            destY,
+                            destWidth,
+                            destHeight
+                        );
+                        tileX += tileSize;
+                        destX += destWidth;
+                    }
+                    tileY += tileSize;
+                    destY += destHeight;
+                }
+                context.restore();
+                return canvas;
+            }
+        }
+        return originalRenderMethod(
+            canvas,
+            img,
+            sourceX,
+            sourceY,
+            sourceWidth,
+            sourceHeight,
+            destX,
+            destY,
+            destWidth,
+            destHeight
+        );
+    };
+
+}));

data/vendor/assets/javascripts/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/load-image.js

@@ -0,0 +1,289 @@
+/*
+ * JavaScript Load Image 1.8.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 orientation based on the given EXIF orientation data:
+    loadImage.transformCoordinates = function (canvas, orientation) {
+        var ctx = canvas.getContext('2d'),
+            width = canvas.width,
+            height = canvas.height;
+        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;
+        }
+    };
+
+    // 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;
+    };
+
+    // Scales the given image (img or canvas HTML element)
+    // using the given options.
+    // Returns a canvas object if the browser supports canvas
+    // and the canvas or crop option is 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 ||
+                ((options.canvas || options.crop || options.orientation) &&
+                    canvas.getContext),
+            width = img.width,
+            height = img.height,
+            sourceWidth = width,
+            sourceHeight = height,
+            sourceX = 0,
+            sourceY = 0,
+            destX = 0,
+            destY = 0,
+            maxWidth,
+            maxHeight,
+            minWidth,
+            minHeight,
+            destWidth,
+            destHeight,
+            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.orientation > 4) {
+            maxWidth = options.maxHeight;
+            maxHeight = options.maxWidth;
+            minWidth = options.minHeight;
+            minHeight = options.minWidth;
+        } else {
+            maxWidth = options.maxWidth;
+            maxHeight = options.maxHeight;
+            minWidth = options.minWidth;
+            minHeight = options.minHeight;
+        }
+        if (useCanvas && maxWidth && maxHeight && options.crop) {
+            destWidth = maxWidth;
+            destHeight = maxHeight;
+            if (width / height < maxWidth / maxHeight) {
+                sourceHeight = maxHeight * width / maxWidth;
+                sourceY = (height - sourceHeight) / 2;
+            } else {
+                sourceWidth = maxWidth * height / maxHeight;
+                sourceX = (width - sourceWidth) / 2;
+            }
+        } else {
+            if (options.contain || options.cover) {
+                minWidth = maxWidth = maxWidth || minWidth;
+                minHeight = maxHeight = maxHeight || minHeight;
+            }
+            destWidth = width;
+            destHeight = height;
+            if (options.cover) {
+                scaleDown();
+                scaleUp();
+            } else {
+                scaleUp();
+                scaleDown();
+            }
+        }
+        if (useCanvas) {
+            canvas.width = destWidth;
+            canvas.height = destHeight;
+            loadImage.transformCoordinates(
+                canvas,
+                options.orientation
+            );
+            return loadImage.renderImageToCanvas(
+                canvas,
+                img,
+                sourceX,
+                sourceY,
+                sourceWidth,
+                sourceHeight,
+                destX,
+                destY,
+                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));