uikit-sass-rails 1.0.0

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

@@ -0,0 +1,177 @@
+/*! 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-notify", ["uikit"], function(){
+            return component || addon(jQuery, jQuery.UIkit);
+        });
+    }
+
+})(function($, UI){
+
+    var containers = {},
+        messages   = {},
+
+        notify     =  function(options){
+
+            if ($.type(options) == 'string') {
+                options = { message: options };
+            }
+
+            if (arguments[1]) {
+                options = $.extend(options, $.type(arguments[1]) == 'string' ? {status:arguments[1]} : arguments[1]);
+            }
+
+            return (new Message(options)).show();
+        },
+        closeAll  = function(group, instantly){
+            if(group) {
+                for(var id in messages) { if(group===messages[id].group) messages[id].close(instantly); }
+            } else {
+                for(var id in messages) { messages[id].close(instantly); }
+            }
+        };
+
+    var Message = function(options){
+
+        var $this = this;
+
+        this.options = $.extend({}, Message.defaults, options);
+
+        this.uuid    = "ID"+(new Date().getTime())+"RAND"+(Math.ceil(Math.random() * 100000));
+        this.element = $([
+
+            '<div class="uk-notify-message">',
+                '<a class="uk-close"></a>',
+                '<div>'+this.options.message+'</div>',
+            '</div>'
+
+        ].join('')).data("notifyMessage", this);
+
+        // status
+        if (this.options.status) {
+            this.element.addClass('uk-notify-message-'+this.options.status);
+            this.currentstatus = this.options.status;
+        }
+
+        this.group = this.options.group;
+
+        messages[this.uuid] = this;
+
+        if(!containers[this.options.pos]) {
+            containers[this.options.pos] = $('<div class="uk-notify uk-notify-'+this.options.pos+'"></div>').appendTo('body').on("click", ".uk-notify-message", function(){
+                $(this).data("notifyMessage").close();
+            });
+        }
+    };
+
+
+    $.extend(Message.prototype, {
+
+        uuid: false,
+        element: false,
+        timout: false,
+        currentstatus: "",
+        group: false,
+
+        show: function() {
+
+            if (this.element.is(":visible")) return;
+
+            var $this = this;
+
+            containers[this.options.pos].show().prepend(this.element);
+
+            var marginbottom = parseInt(this.element.css("margin-bottom"), 10);
+
+            this.element.css({"opacity":0, "margin-top": -1*this.element.outerHeight(), "margin-bottom":0}).animate({"opacity":1, "margin-top": 0, "margin-bottom":marginbottom}, function(){
+
+                if ($this.options.timeout) {
+
+                    var closefn = function(){ $this.close(); };
+
+                    $this.timeout = setTimeout(closefn, $this.options.timeout);
+
+                    $this.element.hover(
+                        function() { clearTimeout($this.timeout); },
+                        function() { $this.timeout = setTimeout(closefn, $this.options.timeout);  }
+                    );
+                }
+
+            });
+
+            return this;
+        },
+
+        close: function(instantly) {
+
+            var $this    = this,
+                finalize = function(){
+                    $this.element.remove();
+
+                    if(!containers[$this.options.pos].children().length) {
+                        containers[$this.options.pos].hide();
+                    }
+
+                    delete messages[$this.uuid];
+                };
+
+            if(this.timeout) clearTimeout(this.timeout);
+
+            if(instantly) {
+                finalize();
+            } else {
+                this.element.animate({"opacity":0, "margin-top": -1* this.element.outerHeight(), "margin-bottom":0}, function(){
+                    finalize();
+                });
+            }
+        },
+
+        content: function(html){
+
+            var container = this.element.find(">div");
+
+            if(!html) {
+                return container.html();
+            }
+
+            container.html(html);
+
+            return this;
+        },
+
+        status: function(status) {
+
+            if(!status) {
+                return this.currentstatus;
+            }
+
+            this.element.removeClass('uk-notify-message-'+this.currentstatus).addClass('uk-notify-message-'+status);
+
+            this.currentstatus = status;
+
+            return this;
+        }
+    });
+
+    Message.defaults = {
+        message: "",
+        status: "",
+        timeout: 5000,
+        group: null,
+        pos: 'top-center'
+    };
+
+    UI.notify          = notify;
+    UI.notify.message  = Message;
+    UI.notify.closeAll = closeAll;
+
+    return notify;
+});

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

@@ -0,0 +1,146 @@
+/*! UIkit 2.8.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+
+/*
+ * Based on simplePagination - Copyright (c) 2012 Flavius Matis - http://flaviusmatis.github.com/simplePagination.js/ (MIT)
+ */
+(function(addon) {
+
+    var component;
+
+    if (jQuery && jQuery.UIkit) {
+        component = addon(jQuery, jQuery.UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-pagination", ["uikit"], function(){
+            return component || addon(jQuery, jQuery.UIkit);
+        });
+    }
+
+})(function($, UI){
+
+    "use strict";
+
+    UI.component('pagination', {
+
+        defaults: {
+            items          : 1,
+            itemsOnPage    : 1,
+            pages          : 0,
+            displayedPages : 3,
+            edges          : 3,
+            currentPage    : 1,
+            lblPrev        : false,
+            lblNext        : false,
+            onSelectPage   : function() {}
+        },
+
+        init: function() {
+
+            var $this = this;
+
+            this.pages         = this.options.pages ?  this.options.pages : Math.ceil(this.options.items / this.options.itemsOnPage) ? Math.ceil(this.options.items / this.options.itemsOnPage) : 1;
+            this.currentPage   = this.options.currentPage - 1;
+            this.halfDisplayed = this.options.displayedPages / 2;
+
+            this.on("click", "a[data-page]", function(e){
+                e.preventDefault();
+                $this.selectPage($(this).data("page"));
+            });
+
+            this._render();
+        },
+
+        _getInterval: function() {
+
+            return {
+                start: Math.ceil(this.currentPage > this.halfDisplayed ? Math.max(Math.min(this.currentPage - this.halfDisplayed, (this.pages - this.options.displayedPages)), 0) : 0),
+                end  : Math.ceil(this.currentPage > this.halfDisplayed ? Math.min(this.currentPage + this.halfDisplayed, this.pages) : Math.min(this.options.displayedPages, this.pages))
+            };
+        },
+
+        render: function(pages) {
+            this.pages = pages ? pages : this.pages;
+            this._render();
+        },
+
+        selectPage: function(pageIndex, pages) {
+            this.currentPage = pageIndex;
+            this.render(pages);
+
+            this.options.onSelectPage.apply(this, [pageIndex]);
+            this.trigger('uk-select-page', [pageIndex, this]);
+        },
+
+        _render: function() {
+
+            var o = this.options, interval = this._getInterval(), i;
+
+            this.element.empty();
+
+            // Generate Prev link
+            if (o.lblPrev) this._append(o.currentPage - 1, {text: o.lblPrev});
+
+            // Generate start edges
+            if (interval.start > 0 && o.edges > 0) {
+
+                var end = Math.min(o.edges, interval.start);
+
+                for (i = 0; i < end; i++) this._append(i);
+
+                if (o.edges < interval.start && (interval.start - o.edges != 1)) {
+                    this.element.append('<li><span>...</span></li>');
+                } else if (interval.start - o.edges == 1) {
+                    this._append(o.edges);
+                }
+            }
+
+            // Generate interval links
+            for (i = interval.start; i < interval.end; i++) this._append(i);
+
+            // Generate end edges
+            if (interval.end < this.pages && o.edges > 0) {
+
+                if (this.pages - o.edges > interval.end && (this.pages - o.edges - interval.end != 1)) {
+                    this.element.append('<li><span>...</span></li>');
+                } else if (this.pages - o.edges - interval.end == 1) {
+                    this._append(interval.end++);
+                }
+
+                var begin = Math.max(this.pages - o.edges, interval.end);
+
+                for (i = begin; i < this.pages; i++) this._append(i);
+            }
+
+            // Generate Next link (unless option is set for at front)
+            if (o.lblNext) this._append(o.currentPage + 1, {text: o.lblNext});
+        },
+
+        _append: function(pageIndex, opts) {
+
+            var $this = this, item, link, options;
+
+            pageIndex = pageIndex < 0 ? 0 : (pageIndex < this.pages ? pageIndex : this.pages - 1);
+            options   = $.extend({ text: pageIndex + 1 }, opts);
+
+            item = (pageIndex == this.currentPage) ? '<li class="uk-active"><span>' + (options.text) + '</span></li>'
+                                                   : '<li><a href="#page-'+(pageIndex+1)+'" data-page="'+pageIndex+'">'+options.text+'</a></li>';
+
+            this.element.append(item);
+        }
+    });
+
+    // init code
+    $(document).on("uk-domready", function(e) {
+
+        $("[data-uk-pagination]").each(function(){
+            var ele = $(this);
+
+            if (!ele.data("pagination")) {
+                var obj = UI.pagination(ele, UI.Utils.options(ele.attr("data-uk-pagination")));
+            }
+        });
+    });
+
+    return UI.pagination;
+});

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

