uikit-sass-rails 1.0.0

data/vendor/assets/javascripts/uikit/addons/sticky.js

@@ -0,0 +1,130 @@
+/*! UIkit 2.8.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+
+(function(addon) {
+
+    var component;
+
+    if (jQuery && jQuery.UIkit) {
+        component = addon(jQuery, jQuery.UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-sticky", ["uikit"], function(){
+            return component || addon(jQuery, jQuery.UIkit);
+        });
+    }
+
+})(function($, UI){
+
+    var $win         = UI.$win,
+        $doc         = UI.$doc,
+        sticked      = [];
+
+    UI.component('sticky', {
+
+        defaults: {
+            top          : 0,
+            bottom       : 0,
+            clsactive    : 'uk-active',
+            clswrapper   : 'uk-sticky',
+            getWidthFrom : ''
+        },
+
+        init: function() {
+
+            var stickyId = this.element.attr('id') || ("s"+Math.ceil(Math.random()*10000)),
+                wrapper  = $('<div></div>').attr('id', 'sticky-'+stickyId).addClass(this.options.clswrapper);
+
+            wrapper = this.element.wrap(wrapper).parent().css('height', this.element.outerHeight());
+
+            if (this.element.css("float") != "none") {
+                wrapper.css({"float":this.element.css("float")});
+                this.element.css({"float":"none"});
+            }
+
+            sticked.push({
+                top: this.options.top,
+                bottom: this.options.bottom,
+                element: this.element,
+                currentTop: null,
+                wrapper: wrapper,
+                clsactive: this.options.clsactive,
+                getWidthFrom: this.options.getWidthFrom || wrapper
+            });
+        },
+
+        update: function() {
+            scroller();
+        }
+    });
+
+    function scroller() {
+
+        if (!sticked.length) return;
+
+        var scrollTop       = $win.scrollTop(),
+            documentHeight  = $doc.height(),
+            dwh             = documentHeight - $win.height(),
+            extra           = (scrollTop > dwh) ? dwh - scrollTop : 0;
+
+        for (var i = 0; i < sticked.length; i++) {
+
+            if (!sticked[i].element.is(":visible")) {
+                continue;
+            }
+
+            var sticky     = sticked[i],
+                elementTop = sticky.wrapper.offset().top,
+                etse       = elementTop - sticky.top - extra;
+
+            if (scrollTop <= etse) {
+
+                if (sticky.currentTop !== null) {
+                    sticky.element.css({"position":"", "top":"", "width":"", "left":""});
+                    sticky.wrapper.removeClass(sticky.clsactive);
+                    sticky.currentTop = null;
+                }
+
+            } else {
+
+                var newTop = documentHeight - sticky.element.outerHeight() - sticky.top - sticky.bottom - scrollTop - extra;
+
+                newTop = newTop < 0 ? newTop + sticky.top : sticky.top;
+
+                if (sticky.currentTop != newTop) {
+                    sticky.element.css({
+                        "position" : "fixed",
+                        "top"      : newTop,
+                        "width"    : (typeof sticky.getWidthFrom !== 'undefined') ? $(sticky.getWidthFrom).width() : sticky.element.width(),
+                        "left"     : sticky.wrapper.offset().left
+                    });
+
+                    sticky.wrapper.addClass(sticky.clsactive);
+                    sticky.currentTop = newTop;
+                }
+            }
+        }
+
+    }
+
+    // should be more efficient than using $win.scroll(scroller):
+    $doc.on('uk-scroll', scroller);
+
+    $doc.on("uk-domready", function(e) {
+        setTimeout(function(){
+
+            scroller();
+
+            $("[data-uk-sticky]").each(function(){
+
+                var $ele = $(this);
+
+                if(!$ele.data("sticky")) {
+                    UI.sticky($ele, UI.Utils.options($ele.attr('data-uk-sticky')));
+                }
+            });
+        }, 0);
+    });
+
+    return $.fn.uksticky;
+});

data/vendor/assets/javascripts/uikit/addons/timepicker.js

@@ -0,0 +1,163 @@
+/*! UIkit 2.8.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+
+(function(addon) {
+
+    var component;
+
+    if (jQuery && jQuery.UIkit) {
+        component = addon(jQuery, jQuery.UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-search", ["uikit"], function(){
+            return component || addon(jQuery, jQuery.UIkit);
+        });
+    }
+
+})(function($, UI){
+
+    "use strict";
+
+    var times = {'12h':[], '24h':[]};
+
+    for(var i = 0, h=''; i<24; i++) {
+
+        h = ''+i;
+
+        if(i<10)  h = '0'+h;
+
+        times['24h'].push({value: (h+':00')});
+        times['24h'].push({value: (h+':30')});
+
+        if (i<13) {
+            times['12h'].push({value: (h+':00 AM')});
+            times['12h'].push({value: (h+':30 AM')});
+        }
+
+        if (i > 12) {
+
+            h = h-12;
+
+            if (h < 10) h = '0'+String(h);
+
+            times['12h'].push({value: (h+':00 PM')});
+            times['12h'].push({value: (h+':30 PM')});
+        }
+    }
+
+
+    UI.component('timepicker', {
+
+        defaults: {
+            format : '24h',
+            delay  : 0
+        },
+
+        init: function() {
+
+            var $this  = this;
+
+            this.options.minLength = 0;
+            this.options.template  = '<ul class="uk-nav uk-nav-autocomplete uk-autocomplete-results">{{~items}}<li data-value="{{$item.value}}"><a>{{$item.value}}</a></li>{{/items}}</ul>';
+
+            this.options.source = function(release) {
+                release(times[$this.options.format] || times['12h']);
+            };
+
+            this.element.wrap('<div class="uk-autocomplete"></div>');
+
+            this.autocomplete = UI.autocomplete(this.element.parent(), this.options);
+            this.autocomplete.dropdown.addClass('uk-dropdown-scrollable');
+
+            this.autocomplete.on('autocomplete-show', function() {
+
+                var selected = $this.autocomplete.dropdown.find('[data-value="'+$this.element.val()+'"]');
+
+                setTimeout(function(){
+                    $this.autocomplete.pick(selected, true);
+                }, 10);
+            });
+
+            this.element.on('focus', function(){
+
+                $this.autocomplete.value = Math.random();
+                $this.autocomplete.triggercomplete();
+
+            }).on('blur', function() {
+                $this.checkTime();
+            });
+
+            this.element.data("timepicker", this);
+        },
+
+        checkTime: function() {
+
+            var arr, timeArray, meridian = 'AM', hour, minute, time = this.element.val();
+
+            if (this.options.format == '12h') {
+                arr = time.split(' ');
+                timeArray = arr[0].split(':');
+                meridian = arr[1];
+            } else {
+                timeArray = time.split(':');
+            }
+
+            hour   = parseInt(timeArray[0], 10);
+            minute = parseInt(timeArray[1], 10);
+
+            if (isNaN(hour))   hour = 0;
+            if (isNaN(minute)) minute = 0;
+
+            if (this.options.format == '12h') {
+                if (hour > 12) {
+                    hour = 12;
+                } else if (hour < 0) {
+                    hour = 12;
+                }
+
+                if (meridian === 'am' || meridian === 'a') {
+                    meridian = 'AM';
+                } else if (meridian === 'pm' || meridian === 'p') {
+                    meridian = 'PM';
+                }
+
+                if (meridian !== 'AM' && meridian !== 'PM') {
+                    meridian = 'AM';
+                }
+
+            } else {
+
+                if (hour >= 24) {
+                    hour = 23;
+                } else if (hour < 0) {
+                    hour = 0;
+                }
+            }
+
+            if (minute < 0) {
+                minute = 0;
+            } else if (minute >= 60) {
+                minute = 0;
+            }
+
+            this.element.val(this.formatTime(hour, minute, meridian));
+        },
+
+        formatTime: function(hour, minute, meridian) {
+            hour = hour < 10 ? '0' + hour : hour;
+            minute = minute < 10 ? '0' + minute : minute;
+            return hour + ':' + minute + (this.options.format == '12h' ? ' ' + meridian : '');
+        }
+    });
+
+    // init code
+    $(document).on("focus.timepicker.uikit", "[data-uk-timepicker]", function(e) {
+        var ele = $(this);
+
+        if (!ele.data("timepicker")) {
+            var obj = UI.timepicker(ele, UI.Utils.options(ele.attr("data-uk-timepicker")));
+
+            ele.focus();
+        }
+    });
+});

data/vendor/assets/javascripts/uikit/addons/upload.js

@@ -0,0 +1,239 @@
+/*! UIkit 2.8.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+
+(function(addon) {
+
+    var component;
+
+    if (jQuery && jQuery.UIkit) {
+        component = addon(jQuery, jQuery.UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-upload", ["uikit"], function(){
+            return component || addon(jQuery, jQuery.UIkit);
+        });
+    }
+
+})(function($, UI){
+
+    UI.component('uploadSelect', {
+
+
+        init: function() {
+
+            var $this = this;
+
+            this.on("change", function() {
+                xhrupload($this.element[0].files, $this.options);
+            });
+        }
+    });
+
+    UI.component('uploadDrop', {
+
+        defaults: {
+            'dragoverClass': 'uk-dragover'
+        },
+
+        init: function() {
+
+            var $this = this, hasdragCls = false;
+
+            this.on("drop", function(e){
+
+                if (e.dataTransfer && e.dataTransfer.files) {
+
+                    e.stopPropagation();
+                    e.preventDefault();
+
+                    $this.element.removeClass($this.options.dragoverClass);
+
+                    xhrupload(e.dataTransfer.files, $this.options);
+                }
+
+            }).on("dragenter", function(e){
+                e.stopPropagation();
+                e.preventDefault();
+            }).on("dragover", function(e){
+                e.stopPropagation();
+                e.preventDefault();
+
+                if (!hasdragCls) {
+                    $this.element.addClass($this.options.dragoverClass);
+                    hasdragCls = true;
+                }
+            }).on("dragleave", function(e){
+                e.stopPropagation();
+                e.preventDefault();
+                $this.element.removeClass($this.options.dragoverClass);
+                hasdragCls = false;
+            });
+        }
+    });
+
+
+    UI.support.ajaxupload = (function() {
+
+        function supportFileAPI() {
+            var fi = document.createElement('INPUT'); fi.type = 'file'; return 'files' in fi;
+        }
+
+        function supportAjaxUploadProgressEvents() {
+            var xhr = new XMLHttpRequest(); return !! (xhr && ('upload' in xhr) && ('onprogress' in xhr.upload));
+        }
+
+        function supportFormData() {
+            return !! window.FormData;
+        }
+
+        return supportFileAPI() && supportAjaxUploadProgressEvents() && supportFormData();
+    })();
+
+    if (UI.support.ajaxupload){
+        $.event.props.push("dataTransfer");
+    }
+
+    function xhrupload(files, settings) {
+
+        if (!UI.support.ajaxupload){
+            return this;
+        }
+
+        settings = $.extend({}, xhrupload.defaults, settings);
+
+        if (!files.length){
+            return;
+        }
+
+        if (settings.allow !== '*.*') {
+
+            for(var i=0,file;file=files[i];i++) {
+
+                if(!matchName(settings.allow, file.name)) {
+
+                    if(typeof(settings.notallowed) == 'string') {
+                       alert(settings.notallowed);
+                    } else {
+                       settings.notallowed(file, settings);
+                    }
+                    return;
+                }
+            }
+        }
+
+        var complete = settings.complete;
+
+        if (settings.single){
+
+            var count    = files.length,
+                uploaded = 0;
+
+                settings.complete = function(response, xhr){
+                    uploaded = uploaded+1;
+                    complete(response, xhr);
+                    if (uploaded<count){
+                        upload([files[uploaded]], settings);
+                    } else {
+                        settings.allcomplete(response, xhr);
+                    }
+                };
+
+                upload([files[0]], settings);
+
+        } else {
+
+            settings.complete = function(response, xhr){
+                complete(response, xhr);
+                settings.allcomplete(response, xhr);
+            };
+
+            upload(files, settings);
+        }
+
+        function upload(files, settings){
+
+            // upload all at once
+            var formData = new FormData(), xhr = new XMLHttpRequest();
+
+            if (settings.before(settings, files)===false) return;
+
+            for (var i = 0, f; f = files[i]; i++) { formData.append(settings.param, f); }
+            for (var p in settings.params) { formData.append(p, settings.params[p]); }
+
+            // Add any event handlers here...
+            xhr.upload.addEventListener("progress", function(e){
+                var percent = (e.loaded / e.total)*100;
+                settings.progress(percent, e);
+            }, false);
+
+            xhr.addEventListener("loadstart", function(e){ settings.loadstart(e); }, false);
+            xhr.addEventListener("load",      function(e){ settings.load(e);      }, false);
+            xhr.addEventListener("loadend",   function(e){ settings.loadend(e);   }, false);
+            xhr.addEventListener("error",     function(e){ settings.error(e);     }, false);
+            xhr.addEventListener("abort",     function(e){ settings.abort(e);     }, false);
+
+            xhr.open(settings.method, settings.action, true);
+
+            xhr.onreadystatechange = function() {
+
+                settings.readystatechange(xhr);
+
+                if (xhr.readyState==4){
+
+                    var response = xhr.responseText;
+
+                    if (settings.type=="json") {
+                        try {
+                            response = $.parseJSON(response);
+                        } catch(e) {
+                            response = false;
+                        }
+                    }
+
+                    settings.complete(response, xhr);
+                }
+            };
+
+            xhr.send(formData);
+        }
+    }
+
+    xhrupload.defaults = {
+        'action': '',
+        'single': true,
+        'method': 'POST',
+        'param' : 'files[]',
+        'params': {},
+        'allow' : '*.*',
+        'type'  : 'text',
+
+        // events
+        'before'          : function(o){},
+        'loadstart'       : function(){},
+        'load'            : function(){},
+        'loadend'         : function(){},
+        'error'           : function(){},
+        'abort'           : function(){},
+        'progress'        : function(){},
+        'complete'        : function(){},
+        'allcomplete'     : function(){},
+        'readystatechange': function(){},
+        'notallowed'      : function(file, settings){ alert('Only the following file types are allowed: '+settings.allow); }
+    };
+
+    function matchName(pattern, path) {
+
+        var parsedPattern = '^' + pattern.replace(/\//g, '\\/').
+            replace(/\*\*/g, '(\\/[^\\/]+)*').
+            replace(/\*/g, '[^\\/]+').
+            replace(/((?!\\))\?/g, '$1.') + '$';
+
+        parsedPattern = '^' + parsedPattern + '$';
+
+        return (path.match(new RegExp(parsedPattern, 'i')) !== null);
+    }
+
+    UI.Utils.xhrupload = xhrupload;
+
+    return xhrupload;
+});