RubyGems - ish_lib_assets - Versions diffs - 0.1.3 - Mend

ish_lib_assets 0.1.3

Files changed (868) hide show

data/vendor/assets/javascripts/jquery-file-upload/index.html ADDED

@@ -0,0 +1,176 @@
+<!DOCTYPE HTML>
+<!--
+/*
+ * jQuery File Upload Plugin Demo 6.0.4
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2010, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+-->
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>jQuery File Upload Demo</title>
+<!--
+    The Bootstrap CSS is not required, but included for the demo.
+    However, the FileUpload user interface waits for CSS transition events in several callbacks,
+    if a "fade" class is present. These CSS transitions are defined by the Bootstrap CSS.
+    If it is not included, either remove the "fade" class from the upload/download templates,
+    or define your own "fade" class with CSS transitions.
+-->
+<link rel="stylesheet" href="http://twitter.github.com/bootstrap/1.4.0/bootstrap.min.css">
+<link rel="stylesheet" href="http://blueimp.github.com/Bootstrap-Image-Gallery/bootstrap-image-gallery.min.css">
+<!--[if lt IE 7]><link rel="stylesheet" href="http://blueimp.github.com/Bootstrap-Image-Gallery/bootstrap-ie6.min.css"><![endif]-->
+<link rel="stylesheet" href="jquery.fileupload-ui.css">
+<style type="text/css">body {padding-top: 80px;}</style>
+<meta name="description" content="File Upload widget with multiple file selection, drag&amp;drop support, progress bar and preview images for jQuery. Supports cross-domain, chunked and resumable file uploads. Works with any server-side platform (Google App Engine, PHP, Python, Ruby on Rails, Java, etc.) that supports standard HTML form file uploads.">
+</head>
+<body>
+<div class="topbar">
+    <div class="fill">
+        <div class="container">
+            <a class="brand" href="https://github.com/blueimp/jQuery-File-Upload">jQuery File Upload</a>
+            <ul class="nav">
+                <li class="active"><a href="#">Demo</a></li>
+                <li><a href="https://github.com/blueimp/jQuery-File-Upload/downloads">Downloads</a></li>
+                <li><a href="https://github.com/blueimp/jQuery-File-Upload">Source Code</a></li>
+                <li><a href="https://github.com/blueimp/jQuery-File-Upload/wiki">Documentation</a></li>
+                <li><a href="https://github.com/blueimp/jQuery-File-Upload/issues">Issues</a></li>
+                <li><a href="test/">Test</a></li>
+                <li><a href="https://blueimp.net">&copy; Sebastian Tschan</a></li>
+            </ul>
+        </div>
+    </div>
+</div>
+<div class="container">
+    <div class="page-header">
+        <h1>jQuery File Upload Demo</h1>
+    </div>
+    <blockquote>
+        <p>File Upload widget with multiple file selection, drag&amp;drop support, progress bar and preview images for jQuery.<br>
+        Supports cross-domain, chunked and resumable file uploads.<br>
+        Works with any server-side platform (Google App Engine, PHP, Python, Ruby on Rails, Java, etc.) that supports standard HTML form file uploads.</p>
+    </blockquote>
+    <br>
+    <form id="fileupload" action="php/index.php" method="POST" enctype="multipart/form-data">
+        <div class="row">
+            <div class="span16 fileupload-buttonbar">
+                <div class="progressbar fileupload-progressbar fade"><div style="width:0%;"></div></div>
+                <span class="btn success fileinput-button">
+                    <span>Add files...</span>
+                    <input type="file" name="files[]" multiple>
+                </span>
+                <button type="submit" class="btn primary start">Start upload</button>
+                <button type="reset" class="btn info cancel">Cancel upload</button>
+                <button type="button" class="btn danger delete">Delete selected</button>
+                <input type="checkbox" class="toggle">
+            </div>
+        </div>
+        <br>
+        <div class="row">
+            <div class="span16">
+                <table class="zebra-striped"><tbody class="files"></tbody></table>
+            </div>
+        </div>
+    </form>
+    <div class="well">
+        <h3>Demo Notes</h3>
+        <ul>
+            <li>The maximum file size for uploads in this demo is <strong>5 MB</strong> (default file size is unlimited).</li>
+            <li>Only image files (<strong>JPG, GIF, PNG</strong>) are allowed in this demo (by default there is no file type restriction).</li>
+            <li>Uploaded files will be deleted automatically after <strong>5 minutes</strong> (demo setting).</li>
+            <li>You can <strong>drag &amp; drop</strong> files from your desktop on this webpage with Google Chrome, Mozilla Firefox and Apple Safari.</li>
+            <li>Please refer to the <a href="https://github.com/blueimp/jQuery-File-Upload">project website</a> and <a href="https://github.com/blueimp/jQuery-File-Upload/wiki">documentation</a> for more information.</li>
+        </ul>
+    </div>
+</div>
+<!-- gallery-loader is the loading animation container -->
+<div id="gallery-loader"></div>
+<!-- gallery-modal is the modal dialog used for the image gallery -->
+<div id="gallery-modal" class="modal hide fade">
+    <div class="modal-header">
+        <a href="#" class="close">&times;</a>
+        <h3 class="title"></h3>
+    </div>
+    <div class="modal-body"></div>
+    <div class="modal-footer">
+        <a class="btn primary next">Next</a>
+        <a class="btn info prev">Previous</a>
+        <a class="btn success download" target="_blank">Download</a>
+    </div>
+</div>
+<script>
+var fileUploadErrors = {
+    maxFileSize: 'File is too big',
+    minFileSize: 'File is too small',
+    acceptFileTypes: 'Filetype not allowed',
+    maxNumberOfFiles: 'Max number of files exceeded',
+    uploadedBytes: 'Uploaded bytes exceed file size',
+    emptyResult: 'Empty file upload result'
+};
+</script>
+<script id="template-upload" type="text/html">
+{% for (var i=0, files=o.files, l=files.length, file=files[0]; i<l; file=files[++i]) { %}
+    <tr class="template-upload fade">
+        <td class="preview"><span class="fade"></span></td>
+        <td class="name">{%=file.name%}</td>
+        <td class="size">{%=o.formatFileSize(file.size)%}</td>
+        {% if (file.error) { %}
+            <td class="error" colspan="2"><span class="label important">Error</span> {%=fileUploadErrors[file.error] || file.error%}</td>
+        {% } else if (o.files.valid && !i) { %}
+            <td class="progress"><div class="progressbar"><div style="width:0%;"></div></div></td>
+            <td class="start">{% if (!o.options.autoUpload) { %}<button class="btn primary">Start</button>{% } %}</td>
+        {% } else { %}
+            <td colspan="2"></td>
+        {% } %}
+        <td class="cancel">{% if (!i) { %}<button class="btn info">Cancel</button>{% } %}</td>
+    </tr>
+{% } %}
+</script>
+<script id="template-download" type="text/html">
+{% for (var i=0, files=o.files, l=files.length, file=files[0]; i<l; file=files[++i]) { %}
+    <tr class="template-download fade">
+        {% if (file.error) { %}
+            <td></td>
+            <td class="name">{%=file.name%}</td>
+            <td class="size">{%=o.formatFileSize(file.size)%}</td>
+            <td class="error" colspan="2"><span class="label important">Error</span> {%=fileUploadErrors[file.error] || file.error%}</td>
+        {% } else { %}
+            <td class="preview">{% if (file.thumbnail_url) { %}
+                <a href="{%=file.url%}" title="{%=file.name%}" rel="gallery"><img src="{%=file.thumbnail_url%}"></a>
+            {% } %}</td>
+            <td class="name">
+                <a href="{%=file.url%}" title="{%=file.name%}" rel="{%=file.thumbnail_url&&'gallery'%}">{%=file.name%}</a>
+            </td>
+            <td class="size">{%=o.formatFileSize(file.size)%}</td>
+            <td colspan="2"></td>
+        {% } %}
+        <td class="delete">
+            <button class="btn danger" data-type="{%=file.delete_type%}" data-url="{%=file.delete_url%}">Delete</button>
+            <input type="checkbox" name="delete" value="1">
+        </td>
+    </tr>
+{% } %}
+</script>
+<script src="//ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
+<!-- The jQuery UI widget factory, can be omitted if jQuery UI is already included -->
+<script src="vendor/jquery.ui.widget.js"></script>
+<!-- The Templates and Load Image plugins are included for the FileUpload user interface -->
+<script src="http://blueimp.github.com/JavaScript-Templates/tmpl.min.js"></script>
+<script src="http://blueimp.github.com/JavaScript-Load-Image/load-image.min.js"></script>
+<!-- Bootstrap Modal and Image Gallery are not required, but included for the demo -->
+<script src="http://twitter.github.com/bootstrap/1.4.0/bootstrap-modal.min.js"></script>
+<script src="http://blueimp.github.com/Bootstrap-Image-Gallery/bootstrap-image-gallery.min.js"></script>
+<!-- The Iframe Transport is required for browsers without support for XHR file uploads -->
+<script src="jquery.iframe-transport.js"></script>
+<script src="jquery.fileupload.js"></script>
+<script src="jquery.fileupload-ui.js"></script>
+<script src="application.js"></script>
+<!-- The XDomainRequest Transport is included for cross-domain file deletion for IE8+ -->
+<!--[if gte IE 8]><script src="cors/jquery.xdr-transport.js"></script><![endif]-->
+</body>
+</html>

data/vendor/assets/javascripts/jquery-file-upload/jquery.fileupload-ui.js ADDED

@@ -0,0 +1,547 @@
+/*
+ * jQuery File Upload User Interface Plugin 6.1
+ * https://github.com/blueimp/jQuery-File-Upload
+ *
+ * Copyright 2010, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+/*jslint nomen: true, unparam: true, regexp: true */
+/*global define, window, document, URL, webkitURL, FileReader */
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define(['jquery', 'tmpl', 'loadImage', './jquery.fileupload.js'], factory);
+    } else {
+        // Browser globals:
+        factory(window.jQuery, window.tmpl, window.loadImage);
+    }
+}(function ($, tmpl, loadImage) {
+    'use strict';
+    // The UI version extends the basic fileupload widget and adds
+    // a complete user interface based on the given upload/download
+    // templates.
+    $.widget('blueimpUI.fileupload', $.blueimp.fileupload, {
+        options: {
+            // By default, files added to the widget are uploaded as soon
+            // as the user clicks on the start buttons. To enable automatic
+            // uploads, set the following option to true:
+            autoUpload: false,
+            // The following option limits the number of files that are
+            // allowed to be uploaded using this widget:
+            maxNumberOfFiles: undefined,
+            // The maximum allowed file size:
+            maxFileSize: undefined,
+            // The minimum allowed file size:
+            minFileSize: 1,
+            // The regular expression for allowed file types, matches
+            // against either file type or file name:
+            acceptFileTypes:  /.+$/i,
+            // The regular expression to define for which files a preview
+            // image is shown, matched against the file type:
+            previewFileTypes: /^image\/(gif|jpeg|png)$/,
+            // The maximum file size for preview images:
+            previewMaxFileSize: 5000000, // 5MB
+            // The maximum width of the preview images:
+            previewMaxWidth: 80,
+            // The maximum height of the preview images:
+            previewMaxHeight: 80,
+            // By default, preview images are displayed as canvas elements
+            // if supported by the browser. Set the following option to false
+            // to always display preview images as img elements:
+            previewAsCanvas: true,
+            // The expected data type of the upload response, sets the dataType
+            // option of the $.ajax upload requests:
+            dataType: 'json',
+            // The add callback is invoked as soon as files are added to the fileupload
+            // widget (via file input selection, drag & drop or add API call).
+            // See the basic file upload widget for more information:
+            add: function (e, data) {
+                var that = $(this).data('fileupload'),
+                    files = data.files;
+                that._adjustMaxNumberOfFiles(-files.length);
+                data.isAdjusted = true;
+                data.files.valid = data.isValidated = that._validate(files);
+                data.context = that._renderUpload(files)
+                    .appendTo(that._files)
+                    .data('data', data);
+                // Force reflow:
+                that._reflow = that._transition && data.context[0].offsetWidth;
+                data.context.addClass('in');
+                if ((that.options.autoUpload || data.autoUpload) &&
+                        data.isValidated) {
+                    data.submit();
+                }
+            },
+            // Callback for the start of each file upload request:
+            send: function (e, data) {
+                if (!data.isValidated) {
+                    var that = $(this).data('fileupload');
+                    if (!data.isAdjusted) {
+                        that._adjustMaxNumberOfFiles(-data.files.length);
+                    }
+                    if (!that._validate(data.files)) {
+                        return false;
+                    }
+                }
+                if (data.context && data.dataType &&
+                        data.dataType.substr(0, 6) === 'iframe') {
+                    // Iframe Transport does not support progress events.
+                    // In lack of an indeterminate progress bar, we set
+                    // the progress to 100%, showing the full animated bar:
+                    data.context.find('.progressbar div').css(
+                        'width',
+                        parseInt(100, 10) + '%'
+                    );
+                }
+            },
+            // Callback for successful uploads:
+            done: function (e, data) {
+                var that = $(this).data('fileupload'),
+                    template,
+                    preview;
+                if (data.context) {
+                    data.context.each(function (index) {
+                        var file = ($.isArray(data.result) &&
+                                data.result[index]) || {error: 'emptyResult'};
+                        if (file.error) {
+                            that._adjustMaxNumberOfFiles(1);
+                        }
+                        that._transitionCallback(
+                            $(this).removeClass('in'),
+                            function (node) {
+                                template = that._renderDownload([file]);
+                                preview = node
+                                    .find('.preview img, .preview canvas');
+                                if (preview.length) {
+                                    template.find('.preview img')
+                                        .prop('width', preview.prop('width'))
+                                        .prop('height', preview.prop('height'));
+                                }
+                                template
+                                    .replaceAll(node);
+                                // Force reflow:
+                                that._reflow = that._transition &&
+                                    template[0].offsetWidth;
+                                template.addClass('in');
+                            }
+                        );
+                    });
+                } else {
+                    template = that._renderDownload(data.result)
+                        .appendTo(that._files);
+                    // Force reflow:
+                    that._reflow = that._transition && template[0].offsetWidth;
+                    template.addClass('in');
+                }
+            },
+            // Callback for failed (abort or error) uploads:
+            fail: function (e, data) {
+                var that = $(this).data('fileupload'),
+                    template;
+                that._adjustMaxNumberOfFiles(data.files.length);
+                if (data.context) {
+                    data.context.each(function (index) {
+                        if (data.errorThrown !== 'abort') {
+                            var file = data.files[index];
+                            file.error = file.error || data.errorThrown ||
+                                true;
+                            that._transitionCallback(
+                                $(this).removeClass('in'),
+                                function (node) {
+                                    template = that._renderDownload([file])
+                                        .replaceAll(node);
+                                    // Force reflow:
+                                    that._reflow = that._transition &&
+                                        template[0].offsetWidth;
+                                    template.addClass('in');
+                                }
+                            );
+                        } else {
+                            that._transitionCallback(
+                                $(this).removeClass('in'),
+                                function (node) {
+                                    node.remove();
+                                }
+                            );
+                        }
+                    });
+                } else if (data.errorThrown !== 'abort') {
+                    that._adjustMaxNumberOfFiles(-data.files.length);
+                    data.context = that._renderUpload(data.files)
+                        .appendTo(that._files)
+                        .data('data', data);
+                    // Force reflow:
+                    that._reflow = that._transition && data.context[0].offsetWidth;
+                    data.context.addClass('in');
+                }
+            },
+            // Callback for upload progress events:
+            progress: function (e, data) {
+                if (data.context) {
+                    data.context.find('.progressbar div').css(
+                        'width',
+                        parseInt(data.loaded / data.total * 100, 10) + '%'
+                    );
+                }
+            },
+            // Callback for global upload progress events:
+            progressall: function (e, data) {
+                $(this).find('.fileupload-progressbar div').css(
+                    'width',
+                    parseInt(data.loaded / data.total * 100, 10) + '%'
+                );
+            },
+            // Callback for uploads start, equivalent to the global ajaxStart event:
+            start: function () {
+                $(this).find('.fileupload-progressbar')
+                    .addClass('in').find('div').css('width', '0%');
+            },
+            // Callback for uploads stop, equivalent to the global ajaxStop event:
+            stop: function () {
+                $(this).find('.fileupload-progressbar')
+                    .removeClass('in').find('div').css('width', '0%');
+            },
+            // Callback for file deletion:
+            destroy: function (e, data) {
+                var that = $(this).data('fileupload');
+                if (data.url) {
+                    $.ajax(data);
+                }
+                that._adjustMaxNumberOfFiles(1);
+                that._transitionCallback(
+                    data.context.removeClass('in'),
+                    function (node) {
+                        node.remove();
+                    }
+                );
+            }
+        },
+        // Link handler, that allows to download files
+        // by drag & drop of the links to the desktop:
+        _enableDragToDesktop: function () {
+            var link = $(this),
+                url = link.prop('href'),
+                name = decodeURIComponent(url.split('/').pop())
+                    .replace(/:/g, '-'),
+                type = 'application/octet-stream';
+            link.bind('dragstart', function (e) {
+                try {
+                    e.originalEvent.dataTransfer.setData(
+                        'DownloadURL',
+                        [type, name, url].join(':')
+                    );
+                } catch (err) {}
+            });
+        },
+        _adjustMaxNumberOfFiles: function (operand) {
+            if (typeof this.options.maxNumberOfFiles === 'number') {
+                this.options.maxNumberOfFiles += operand;
+                if (this.options.maxNumberOfFiles < 1) {
+                    this._disableFileInputButton();
+                } else {
+                    this._enableFileInputButton();
+                }
+            }
+        },
+        _formatFileSize: function (bytes) {
+            if (typeof bytes !== 'number') {
+                return '';
+            }
+            if (bytes >= 1000000000) {
+                return (bytes / 1000000000).toFixed(2) + ' GB';
+            }
+            if (bytes >= 1000000) {
+                return (bytes / 1000000).toFixed(2) + ' MB';
+            }
+            return (bytes / 1000).toFixed(2) + ' KB';
+        },
+        _hasError: function (file) {
+            if (file.error) {
+                return file.error;
+            }
+            // The number of added files is subtracted from
+            // maxNumberOfFiles before validation, so we check if
+            // maxNumberOfFiles is below 0 (instead of below 1):
+            if (this.options.maxNumberOfFiles < 0) {
+                return 'maxNumberOfFiles';
+            }
+            // Files are accepted if either the file type or the file name
+            // matches against the acceptFileTypes regular expression, as
+            // only browsers with support for the File API report the type:
+            if (!(this.options.acceptFileTypes.test(file.type) ||
+                    this.options.acceptFileTypes.test(file.name))) {
+                return 'acceptFileTypes';
+            }
+            if (this.options.maxFileSize &&
+                    file.size > this.options.maxFileSize) {
+                return 'maxFileSize';
+            }
+            if (typeof file.size === 'number' &&
+                    file.size < this.options.minFileSize) {
+                return 'minFileSize';
+            }
+            return null;
+        },
+        _validate: function (files) {
+            var that = this,
+                valid = !!files.length;
+            $.each(files, function (index, file) {
+                file.error = that._hasError(file);
+                if (file.error) {
+                    valid = false;
+                }
+            });
+            return valid;
+        },
+        _renderTemplate: function (func, files) {
+            return $(this.options.templateContainer).html(func({
+                files: files,
+                formatFileSize: this._formatFileSize,
+                options: this.options
+            })).children();
+        },
+        _renderUpload: function (files) {
+            var that = this,
+                options = this.options,
+                nodes = this._renderTemplate(options.uploadTemplate, files);
+            nodes.find('.preview span').each(function (index, node) {
+                var file = files[index];
+                if (options.previewFileTypes.test(file.type) &&
+                        (!options.previewMaxFileSize ||
+                        file.size < options.previewMaxFileSize)) {
+                    loadImage(
+                        files[index],
+                        function (img) {
+                            $(node).append(img);
+                            // Force reflow:
+                            that._reflow = that._transition &&
+                                node.offsetWidth;
+                            $(node).addClass('in');
+                        },
+                        {
+                            maxWidth: options.previewMaxWidth,
+                            maxHeight: options.previewMaxHeight,
+                            canvas: options.previewAsCanvas
+                        }
+                    );
+                }
+            });
+            return nodes;
+        },
+        _renderDownload: function (files) {
+            var nodes = this._renderTemplate(
+                this.options.downloadTemplate,
+                files
+            );
+            nodes.find('a').each(this._enableDragToDesktop);
+            return nodes;
+        },
+        _startHandler: function (e) {
+            e.preventDefault();
+            var button = $(this),
+                template = button.closest('.template-upload'),
+                data = template.data('data');
+            if (data && data.submit && !data.jqXHR && data.submit()) {
+                button.prop('disabled', true);
+            }
+        },
+        _cancelHandler: function (e) {
+            e.preventDefault();
+            var template = $(this).closest('.template-upload'),
+                data = template.data('data') || {};
+            if (!data.jqXHR) {
+                data.errorThrown = 'abort';
+                e.data.fileupload._trigger('fail', e, data);
+            } else {
+                data.jqXHR.abort();
+            }
+        },
+        _deleteHandler: function (e) {
+            e.preventDefault();
+            var button = $(this);
+            e.data.fileupload._trigger('destroy', e, {
+                context: button.closest('.template-download'),
+                url: button.attr('data-url'),
+                type: button.attr('data-type'),
+                dataType: e.data.fileupload.options.dataType
+            });
+        },
+        _transitionCallback: function (node, callback) {
+            var that = this;
+            if (this._transition && node.hasClass('fade')) {
+                node.bind(
+                    this._transitionEnd,
+                    function (e) {
+                        // Make sure we don't respond to other transitions events
+                        // in the container element, e.g. from button elements:
+                        if (e.target === node[0]) {
+                            node.unbind(that._transitionEnd);
+                            callback.call(that, node);
+                        }
+                    }
+                );
+            } else {
+                callback.call(this, node);
+            }
+        },
+        _initTransitionSupport: function () {
+            var that = this,
+                style = (document.body || document.documentElement).style,
+                suffix = '.' + that.options.namespace;
+            that._transition = style.transition !== undefined ||
+                style.WebkitTransition !== undefined ||
+                style.MozTransition !== undefined ||
+                style.MsTransition !== undefined ||
+                style.OTransition !== undefined;
+            if (that._transition) {
+                that._transitionEnd = [
+                    'MSTransitionEnd',
+                    'webkitTransitionEnd',
+                    'transitionend',
+                    'oTransitionEnd'
+                ].join(suffix + ' ') + suffix;
+            }
+        },
+        _initButtonBarEventHandlers: function () {
+            var fileUploadButtonBar = this.element.find('.fileupload-buttonbar'),
+                filesList = this._files,
+                ns = this.options.namespace;
+            fileUploadButtonBar.find('.start')
+                .bind('click.' + ns, function (e) {
+                    e.preventDefault();
+                    filesList.find('.start button').click();
+                });
+            fileUploadButtonBar.find('.cancel')
+                .bind('click.' + ns, function (e) {
+                    e.preventDefault();
+                    filesList.find('.cancel button').click();
+                });
+            fileUploadButtonBar.find('.delete')
+                .bind('click.' + ns, function (e) {
+                    e.preventDefault();
+                    filesList.find('.delete input:checked')
+                        .siblings('button').click();
+                });
+            fileUploadButtonBar.find('.toggle')
+                .bind('change.' + ns, function (e) {
+                    filesList.find('.delete input').prop(
+                        'checked',
+                        $(this).is(':checked')
+                    );
+                });
+        },
+        _destroyButtonBarEventHandlers: function () {
+            this.element.find('.fileupload-buttonbar button')
+                .unbind('click.' + this.options.namespace);
+            this.element.find('.fileupload-buttonbar .toggle')
+                .unbind('change.' + this.options.namespace);
+        },
+        _initEventHandlers: function () {
+            $.blueimp.fileupload.prototype._initEventHandlers.call(this);
+            var eventData = {fileupload: this};
+            this._files
+                .delegate(
+                    '.start button',
+                    'click.' + this.options.namespace,
+                    eventData,
+                    this._startHandler
+                )
+                .delegate(
+                    '.cancel button',
+                    'click.' + this.options.namespace,
+                    eventData,
+                    this._cancelHandler
+                )
+                .delegate(
+                    '.delete button',
+                    'click.' + this.options.namespace,
+                    eventData,
+                    this._deleteHandler
+                );
+            this._initButtonBarEventHandlers();
+            this._initTransitionSupport();
+        },
+        _destroyEventHandlers: function () {
+            this._destroyButtonBarEventHandlers();
+            this._files
+                .undelegate('.start button', 'click.' + this.options.namespace)
+                .undelegate('.cancel button', 'click.' + this.options.namespace)
+                .undelegate('.delete button', 'click.' + this.options.namespace);
+            $.blueimp.fileupload.prototype._destroyEventHandlers.call(this);
+        },
+        _enableFileInputButton: function () {
+            this.element.find('.fileinput-button input')
+                .prop('disabled', false)
+                .parent().removeClass('disabled');
+        },
+        _disableFileInputButton: function () {
+            this.element.find('.fileinput-button input')
+                .prop('disabled', true)
+                .parent().addClass('disabled');
+        },
+        _initTemplates: function () {
+            this.options.templateContainer = document.createElement(
+                this._files.prop('nodeName')
+            );
+            this.options.uploadTemplate = tmpl('template-upload');
+            this.options.downloadTemplate = tmpl('template-download');
+        },
+        _initFiles: function () {
+            this._files = this.element.find('.files');
+        },
+        _create: function () {
+            this._initFiles();
+            $.blueimp.fileupload.prototype._create.call(this);
+            this._initTemplates();
+        },
+        destroy: function () {
+            $.blueimp.fileupload.prototype.destroy.call(this);
+        },
+        enable: function () {
+            $.blueimp.fileupload.prototype.enable.call(this);
+            this.element.find('input, button').prop('disabled', false);
+            this._enableFileInputButton();
+        },
+        disable: function () {
+            this.element.find('input, button').prop('disabled', true);
+            this._disableFileInputButton();
+            $.blueimp.fileupload.prototype.disable.call(this);
+        }
+    });
+}));