@@ -0,0 +1,90 @@
+/*! 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";
+
+    UI.component('search', {
+        defaults: {
+            msgResultsHeader   : 'Search Results',
+            msgMoreResults     : 'More Results',
+            msgNoResults       : 'No results found',
+            template           : '<ul class="uk-nav uk-nav-search uk-autocomplete-results">\
+                                      {{#msgResultsHeader}}<li class="uk-nav-header uk-skip">{{msgResultsHeader}}</li>{{/msgResultsHeader}}\
+                                      {{#items && items.length}}\
+                                          {{~items}}\
+                                          <li data-url="{{!$item.url}}">\
+                                              <a href="{{!$item.url}}">\
+                                                  {{{$item.title}}}\
+                                                  {{#$item.text}}<div>{{{$item.text}}}</div>{{/$item.text}}\
+                                              </a>\
+                                          </li>\
+                                          {{/items}}\
+                                          {{#msgMoreResults}}\
+                                              <li class="uk-nav-divider uk-skip"></li>\
+                                              <li class="uk-search-moreresults" data-moreresults="true"><a href="#" onclick="jQuery(this).closest(\'form\').submit();">{{msgMoreResults}}</a></li>\
+                                          {{/msgMoreResults}}\
+                                      {{/end}}\
+                                      {{^items.length}}\
+                                        {{#msgNoResults}}<li class="uk-skip"><a>{{msgNoResults}}</a></li>{{/msgNoResults}}\
+                                      {{/end}}\
+                                  </ul>',
+
+            renderer: function(data) {
+
+                var $this = this, opts = this.options;
+
+                this.dropdown.append(this.template({"items":data.results || [], "msgResultsHeader":opts.msgResultsHeader, "msgMoreResults": opts.msgMoreResults, "msgNoResults": opts.msgNoResults}));
+                this.show();
+            }
+        },
+
+        init: function() {
+            var $this = this;
+
+            this.autocomplete = UI.autocomplete(this.element, this.options);
+
+            this.autocomplete.dropdown.addClass('uk-dropdown-search');
+
+            this.autocomplete.input.on("keyup", function(){
+                $this.element[$this.autocomplete.input.val() ? "addClass":"removeClass"]("uk-active");
+            }).closest("form").on("reset", function(){
+                $this.value="";
+                $this.element.removeClass("uk-active");
+            });
+
+            this.on('autocomplete-select', function(e, data) {
+                if (data.url) {
+                  location.href = data.url;
+                } else if(data.moreresults) {
+                  this.autocomplete.input.closest('form').submit();
+                }
+            });
+
+            this.element.data("search", this);
+        }
+    });
+
+    // init code
+    $(document).on("focus.search.uikit", "[data-uk-search]", function(e) {
+        var ele = $(this);
+
+        if (!ele.data("search")) {
+            var obj = UI.search(ele, UI.Utils.options(ele.attr("data-uk-search")));
+        }
+    });
+});

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

@@ -0,0 +1,494 @@
+/*! UIkit 2.8.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
+
+/*
+  * Based on nativesortable - Copyright (c) Brian Grinstead - https://github.com/bgrins/nativesortable
+  */
+(function(addon) {
+
+    var component;
+
+    if (jQuery && jQuery.UIkit) {
+        component = addon(jQuery, jQuery.UIkit);
+    }
+
+    if (typeof define == "function" && define.amd) {
+        define("uikit-sortable", ["uikit"], function(){
+            return component || addon(jQuery, jQuery.UIkit);
+        });
+    }
+
+})(function($, UI){
+
+    "use strict";
+
+    var supportsTouch       = ('ontouchstart' in window) || (window.DocumentTouch && document instanceof DocumentTouch),
+        supportsDragAndDrop = !supportsTouch && (function() {
+        var div = document.createElement('div');
+        return ('draggable' in div) || ('ondragstart' in div && 'ondrop' in div);
+    })(),
+
+    draggingPlaceholder, moving, clickedlink;
+
+    // disable native dragndrop support for now
+    supportsDragAndDrop = false;
+
+    UI.component('sortable', {
+
+        defaults: {
+
+            warp             : false,
+            animation        : 150,
+
+            childClass       : 'uk-sortable-item',
+            placeholderClass : 'uk-sortable-placeholder',
+            overClass        : 'uk-sortable-over',
+            draggingClass    : 'uk-sortable-dragged',
+            dragMovingClass  : 'uk-sortable-moving',
+            dragCustomClass  : '',
+
+            handleClass      : false,
+
+            stop             : function() {},
+            start            : function() {},
+            change           : function() {}
+        },
+
+        init: function() {
+
+            var $this                    = this,
+                element                  = this.element[0],
+                currentlyDraggingElement = null,
+                currentlyDraggingTarget  = null,
+                children;
+
+            if (supportsDragAndDrop) {
+                this.element.children().attr("draggable", "true");
+
+            } else {
+
+                // prevent leaving page after link clicking
+                this.element.on('mousedown touchstart', 'a[href]', function(e) {
+                    clickedlink = $(this);
+                }).on('click', 'a[href]', function(e) {
+                    clickedlink = $(this);
+                    e.stopImmediatePropagation();
+                    return false;
+                });
+            }
+
+            var handleDragStart = delegate(function(e) {
+
+                moving = false;
+
+                var target = $(e.target), children = $this.element.children();
+
+                if (!supportsTouch && e.button==2) {
+                    return;
+                }
+
+                if ($this.options.handleClass) {
+
+                    var handle = target.hasClass($this.options.handleClass) ? target : target.closest('.'+$this.options.handleClass, element);
+
+                    if (!handle.length) {
+                        e.preventDefault();
+                        return;
+                    }
+                }
+
+                if (e.dataTransfer) {
+                    e.dataTransfer.effectAllowed = 'move';
+                    e.dataTransfer.dropEffect = 'move';
+                    e.dataTransfer.setData('Text', "*"); // Need to set to something or else drag doesn't start
+                }
+
+                currentlyDraggingElement = this;
+
+                // init drag placeholder
+                if (draggingPlaceholder) draggingPlaceholder.remove();
+
+                var $current = $(currentlyDraggingElement), offset = $current.offset();
+
+                draggingPlaceholder = $('<div class="'+([$this.options.draggingClass, $this.options.dragCustomClass].join(' '))+'"></div>').css({
+                    display : 'none',
+                    top     : offset.top,
+                    left    : offset.left,
+                    width   : $current.width(),
+                    height  : $current.height(),
+                    padding : $current.css('padding')
+                }).data('mouse-offset', {
+                    'left': offset.left - parseInt(e.pageX, 10),
+                    'top' : offset.top  - parseInt(e.pageY, 10)
+                }).append($current.html()).appendTo('body');
+
+                draggingPlaceholder.$current  = $current;
+                draggingPlaceholder.$sortable = $this;
+
+                addFakeDragHandlers();
+
+                $this.options.start(this, currentlyDraggingElement);
+                $this.trigger('sortable-start', [$this, currentlyDraggingElement]);
+
+                if (!supportsDragAndDrop) {
+                    e.preventDefault();
+                }
+            });
+
+            var handleDragOver = delegate(function(e) {
+
+                if (!currentlyDraggingElement) {
+                    return true;
+                }
+
+                if (e.preventDefault) {
+                    e.preventDefault();
+                }
+
+                return false;
+            });
+
+            var handleDragEnter = delegate($.UIkit.Utils.debounce(function(e) {
+
+                if (!currentlyDraggingElement || currentlyDraggingElement === this) {
+                    return true;
+                }
+
+                // Prevent dragenter on a child from allowing a dragleave on the container
+                var previousCounter = $this.dragenterData(this);
+
+                $this.dragenterData(this, previousCounter + 1);
+
+                if (previousCounter === 0) {
+
+                    $(this).addClass($this.options.overClass);
+
+                    if (!$this.options.warp) {
+                        $this.moveElementNextTo(currentlyDraggingElement, this);
+                    }
+                }
+
+                return false;
+            }), 40);
+
+            var handleDragLeave = delegate(function(e) {
+
+                // Prevent dragenter on a child from allowing a dragleave on the container
+                var previousCounter = $this.dragenterData(this);
+                $this.dragenterData(this, previousCounter - 1);
+
+                // This is a fix for child elements firing dragenter before the parent fires dragleave
+                if (!$this.dragenterData(this)) {
+                    $(this).removeClass($this.options.overClass);
+                    $this.dragenterData(this, false);
+                }
+            });
+
+            var handleDrop = delegate(function(e) {
+
+                if (e.type === 'drop') {
+
+                    if (e.stopPropagation) {
+                        e.stopPropagation();
+                    }
+
+                    if (e.preventDefault) {
+                        e.preventDefault();
+                    }
+                }
+
+                if (this === currentlyDraggingElement) {
+                    return;
+                }
+
+                if ($this.options.warp) {
+                    var thisSibling = currentlyDraggingElement.nextSibling;
+                    this.parentNode.insertBefore(currentlyDraggingElement, this);
+                    this.parentNode.insertBefore(this, thisSibling);
+                }
+
+                $this.options.change(this, currentlyDraggingElement);
+                $this.trigger('sortable-change', [$this, currentlyDraggingElement]);
+            });
+
+            var handleDragEnd = function(e) {
+
+                currentlyDraggingElement = null;
+                currentlyDraggingTarget  = null;
+
+                $this.element.children().each(function() {
+                    if (this.nodeType === 1) {
+                        $(this).removeClass($this.options.overClass).removeClass($this.options.placeholderClass).removeClass($this.options.childClass);
+                        $this.dragenterData(this, false);
+                    }
+                });
+
+                $('html').removeClass($this.options.dragMovingClass);
+
+                removeFakeDragHandlers();
+
+                $this.options.stop(this);
+                $this.trigger('sortable-stop', [$this]);
+
+                draggingPlaceholder.remove();
+                draggingPlaceholder = null;
+            };
+
+            var handleTouchMove = delegate(function(e) {
+
+                if (!currentlyDraggingElement ||
+                    currentlyDraggingElement === this ||
+                    currentlyDraggingTarget === this) {
+                    return true;
+                }
+
+                children.removeClass($this.options.overClass);
+                currentlyDraggingTarget = this;
+
+                if (!$this.options.warp) {
+                    $this.moveElementNextTo(currentlyDraggingElement, this);
+                } else {
+                    $(this).addClass($this.options.overClass);
+                }
+
+                return prevent(e);
+            });
+
+            function delegate(fn) {
+                return function(e) {
+
+                    var touch  = (supportsTouch && e.touches && e.touches[0]) || { },
+                        target = touch.target || e.target;
+
+                    // Fix event.target for a touch event
+                    if (supportsTouch && document.elementFromPoint) {
+                        target = document.elementFromPoint(e.pageX - document.body.scrollLeft, e.pageY - document.body.scrollTop);
+                    }
+
+                    if ($(target).hasClass($this.options.childClass)) {
+                        fn.apply(target, [e]);
+                    } else if (target !== element) {
+
+                        // If a child is initiating the event or ending it, then use the container as context for the callback.
+                        var context = moveUpToChildNode(element, target);
+
+                        if (context) {
+                            fn.apply(context, [e]);
+                        }
+                    }
+                };
+            }
+
+            // Opera and mobile devices do not support drag and drop.  http://caniuse.com/dragndrop
+            // Bind/unbind standard mouse/touch events as a polyfill.
+            function addFakeDragHandlers() {
+                if (!supportsDragAndDrop) {
+                    if (supportsTouch) {
+                        element.addEventListener("touchmove", handleTouchMove, false);
+                    } else {
+                        element.addEventListener('mouseover', handleDragEnter, false);
+                        element.addEventListener('mouseout', handleDragLeave, false);
+                    }
+
+                    element.addEventListener(supportsTouch ? 'touchend' : 'mouseup', handleDrop, false);
+                    document.addEventListener(supportsTouch ? 'touchend' : 'mouseup', handleDragEnd, false);
+                    document.addEventListener("selectstart", prevent, false);
+
+                }
+            }
+
+            function removeFakeDragHandlers() {
+                if (!supportsDragAndDrop) {
+                    if (supportsTouch) {
+                        element.removeEventListener("touchmove", handleTouchMove, false);
+                    } else {
+                        element.removeEventListener('mouseover', handleDragEnter, false);
+                        element.removeEventListener('mouseout', handleDragLeave, false);
+                    }
+
+                    element.removeEventListener(supportsTouch ? 'touchend' : 'mouseup', handleDrop, false);
+                    document.removeEventListener(supportsTouch ? 'touchend' : 'mouseup', handleDragEnd, false);
+                    document.removeEventListener("selectstart", prevent, false);
+                }
+            }
+
+            if (supportsDragAndDrop) {
+                element.addEventListener('dragstart', handleDragStart, false);
+                element.addEventListener('dragenter', handleDragEnter, false);
+                element.addEventListener('dragleave', handleDragLeave, false);
+                element.addEventListener('drop', handleDrop, false);
+                element.addEventListener('dragover', handleDragOver, false);
+                element.addEventListener('dragend', handleDragEnd, false);
+            } else {
+
+                element.addEventListener(supportsTouch ? 'touchstart':'mousedown', handleDragStart, false);
+            }
+        },
+
+        dragenterData: function(element, val) {
+
+            element = $(element);
+
+            if (arguments.length == 1) {
+                return parseInt(element.attr('data-child-dragenter'), 10) || 0;
+            } else if (!val) {
+                element.removeAttr('data-child-dragenter');
+            } else {
+                element.attr('data-child-dragenter', Math.max(0, val));
+            }
+        },
+
+        moveElementNextTo: function(element, elementToMoveNextTo) {
+
+            var $this    = this,
+                list     = $(element).parent().css('min-height', ''),
+                next     = isBelow(element, elementToMoveNextTo) ? elementToMoveNextTo : elementToMoveNextTo.nextSibling,
+                children = list.children(),
+                count    = children.length;
+
+            if($this.options.warp || !$this.options.animation) {
+                elementToMoveNextTo.parentNode.insertBefore(element, next);
+                $(document).trigger("uk-check-display");
+                return;
+            }
+
+            list.css('min-height', list.height());
+
+            children.stop().each(function(){
+                var ele = $(this),
+                    offset = ele.position();
+
+                    offset.width = ele.width();
+
+                ele.data('offset-before', offset);
+            });
+
+            elementToMoveNextTo.parentNode.insertBefore(element, next);
+
+            children = list.children().each(function() {
+                var ele    = $(this);
+                ele.data('offset-after', ele.position());
+            }).each(function() {
+                var ele    = $(this),
+                    before = ele.data('offset-before');
+                ele.css({'position':'absolute', 'top':before.top, 'left':before.left, 'min-width':before.width });
+            });
+
+            children.each(function(){
+
+                var ele    = $(this),
+                    before = ele.data('offset-before'),
+                    offset = ele.data('offset-after');
+
+                    ele.css('pointer-events', 'none').width();
+
+                    setTimeout(function(){
+                        ele.animate({'top':offset.top, 'left':offset.left}, $this.options.animation, function() {
+                            ele.css({'position':'','top':'', 'left':'', 'min-width': '', 'pointer-events':''}).removeClass($this.options.overClass).attr('data-child-dragenter', '');
+                            count--
+                            if (!count) {
+                                list.css('min-height', '');
+                                $(document).trigger("uk-check-display");
+                            }
+                        });
+                    }, 0);
+            });
+
+
+        }
+    });
+
+    // helpers
+
+    function isBelow(el1, el2) {
+
+        var parent = el1.parentNode;
+
+        if (el2.parentNode != parent) {
+            return false;
+        }
+
+        var cur = el1.previousSibling;
+
+        while (cur && cur.nodeType !== 9) {
+            if (cur === el2) {
+                return true;
+            }
+            cur = cur.previousSibling;
+        }
+
+        return false;
+    }
+
+    function moveUpToChildNode(parent, child) {
+        var cur = child;
+        if (cur == parent) { return null; }
+
+        while (cur) {
+            if (cur.parentNode === parent) {
+                return cur;
+            }
+
+            cur = cur.parentNode;
+            if ( !cur || !cur.ownerDocument || cur.nodeType === 11 ) {
+                break;
+            }
+        }
+        return null;
+    }
+
+    function prevent(e) {
+        if (e.stopPropagation) {
+            e.stopPropagation();
+        }
+        if (e.preventDefault) {
+            e.preventDefault();
+        }
+        e.returnValue = false;
+    }
+
+    // auto init
+    $(document).on("uk-domready", function(e) {
+
+        $("[data-uk-sortable]").each(function(){
+
+          var ele = $(this);
+
+          if(!ele.data("sortable")) {
+              var plugin = UI.sortable(ele, UI.Utils.options(ele.attr("data-uk-sortable")));
+          }
+        });
+    });
+
+    $(document).on('mousemove touchmove', function(e) {
+
+        if (draggingPlaceholder) {
+
+            if (!moving) {
+                moving = true;
+                draggingPlaceholder.show();
+
+                draggingPlaceholder.$current.addClass(draggingPlaceholder.$sortable.options.placeholderClass);
+                draggingPlaceholder.$sortable.element.children().addClass(draggingPlaceholder.$sortable.options.childClass);
+
+                $('html').addClass(draggingPlaceholder.$sortable.options.dragMovingClass);
+            }
+
+            var offset = draggingPlaceholder.data('mouse-offset'),
+                left   = parseInt(e.originalEvent.pageX, 10) + offset.left,
+                top    = parseInt(e.originalEvent.pageY, 10) + offset.top;
+
+            draggingPlaceholder.css({'left': left, 'top': top });
+        }
+    });
+
+    $(document).on('mouseup touchend', function() {
+
+        if(!moving && clickedlink) {
+            location.href = clickedlink.attr('href');
+        }
+
+        clickedlink = false;
+    });
+
+    return UI.sortable;
+});