uikit-on-rails 1.5.0

data/vendor/assets/javascripts/uikit/components/tooltip.js

@@ -0,0 +1,234 @@
+/*! UIkit 2.27.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-tooltip", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+
+})(function(UI){
+
+    "use strict";
+
+    var $tooltip,   // tooltip container
+        tooltipdelay, checkdelay;
+
+    UI.component('tooltip', {
+
+        defaults: {
+            offset: 5,
+            pos: 'top',
+            animation: false,
+            delay: 0, // in miliseconds
+            cls: "",
+            activeClass: "uk-active",
+            src: function(ele) {
+                var title = ele.attr('title');
+
+                if (title !== undefined) {
+                    ele.data('cached-title', title).removeAttr('title');
+                }
+
+                return ele.data("cached-title");
+            }
+        },
+
+        tip: "",
+
+        boot: function() {
+
+            // init code
+            UI.$html.on("mouseenter.tooltip.uikit focus.tooltip.uikit", "[data-uk-tooltip]", function(e) {
+                var ele = UI.$(this);
+
+                if (!ele.data("tooltip")) {
+                    UI.tooltip(ele, UI.Utils.options(ele.attr("data-uk-tooltip")));
+                    ele.trigger("mouseenter");
+                }
+            });
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            if (!$tooltip) {
+                $tooltip = UI.$('<div class="uk-tooltip"></div>').appendTo("body");
+            }
+
+            this.on({
+                focus      : function(e) { $this.show(); },
+                blur       : function(e) { $this.hide(); },
+                mouseenter : function(e) { $this.show(); },
+                mouseleave : function(e) { $this.hide(); }
+            });
+        },
+
+        show: function() {
+
+            this.tip = typeof(this.options.src) === "function" ? this.options.src(this.element) : this.options.src;
+
+            if (tooltipdelay)     clearTimeout(tooltipdelay);
+            if (checkdelay)       clearTimeout(checkdelay);
+
+            if (typeof(this.tip) === 'string' ? !this.tip.length:true) return;
+
+            $tooltip.stop().css({"top": -2000, "visibility": "hidden"}).removeClass(this.options.activeClass).show();
+            $tooltip.html('<div class="uk-tooltip-inner">' + this.tip + '</div>');
+
+            var $this      = this,
+                pos        = UI.$.extend({}, this.element.offset(), {width: this.element[0].offsetWidth, height: this.element[0].offsetHeight}),
+                width      = $tooltip[0].offsetWidth,
+                height     = $tooltip[0].offsetHeight,
+                offset     = typeof(this.options.offset) === "function" ? this.options.offset.call(this.element) : this.options.offset,
+                position   = typeof(this.options.pos) === "function" ? this.options.pos.call(this.element) : this.options.pos,
+                tmppos     = position.split("-"),
+                tcss       = {
+                    "display"    : "none",
+                    "visibility" : "visible",
+                    "top"        : (pos.top + pos.height + height),
+                    "left"       : pos.left
+                };
+
+
+            // prevent strange position
+            // when tooltip is in offcanvas etc.
+            if (UI.$html.css('position')=='fixed' || UI.$body.css('position')=='fixed'){
+                var bodyoffset = UI.$('body').offset(),
+                    htmloffset = UI.$('html').offset(),
+                    docoffset  = {'top': (htmloffset.top + bodyoffset.top), 'left': (htmloffset.left + bodyoffset.left)};
+
+                pos.left -= docoffset.left;
+                pos.top  -= docoffset.top;
+            }
+
+
+            if ((tmppos[0] == "left" || tmppos[0] == "right") && UI.langdirection == 'right') {
+                tmppos[0] = tmppos[0] == "left" ? "right" : "left";
+            }
+
+            var variants =  {
+                "bottom"  : {top: pos.top + pos.height + offset, left: pos.left + pos.width / 2 - width / 2},
+                "top"     : {top: pos.top - height - offset, left: pos.left + pos.width / 2 - width / 2},
+                "left"    : {top: pos.top + pos.height / 2 - height / 2, left: pos.left - width - offset},
+                "right"   : {top: pos.top + pos.height / 2 - height / 2, left: pos.left + pos.width + offset}
+            };
+
+            UI.$.extend(tcss, variants[tmppos[0]]);
+
+            if (tmppos.length == 2) tcss.left = (tmppos[1] == 'left') ? (pos.left) : ((pos.left + pos.width) - width);
+
+            var boundary = this.checkBoundary(tcss.left, tcss.top, width, height);
+
+            if(boundary) {
+
+                switch(boundary) {
+                    case "x":
+
+                        if (tmppos.length == 2) {
+                            position = tmppos[0]+"-"+(tcss.left < 0 ? "left": "right");
+                        } else {
+                            position = tcss.left < 0 ? "right": "left";
+                        }
+
+                        break;
+
+                    case "y":
+                        if (tmppos.length == 2) {
+                            position = (tcss.top < 0 ? "bottom": "top")+"-"+tmppos[1];
+                        } else {
+                            position = (tcss.top < 0 ? "bottom": "top");
+                        }
+
+                        break;
+
+                    case "xy":
+                        if (tmppos.length == 2) {
+                            position = (tcss.top < 0 ? "bottom": "top")+"-"+(tcss.left < 0 ? "left": "right");
+                        } else {
+                            position = tcss.left < 0 ? "right": "left";
+                        }
+
+                        break;
+
+                }
+
+                tmppos = position.split("-");
+
+                UI.$.extend(tcss, variants[tmppos[0]]);
+
+                if (tmppos.length == 2) tcss.left = (tmppos[1] == 'left') ? (pos.left) : ((pos.left + pos.width) - width);
+            }
+
+
+            tcss.left -= UI.$body.position().left;
+
+            tooltipdelay = setTimeout(function(){
+
+                $tooltip.css(tcss).attr("class", ["uk-tooltip", "uk-tooltip-"+position, $this.options.cls].join(' '));
+
+                if ($this.options.animation) {
+                    $tooltip.css({opacity: 0, display: 'block'}).addClass($this.options.activeClass).animate({opacity: 1}, parseInt($this.options.animation, 10) || 400);
+                } else {
+                    $tooltip.show().addClass($this.options.activeClass);
+                }
+
+                tooltipdelay = false;
+
+                // close tooltip if element was removed or hidden
+                checkdelay = setInterval(function(){
+                    if(!$this.element.is(':visible')) $this.hide();
+                }, 150);
+
+            }, parseInt(this.options.delay, 10) || 0);
+        },
+
+        hide: function() {
+            if(this.element.is("input") && this.element[0]===document.activeElement) return;
+
+            if(tooltipdelay) clearTimeout(tooltipdelay);
+            if (checkdelay)  clearTimeout(checkdelay);
+
+            $tooltip.stop();
+
+            if (this.options.animation) {
+
+                var $this = this;
+
+                $tooltip.fadeOut(parseInt(this.options.animation, 10) || 400, function(){
+                    $tooltip.removeClass($this.options.activeClass)
+                });
+
+            } else {
+                $tooltip.hide().removeClass(this.options.activeClass);
+            }
+        },
+
+        content: function() {
+            return this.tip;
+        },
+
+        checkBoundary: function(left, top, width, height) {
+
+            var axis = "";
+
+            if(left < 0 || ((left - UI.$win.scrollLeft())+width) > window.innerWidth) {
+               axis += "x";
+            }
+
+            if(top < 0 || ((top - UI.$win.scrollTop())+height) > window.innerHeight) {
+               axis += "y";
+            }
+
+            return axis;
+        }
+    });
+
+    return UI.tooltip;
+});

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

@@ -0,0 +1,262 @@
+/*! UIkit 2.27.1 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+(function(addon) {
+
+    var component;
+
+    if (window.UIkit) {
+        component = addon(UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-upload", ["uikit"], function(){
+            return component || addon(UIkit);
+        });
+    }
+
+})(function(UI){
+
+    "use strict";
+
+    UI.component('uploadSelect', {
+
+        init: function() {
+
+            var $this = this;
+
+            this.on("change", function() {
+                xhrupload($this.element[0].files, $this.options);
+                var twin = $this.element.clone(true).data('uploadSelect', $this);
+                $this.element.replaceWith(twin);
+                $this.element = twin;
+            });
+        }
+    });
+
+    UI.component('uploadDrop', {
+
+        defaults: {
+            'dragoverClass': 'uk-dragover'
+        },
+
+        init: function() {
+
+            var $this = this, hasdragCls = false;
+
+            this.on("drop", function(e){
+
+                if (e.originalEvent.dataTransfer && e.originalEvent.dataTransfer.files) {
+
+                    e.stopPropagation();
+                    e.preventDefault();
+
+                    $this.element.removeClass($this.options.dragoverClass);
+                    $this.element.trigger('dropped.uk.upload', [e.originalEvent.dataTransfer.files]);
+
+                    xhrupload(e.originalEvent.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();
+    })();
+
+
+    function xhrupload(files, settings) {
+
+        if (!UI.support.ajaxupload){
+            return this;
+        }
+
+        settings = UI.$.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,
+                allow    = true;
+
+                settings.beforeAll(files);
+
+                settings.complete = function(response, xhr){
+
+                    uploaded = uploaded + 1;
+
+                    complete(response, xhr);
+
+                    if (settings.filelimit && uploaded >= settings.filelimit){
+                        allow = false;
+                    }
+
+                    if (allow && 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);
+
+            if (settings.type=="json") {
+                xhr.setRequestHeader("Accept", "application/json");
+            }
+
+            for (var h in settings.headers) {
+                xhr.setRequestHeader(h, settings.headers[h]);
+            }
+
+            xhr.onreadystatechange = function() {
+
+                settings.readystatechange(xhr);
+
+                if (xhr.readyState==4){
+
+                    var response = xhr.responseText;
+
+                    if (settings.type=="json") {
+                        try {
+                            response = UI.$.parseJSON(response);
+                        } catch(e) {
+                            response = false;
+                        }
+                    }
+
+                    settings.complete(response, xhr);
+                }
+            };
+            settings.beforeSend(xhr);
+            xhr.send(formData);
+        }
+    }
+
+    xhrupload.defaults = {
+        action: '',
+        single: true,
+        method: 'POST',
+        param : 'files[]',
+        params: {},
+        allow : '*.*',
+        type  : 'text',
+        filelimit: false,
+        headers: {},
+
+        // events
+        before          : function(o){},
+        beforeSend      : function(xhr){},
+        beforeAll       : function(){},
+        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;
+});