Bootstrap-Image-Gallery-rails 1.0.0.3.1.0

data/vendor/assets/javascripts/blueimp-helper.js

@@ -0,0 +1,191 @@
+/*
+ * blueimp helper JS 1.2.0
+ * https://github.com/blueimp/Gallery
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/* global define, window, document */
+
+(function () {
+    'use strict';
+
+    function extend(obj1, obj2) {
+        var prop;
+        for (prop in obj2) {
+            if (obj2.hasOwnProperty(prop)) {
+                obj1[prop] = obj2[prop];
+            }
+        }
+        return obj1;
+    }
+
+    function Helper(query) {
+        if (!this || this.find !== Helper.prototype.find) {
+            // Called as function instead of as constructor,
+            // so we simply return a new instance:
+            return new Helper(query);
+        }
+        this.length = 0;
+        if (query) {
+            if (typeof query === 'string') {
+                query = this.find(query);
+            }
+            if (query.nodeType || query === query.window) {
+                // Single HTML element
+                this.length = 1;
+                this[0] = query;
+            } else {
+                // HTML element collection
+                var i = query.length;
+                this.length = i;
+                while (i) {
+                    i -= 1;
+                    this[i] = query[i];
+                }
+            }
+        }
+    }
+
+    Helper.extend = extend;
+
+    Helper.contains = function (container, element) {
+        do {
+            element = element.parentNode;
+            if (element === container) {
+                return true;
+            }
+        } while (element);
+        return false;
+    };
+
+    Helper.parseJSON = function (string) {
+        return window.JSON && JSON.parse(string);
+    };
+
+    extend(Helper.prototype, {
+
+        find: function (query) {
+            var container = this[0] || document;
+            if (typeof query === 'string') {
+                if (container.querySelectorAll) {
+                    query = container.querySelectorAll(query);
+                } else if (query.charAt(0) === '#') {
+                    query = container.getElementById(query.slice(1));
+                } else {
+                    query = container.getElementsByTagName(query);
+                }
+            }
+            return new Helper(query);
+        },
+
+        hasClass: function (className) {
+            if (!this[0]) {
+                return false;
+            }
+            return new RegExp('(^|\\s+)' + className +
+                '(\\s+|$)').test(this[0].className);
+        },
+
+        addClass: function (className) {
+            var i = this.length,
+                element;
+            while (i) {
+                i -= 1;
+                element = this[i];
+                if (!element.className) {
+                    element.className = className;
+                    return this;
+                }
+                if (this.hasClass(className)) {
+                    return this;
+                }
+                element.className += ' ' + className;
+            }
+            return this;
+        },
+
+        removeClass: function (className) {
+            var regexp = new RegExp('(^|\\s+)' + className + '(\\s+|$)'),
+                i = this.length,
+                element;
+            while (i) {
+                i -= 1;
+                element = this[i];
+                element.className = element.className.replace(regexp, ' ');
+            }
+            return this;
+        },
+
+        on: function (eventName, handler) {
+            var eventNames = eventName.split(/\s+/),
+                i,
+                element;
+            while (eventNames.length) {
+                eventName = eventNames.shift();
+                i = this.length;
+                while (i) {
+                    i -= 1;
+                    element = this[i];
+                    if (element.addEventListener) {
+                        element.addEventListener(eventName, handler, false);
+                    } else if (element.attachEvent) {
+                        element.attachEvent('on' + eventName, handler);
+                    }
+                }
+            }
+            return this;
+        },
+
+        off: function (eventName, handler) {
+            var eventNames = eventName.split(/\s+/),
+                i,
+                element;
+            while (eventNames.length) {
+                eventName = eventNames.shift();
+                i = this.length;
+                while (i) {
+                    i -= 1;
+                    element = this[i];
+                    if (element.removeEventListener) {
+                        element.removeEventListener(eventName, handler, false);
+                    } else if (element.detachEvent) {
+                        element.detachEvent('on' + eventName, handler);
+                    }
+                }
+            }
+            return this;
+        },
+
+        empty: function () {
+            var i = this.length,
+                element;
+            while (i) {
+                i -= 1;
+                element = this[i];
+                while (element.hasChildNodes()) {
+                    element.removeChild(element.lastChild);
+                }
+            }
+            return this;
+        },
+
+        first: function () {
+            return new Helper(this[0]);
+        }
+
+    });
+
+    if (typeof define === 'function' && define.amd) {
+        define(function () {
+            return Helper;
+        });
+    } else {
+        window.blueimp = window.blueimp || {};
+        window.blueimp.helper = Helper;
+    }
+}());

