Bootstrap-Image-Gallery-rails 1.0.0.3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fec5ae06e0a86ee24bc15acc8f52e78875743684
+  data.tar.gz: 645e701a154c2f137fec3dbe92e9915bd75fd1d3
+SHA512:
+  metadata.gz: da7b5635812d3f79eb803d687820d73dc044ec5f40980150b028884dabbf653d3827fe7f1964afb1fc59c95c4d76d0f9a4b5c3cfd387ef497bb8987d2a66123b
+  data.tar.gz: c63d9445808f4dd954259c6df65814ac598b09f2249d2dcb1ad26489fd154a8723a0570f4dc32262f63cf9e999647383e51ec630dea4e200f884bd1aa658eb62

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 dogwood008
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# Bootstrap-Image-Gallery-Rails
+This is a Ruby on Rails gem for [Bootstrap-Image-Gallery](https://github.com/blueimp/Bootstrap-Image-Gallery).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'Bootstrap-Image-Gallery-rails', github: 'dogwood008/Bootstrap-Image-Gallery-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install Bootstrap-Image-Gallery-rails
+
+
+## Usage
+
+Add "require" in css/js.
+
+```
+CSS:
+ *= require blueimp-gallery
+ *= require bootstrap-image-gallery
+ *= require blueimp-gallery-indicator
+ *= require blueimp-gallery-video
+
+JS:
+//= require blueimp-gallery
+//= require blueimp-gallery-fullscreen
+//= require blueimp-gallery-indicator
+//= require blueimp-gallery-video
+//= require blueimp-gallery-youtube
+//= require jquery.blueimp-gallery
+//= require bootstrap-image-galler
+```
+
+Do asset compiling.
+
+```
+$ rake assets:precompile
+```
+
+Add the following HTML snippet with the Gallery widget to the body of your webpage:
+
+```html
+<!-- The Bootstrap Image Gallery lightbox, should be a child element of the document body -->
+<div id="blueimp-gallery" class="blueimp-gallery">
+    <!-- The container for the modal slides -->
+    <div class="slides"></div>
+    <!-- Controls for the borderless lightbox -->
+    <h3 class="title"></h3>
+    <a class="prev">‹</a>
+    <a class="next">›</a>
+    <a class="close">×</a>
+    <a class="play-pause"></a>
+    <ol class="indicator"></ol>
+    <!-- The modal dialog, which will be used to wrap the lightbox content -->
+    <div class="modal fade">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <button type="button" class="close" aria-hidden="true">&times;</button>
+                    <h4 class="modal-title"></h4>
+                </div>
+                <div class="modal-body next"></div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-default pull-left prev">
+                        <i class="glyphicon glyphicon-chevron-left"></i>
+                        Previous
+                    </button>
+                    <button type="button" class="btn btn-primary next">
+                        Next
+                        <i class="glyphicon glyphicon-chevron-right"></i>
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+```
+
+Create a list of links to image files with the attribute **data-gallery** (optionally with enclosed thumbnails) and add them to the body of your webpage:
+
+```html
+<div id="links">
+    <a href="images/banana.jpg" title="Banana" data-gallery>
+        <img src="images/thumbnails/banana.jpg" alt="Banana">
+    </a>
+    <a href="images/apple.jpg" title="Apple" data-gallery>
+        <img src="images/thumbnails/apple.jpg" alt="Apple">
+    </a>
+    <a href="images/orange.jpg" title="Orange" data-gallery>
+        <img src="images/thumbnails/orange.jpg" alt="Orange">
+    </a>
+</div>
+```
+
+
+## Requirements
+* [jQuery](http://jquery.com/) v. 1.9.0+
+* [Bootstrap](http://getbootstrap.com/) v. 3.0.0+
+
+## License
+Released under the [MIT license](http://www.opensource.org/licenses/MIT).
+
+## Thanks
+* [blueimp](https://github.com/blueimp)
+* [twbs](https://github.com/twbs)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/Bootstrap-Image-Gallery-rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+=======
+
+Bootstrap-Image-Gallery-rails

data/lib/Bootstrap/Image/Gallery/rails.rb

@@ -0,0 +1,12 @@
+require "Bootstrap/Image/Gallery/rails/version"
+
+module Bootstrap
+  module Image
+    module Gallery
+      module Rails
+        class Engine < ::Rails::Engine
+        end
+      end
+    end
+  end
+end

data/lib/Bootstrap/Image/Gallery/rails/version.rb

@@ -0,0 +1,9 @@
+module Bootstrap
+  module Image
+    module Gallery
+      module Rails
+        VERSION = "1.0.0.3.1.0"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+/*
+ * blueimp Gallery Fullscreen 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 (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            './blueimp-helper',
+            './blueimp-gallery'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.blueimp.helper || window.jQuery,
+            window.blueimp.Gallery
+        );
+    }
+}(function ($, Gallery) {
+    'use strict';
+
+    $.extend(Gallery.prototype.options, {
+        // Defines if the gallery should open in fullscreen mode:
+        fullScreen: false
+    });
+
+    var initialize = Gallery.prototype.initialize,
+        close = Gallery.prototype.close;
+
+    $.extend(Gallery.prototype, {
+
+        getFullScreenElement: function () {
+            return document.fullscreenElement ||
+                document.webkitFullscreenElement ||
+                document.mozFullScreenElement ||
+                document.msFullscreenElement;
+        },
+
+        requestFullScreen: function (element) {
+            if (element.requestFullscreen) {
+                element.requestFullscreen();
+            } else if (element.webkitRequestFullscreen) {
+                element.webkitRequestFullscreen();
+            } else if (element.mozRequestFullScreen) {
+                element.mozRequestFullScreen();
+            } else if (element.msRequestFullscreen) {
+                element.msRequestFullscreen();
+            }
+        },
+
+        exitFullScreen: function () {
+            if (document.exitFullscreen) {
+                document.exitFullscreen();
+            } else if (document.webkitCancelFullScreen) {
+                document.webkitCancelFullScreen();
+            } else if (document.mozCancelFullScreen) {
+                document.mozCancelFullScreen();
+            } else if (document.msExitFullscreen) {
+                document.msExitFullscreen();
+            }
+        },
+
+        initialize: function () {
+            initialize.call(this);
+            if (this.options.fullScreen && !this.getFullScreenElement()) {
+                this.requestFullScreen(this.container[0]);
+            }
+        },
+
+        close: function () {
+            if (this.getFullScreenElement() === this.container[0]) {
+                this.exitFullScreen();
+            }
+            close.call(this);
+        }
+
+    });
+
+    return Gallery;
+}));

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

@@ -0,0 +1,153 @@
+/*
+ * blueimp Gallery Indicator JS 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
+ */
+
+/* global define, window, document */
+
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        // Register as an anonymous AMD module:
+        define([
+            './blueimp-helper',
+            './blueimp-gallery'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.blueimp.helper || window.jQuery,
+            window.blueimp.Gallery
+        );
+    }
+}(function ($, Gallery) {
+    'use strict';
+
+    $.extend(Gallery.prototype.options, {
+        // The tag name, Id, element or querySelector of the indicator container:
+        indicatorContainer: 'ol',
+        // The class for the active indicator:
+        activeIndicatorClass: 'active',
+        // The list object property (or data attribute) with the thumbnail URL,
+        // used as alternative to a thumbnail child element:
+        thumbnailProperty: 'thumbnail',
+        // Defines if the gallery indicators should display a thumbnail:
+        thumbnailIndicators: true
+    });
+
+    var initSlides = Gallery.prototype.initSlides,
+        addSlide = Gallery.prototype.addSlide,
+        resetSlides = Gallery.prototype.resetSlides,
+        handleClick = Gallery.prototype.handleClick,
+        handleSlide = Gallery.prototype.handleSlide,
+        handleClose = Gallery.prototype.handleClose;
+
+    $.extend(Gallery.prototype, {
+
+        createIndicator: function (obj) {
+            var indicator = this.indicatorPrototype.cloneNode(false),
+                title = this.getItemProperty(obj, this.options.titleProperty),
+                thumbnailProperty = this.options.thumbnailProperty,
+                thumbnailUrl,
+                thumbnail;
+            if (this.options.thumbnailIndicators) {
+                thumbnail = obj.getElementsByTagName && $(obj).find('img')[0];
+                if (thumbnail) {
+                    thumbnailUrl = thumbnail.src;
+                } else if (thumbnailProperty) {
+                    thumbnailUrl = this.getItemProperty(obj, thumbnailProperty);
+                }
+                if (thumbnailUrl) {
+                    indicator.style.backgroundImage = 'url("' + thumbnailUrl + '")';
+                }
+            }
+            if (title) {
+                indicator.title = title;
+            }
+            return indicator;
+        },
+
+        addIndicator: function (index) {
+            if (this.indicatorContainer.length) {
+                var indicator = this.createIndicator(this.list[index]);
+                indicator.setAttribute('data-index', index);
+                this.indicatorContainer[0].appendChild(indicator);
+                this.indicators.push(indicator);
+            }
+        },
+
+        setActiveIndicator: function (index) {
+            if (this.indicators) {
+                if (this.activeIndicator) {
+                    this.activeIndicator
+                        .removeClass(this.options.activeIndicatorClass);
+                }
+                this.activeIndicator = $(this.indicators[index]);
+                this.activeIndicator
+                    .addClass(this.options.activeIndicatorClass);
+            }
+        },
+
+        initSlides: function (reload) {
+            if (!reload) {
+                this.indicatorContainer = this.container.find(
+                    this.options.indicatorContainer
+                );
+                if (this.indicatorContainer.length) {
+                    this.indicatorPrototype = document.createElement('li');
+                    this.indicators = this.indicatorContainer[0].children;
+                }
+            }
+            initSlides.call(this, reload);
+        },
+
+        addSlide: function (index) {
+            addSlide.call(this, index);
+            this.addIndicator(index);
+        },
+
+        resetSlides: function () {
+            resetSlides.call(this);
+            this.indicatorContainer.empty();
+            this.indicators = [];
+        },
+
+        handleClick: function (event) {
+            var target = event.target || event.srcElement,
+                parent = target.parentNode;
+            if (parent === this.indicatorContainer[0]) {
+                // Click on indicator element
+                this.preventDefault(event);
+                this.slide(this.getNodeIndex(target));
+            } else if (parent.parentNode === this.indicatorContainer[0]) {
+                // Click on indicator child element
+                this.preventDefault(event);
+                this.slide(this.getNodeIndex(parent));
+            } else {
+                return handleClick.call(this, event);
+            }
+        },
+
+        handleSlide: function (index) {
+            handleSlide.call(this, index);
+            this.setActiveIndicator(index);
+        },
+
+        handleClose: function () {
+            if (this.activeIndicator) {
+                this.activeIndicator
+                    .removeClass(this.options.activeIndicatorClass);
+            }
+            handleClose.call(this);
+        }
+
+    });
+
+    return Gallery;
+}));

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

@@ -0,0 +1,171 @@
+/*
+ * blueimp Gallery Video Factory JS 1.1.1
+ * 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) {
+        // Register as an anonymous AMD module:
+        define([
+            './blueimp-helper',
+            './blueimp-gallery'
+        ], factory);
+    } else {
+        // Browser globals:
+        factory(
+            window.blueimp.helper || window.jQuery,
+            window.blueimp.Gallery
+        );
+    }
+}(function ($, Gallery) {
+    'use strict';
+
+    $.extend(Gallery.prototype.options, {
+        // The class for video content elements:
+        videoContentClass: 'video-content',
+        // The class for video when it is loading:
+        videoLoadingClass: 'video-loading',
+        // The class for video when it is playing:
+        videoPlayingClass: 'video-playing',
+        // The list object property (or data attribute) for the video poster URL:
+        videoPosterProperty: 'poster',
+        // The list object property (or data attribute) for the video sources array:
+        videoSourcesProperty: 'sources'
+    });
+
+    var handleSlide = Gallery.prototype.handleSlide;
+
+    $.extend(Gallery.prototype, {
+
+        handleSlide: function (index) {
+            handleSlide.call(this, index);
+            if (this.playingVideo) {
+                this.playingVideo.pause();
+            }
+        },
+
+        videoFactory: function (obj, callback, videoInterface) {
+            var that = this,
+                options = this.options,
+                videoContainerNode = this.elementPrototype.cloneNode(false),
+                videoContainer = $(videoContainerNode),
+                errorArgs = [{
+                    type: 'error',
+                    target: videoContainerNode
+                }],
+                video = videoInterface || document.createElement('video'),
+                url = this.getItemProperty(obj, options.urlProperty),
+                type = this.getItemProperty(obj, options.typeProperty),
+                title = this.getItemProperty(obj, options.titleProperty),
+                posterUrl = this.getItemProperty(obj, options.videoPosterProperty),
+                posterImage,
+                sources = this.getItemProperty(
+                    obj,
+                    options.videoSourcesProperty
+                ),
+                source,
+                playMediaControl,
+                isLoading,
+                hasControls;
+            videoContainer.addClass(options.videoContentClass);
+            if (title) {
+                videoContainerNode.title = title;
+            }
+            if (video.canPlayType) {
+                if (url && type && video.canPlayType(type)) {
+                    video.src = url;
+                } else {
+                    while (sources && sources.length) {
+                        source = sources.shift();
+                        url = this.getItemProperty(source, options.urlProperty);
+                        type = this.getItemProperty(source, options.typeProperty);
+                        if (url && type && video.canPlayType(type)) {
+                            video.src = url;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (posterUrl) {
+                video.poster = posterUrl;
+                posterImage = this.imagePrototype.cloneNode(false);
+                $(posterImage).addClass(options.toggleClass);
+                posterImage.src = posterUrl;
+                posterImage.draggable = false;
+                videoContainerNode.appendChild(posterImage);
+            }
+            playMediaControl = document.createElement('a');
+            playMediaControl.setAttribute('target', '_blank');
+            if (!videoInterface) {
+                playMediaControl.setAttribute('download', title);
+            }
+            playMediaControl.href = url;
+            if (video.src) {
+                video.controls = true;
+                (videoInterface || $(video))
+                    .on('error', function () {
+                        that.setTimeout(callback, errorArgs);
+                    })
+                    .on('pause', function () {
+                        isLoading = false;
+                        videoContainer
+                            .removeClass(that.options.videoLoadingClass)
+                            .removeClass(that.options.videoPlayingClass);
+                        if (hasControls) {
+                            that.container.addClass(that.options.controlsClass);
+                        }
+                        delete that.playingVideo;
+                        if (that.interval) {
+                            that.play();
+                        }
+                    })
+                    .on('playing', function () {
+                        isLoading = false;
+                        videoContainer
+                            .removeClass(that.options.videoLoadingClass)
+                            .addClass(that.options.videoPlayingClass);
+                        if (that.container.hasClass(that.options.controlsClass)) {
+                            hasControls = true;
+                            that.container.removeClass(that.options.controlsClass);
+                        } else {
+                            hasControls = false;
+                        }
+                    })
+                    .on('play', function () {
+                        window.clearTimeout(that.timeout);
+                        isLoading = true;
+                        videoContainer.addClass(that.options.videoLoadingClass);
+                        that.playingVideo = video;
+                    });
+                $(playMediaControl).on('click', function (event) {
+                    that.preventDefault(event);
+                    if (isLoading) {
+                        video.pause();
+                    } else {
+                        video.play();
+                    }
+                });
+                videoContainerNode.appendChild(
+                    (videoInterface && videoInterface.element) || video
+                );
+            }
+            videoContainerNode.appendChild(playMediaControl);
+            this.setTimeout(callback, [{
+                type: 'load',
+                target: videoContainerNode
+            }]);
+            return videoContainerNode;
+        }
+    });
+
+    return Gallery;
+}));