data/vendor/assets/javascripts/bootstrap-image-gallery.js

@@ -0,0 +1,88 @@
+/*
+ * Bootstrap Image Gallery 3.0.1
+ * https://github.com/blueimp/Bootstrap-Image-Gallery
+ *
+ * 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) {
+        define([
+            'jquery',
+            './blueimp-gallery'
+        ], factory);
+    } else {
+        factory(
+            window.jQuery,
+            window.blueimp.Gallery
+        );
+    }
+}(function ($, Gallery) {
+    'use strict';
+
+    $.extend(Gallery.prototype.options, {
+        useBootstrapModal: true
+    });
+
+    var close = Gallery.prototype.close,
+        imageFactory = Gallery.prototype.imageFactory,
+        videoFactory = Gallery.prototype.videoFactory,
+        textFactory = Gallery.prototype.textFactory;
+
+    $.extend(Gallery.prototype, {
+
+        modalFactory: function (obj, callback, factoryInterface, factory) {
+            if (!this.options.useBootstrapModal || factoryInterface) {
+                return factory.call(this, obj, callback, factoryInterface);
+            }
+            var that = this,
+                modalTemplate = this.container.children('.modal'),
+                modal = modalTemplate.clone().show()
+                    .on('click', function (event) {
+                        // Close modal if click is outside of modal-content:
+                        if (event.target === modal[0] ||
+                                event.target === modal.children()[0]) {
+                            event.preventDefault();
+                            event.stopPropagation();
+                            that.close();
+                        }
+                    }),
+                element = factory.call(this, obj, function (event) {
+                    callback({
+                        type: event.type,
+                        target: modal[0]
+                    });
+                    modal.addClass('in');
+                }, factoryInterface);
+            modal.find('.modal-title').text(element.title || String.fromCharCode(160));
+            modal.find('.modal-body').append(element);
+            return modal[0];
+        },
+
+        imageFactory: function (obj, callback, factoryInterface) {
+            return this.modalFactory(obj, callback, factoryInterface, imageFactory);
+        },
+
+        videoFactory: function (obj, callback, factoryInterface) {
+            return this.modalFactory(obj, callback, factoryInterface, videoFactory);
+        },
+
+        textFactory: function (obj, callback, factoryInterface) {
+            return this.modalFactory(obj, callback, factoryInterface, textFactory);
+        },
+
+        close: function () {
+            this.container.find('.modal').removeClass('in');
+            close.call(this);
+        }
+
+    });
+
+}));

data/vendor/assets/javascripts/jquery.blueimp-gallery.js

@@ -0,0 +1,84 @@
+/*
+ * blueimp Gallery jQuery plugin 1.2.2
+ * https://github.com/blueimp/Gallery
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+/* global define, window, document */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        define([
+            'jquery',
+            './blueimp-gallery'
+        ], factory);
+    } else {
+        factory(
+            window.jQuery,
+            window.blueimp.Gallery
+        );
+    }
+}(function ($, Gallery) {
+    'use strict';
+
+    // Global click handler to open links with data-gallery attribute
+    // in the Gallery lightbox:
+    $(document).on('click', '[data-gallery]', function (event) {
+        // Get the container id from the data-gallery attribute:
+        var id = $(this).data('gallery'),
+            widget = $(id),
+            container = (widget.length && widget) ||
+                $(Gallery.prototype.options.container),
+            callbacks = {
+                onopen: function () {
+                    container
+                        .data('gallery', this)
+                        .trigger('open');
+                },
+                onopened: function () {
+                    container.trigger('opened');
+                },
+                onslide: function () {
+                    container.trigger('slide', arguments);
+                },
+                onslideend: function () {
+                    container.trigger('slideend', arguments);
+                },
+                onslidecomplete: function () {
+                    container.trigger('slidecomplete', arguments);
+                },
+                onclose: function () {
+                    container.trigger('close');
+                },
+                onclosed: function () {
+                    container
+                        .trigger('closed')
+                        .removeData('gallery');
+                }
+            },
+            options = $.extend(
+                // Retrieve custom options from data-attributes
+                // on the Gallery widget:
+                container.data(),
+                {
+                    container: container[0],
+                    index: this,
+                    event: event
+                },
+                callbacks
+            ),
+            // Select all links with the same data-gallery attribute:
+            links = $('[data-gallery="' + id + '"]');
+        if (options.filter) {
+            links = links.filter(options.filter);
+        }
+        return new Gallery(links, options);
+    });
+
+}));

data/vendor/assets/stylesheets/blueimp-gallery-indicator.css

@@ -0,0 +1,71 @@
+@charset "UTF-8";
+/*
+ * blueimp Gallery Indicator CSS 1.1.0
+ * https://github.com/blueimp/Gallery
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+.blueimp-gallery > .indicator {
+  position: absolute;
+  top: auto;
+  right: 15px;
+  bottom: 15px;
+  left: 15px;
+  margin: 0 40px;
+  padding: 0;
+  list-style: none;
+  text-align: center;
+  line-height: 10px;
+  display: none;
+}
+.blueimp-gallery > .indicator > li {
+  display: inline-block;
+  width: 9px;
+  height: 9px;
+  margin: 6px 3px 0 3px;
+  -webkit-box-sizing: content-box;
+     -moz-box-sizing: content-box;
+          box-sizing: content-box;
+  border: 1px solid transparent;
+  background: #ccc;
+  background: rgba(255, 255, 255, 0.25) center no-repeat;
+  border-radius: 5px;
+  box-shadow: 0 0 2px #000;
+  opacity: 0.5;
+  cursor: pointer;
+}
+.blueimp-gallery > .indicator > li:hover,
+.blueimp-gallery > .indicator > .active {
+  background-color: #fff;
+  border-color: #fff;
+  opacity: 1;
+}
+.blueimp-gallery-controls > .indicator {
+  display: block;
+  /* Fix z-index issues (controls behind slide element) on Android: */
+  -webkit-transform: translateZ(0);
+     -moz-transform: translateZ(0);
+      -ms-transform: translateZ(0);
+       -o-transform: translateZ(0);
+          transform: translateZ(0);
+}
+.blueimp-gallery-single > .indicator {
+  display: none;
+}
+.blueimp-gallery > .indicator {
+  -webkit-user-select: none;
+   -khtml-user-select: none;
+     -moz-user-select: none;
+      -ms-user-select: none;
+          user-select: none;
+}
+
+/* IE7 fixes */
+*+html .blueimp-gallery > .indicator > li {
+  display: inline;
+}

data/vendor/assets/stylesheets/blueimp-gallery-video.css

@@ -0,0 +1,87 @@
+@charset "UTF-8";
+/*
+ * blueimp Gallery Video Factory CSS 1.3.0
+ * https://github.com/blueimp/Gallery
+ *
+ * Copyright 2013, Sebastian Tschan
+ * https://blueimp.net
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/MIT
+ */
+
+.blueimp-gallery > .slides > .slide > .video-content > img {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  margin: auto;
+  width: auto;
+  height: auto;
+  max-width: 100%;
+  max-height: 100%;
+  /* Prevent artifacts in Mozilla Firefox: */
+  -moz-backface-visibility: hidden;
+}
+.blueimp-gallery > .slides > .slide > .video-content > video {
+  position: absolute;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}
+.blueimp-gallery > .slides > .slide > .video-content > iframe {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  border: none;
+}
+.blueimp-gallery > .slides > .slide > .video-playing > iframe {
+  top: 0;
+}
+.blueimp-gallery > .slides > .slide > .video-content > a {
+  position: absolute;
+  top: 50%;
+  right: 0;
+  left: 0;
+  margin: -64px auto 0;
+  width: 128px;
+  height: 128px;
+  background: url(/assets/Gallery/video-play.png) center no-repeat;
+  opacity: 0.8;
+  cursor: pointer;
+}
+.blueimp-gallery > .slides > .slide > .video-content > a:hover {
+  opacity: 1;
+}
+.blueimp-gallery > .slides > .slide > .video-playing > a,
+.blueimp-gallery > .slides > .slide > .video-playing > img {
+  display: none;
+}
+.blueimp-gallery > .slides > .slide > .video-content > video {
+  display: none;
+}
+.blueimp-gallery > .slides > .slide > .video-playing > video {
+  display: block;
+}
+.blueimp-gallery > .slides > .slide > .video-loading > a {
+  background: url(/assets/Gallery/loading.gif) center no-repeat;
+  background-size: 64px 64px;
+}
+
+/* Replace PNGs with SVGs for capable browsers (excluding IE<9) */
+body:last-child .blueimp-gallery > .slides > .slide > .video-content:not(.video-loading) > a {
+  background-image: url(/assets/Gallery/video-play.svg);
+}
+
+/* IE7 fixes */
+*+html .blueimp-gallery > .slides > .slide > .video-content {
+  height: 100%;
+}
+*+html .blueimp-gallery > .slides > .slide > .video-content > a {
+  left: 50%;
+  margin-left: -64px;
+}