751 lines
23 KiB
JavaScript
751 lines
23 KiB
JavaScript
/*! UIkit 2.25.0 | http://www.getuikit.com | (c) 2014 YOOtheme | MIT License */
|
|
(function(core) {
|
|
|
|
if (typeof define == "function" && define.amd) { // AMD
|
|
|
|
define("uikit", function(){
|
|
|
|
var uikit = window.UIkit || core(window, window.jQuery, window.document);
|
|
|
|
uikit.load = function(res, req, onload, config) {
|
|
|
|
var resources = res.split(','), load = [], i, base = (config.config && config.config.uikit && config.config.uikit.base ? config.config.uikit.base : "").replace(/\/+$/g, "");
|
|
|
|
if (!base) {
|
|
throw new Error( "Please define base path to UIkit in the requirejs config." );
|
|
}
|
|
|
|
for (i = 0; i < resources.length; i += 1) {
|
|
var resource = resources[i].replace(/\./g, '/');
|
|
load.push(base+'/components/'+resource);
|
|
}
|
|
|
|
req(load, function() {
|
|
onload(uikit);
|
|
});
|
|
};
|
|
|
|
return uikit;
|
|
});
|
|
}
|
|
|
|
if (!window.jQuery) {
|
|
throw new Error( "UIkit requires jQuery" );
|
|
}
|
|
|
|
if (window && window.jQuery) {
|
|
core(window, window.jQuery, window.document);
|
|
}
|
|
|
|
|
|
})(function(global, $, doc) {
|
|
|
|
"use strict";
|
|
|
|
var UI = {}, _UI = global.UIkit ? Object.create(global.UIkit) : undefined;
|
|
|
|
UI.version = '2.25.0';
|
|
|
|
UI.noConflict = function() {
|
|
// restore UIkit version
|
|
if (_UI) {
|
|
global.UIkit = _UI;
|
|
$.UIkit = _UI;
|
|
$.fn.uk = _UI.fn;
|
|
}
|
|
|
|
return UI;
|
|
};
|
|
|
|
UI.prefix = function(str) {
|
|
return str;
|
|
};
|
|
|
|
// cache jQuery
|
|
UI.$ = $;
|
|
|
|
UI.$doc = UI.$(document);
|
|
UI.$win = UI.$(window);
|
|
UI.$html = UI.$('html');
|
|
|
|
UI.support = {};
|
|
UI.support.transition = (function() {
|
|
|
|
var transitionEnd = (function() {
|
|
|
|
var element = doc.body || doc.documentElement,
|
|
transEndEventNames = {
|
|
WebkitTransition : 'webkitTransitionEnd',
|
|
MozTransition : 'transitionend',
|
|
OTransition : 'oTransitionEnd otransitionend',
|
|
transition : 'transitionend'
|
|
}, name;
|
|
|
|
for (name in transEndEventNames) {
|
|
if (element.style[name] !== undefined) return transEndEventNames[name];
|
|
}
|
|
}());
|
|
|
|
return transitionEnd && { end: transitionEnd };
|
|
})();
|
|
|
|
UI.support.animation = (function() {
|
|
|
|
var animationEnd = (function() {
|
|
|
|
var element = doc.body || doc.documentElement,
|
|
animEndEventNames = {
|
|
WebkitAnimation : 'webkitAnimationEnd',
|
|
MozAnimation : 'animationend',
|
|
OAnimation : 'oAnimationEnd oanimationend',
|
|
animation : 'animationend'
|
|
}, name;
|
|
|
|
for (name in animEndEventNames) {
|
|
if (element.style[name] !== undefined) return animEndEventNames[name];
|
|
}
|
|
}());
|
|
|
|
return animationEnd && { end: animationEnd };
|
|
})();
|
|
|
|
// requestAnimationFrame polyfill
|
|
//https://github.com/darius/requestAnimationFrame
|
|
(function() {
|
|
|
|
Date.now = Date.now || function() { return new Date().getTime(); };
|
|
|
|
var vendors = ['webkit', 'moz'];
|
|
for (var i = 0; i < vendors.length && !window.requestAnimationFrame; ++i) {
|
|
var vp = vendors[i];
|
|
window.requestAnimationFrame = window[vp+'RequestAnimationFrame'];
|
|
window.cancelAnimationFrame = (window[vp+'CancelAnimationFrame']
|
|
|| window[vp+'CancelRequestAnimationFrame']);
|
|
}
|
|
if (/iP(ad|hone|od).*OS 6/.test(window.navigator.userAgent) // iOS6 is buggy
|
|
|| !window.requestAnimationFrame || !window.cancelAnimationFrame) {
|
|
var lastTime = 0;
|
|
window.requestAnimationFrame = function(callback) {
|
|
var now = Date.now();
|
|
var nextTime = Math.max(lastTime + 16, now);
|
|
return setTimeout(function() { callback(lastTime = nextTime); },
|
|
nextTime - now);
|
|
};
|
|
window.cancelAnimationFrame = clearTimeout;
|
|
}
|
|
}());
|
|
|
|
UI.support.touch = (
|
|
('ontouchstart' in document) ||
|
|
(global.DocumentTouch && document instanceof global.DocumentTouch) ||
|
|
(global.navigator.msPointerEnabled && global.navigator.msMaxTouchPoints > 0) || //IE 10
|
|
(global.navigator.pointerEnabled && global.navigator.maxTouchPoints > 0) || //IE >=11
|
|
false
|
|
);
|
|
|
|
UI.support.mutationobserver = (global.MutationObserver || global.WebKitMutationObserver || null);
|
|
|
|
UI.Utils = {};
|
|
|
|
UI.Utils.isFullscreen = function() {
|
|
return document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement || document.fullscreenElement || false;
|
|
};
|
|
|
|
UI.Utils.str2json = function(str, notevil) {
|
|
try {
|
|
if (notevil) {
|
|
return JSON.parse(str
|
|
// wrap keys without quote with valid double quote
|
|
.replace(/([\$\w]+)\s*:/g, function(_, $1){return '"'+$1+'":';})
|
|
// replacing single quote wrapped ones to double quote
|
|
.replace(/'([^']+)'/g, function(_, $1){return '"'+$1+'"';})
|
|
);
|
|
} else {
|
|
return (new Function("", "var json = " + str + "; return JSON.parse(JSON.stringify(json));"))();
|
|
}
|
|
} catch(e) { return false; }
|
|
};
|
|
|
|
UI.Utils.debounce = function(func, wait, immediate) {
|
|
var timeout;
|
|
return function() {
|
|
var context = this, args = arguments;
|
|
var later = function() {
|
|
timeout = null;
|
|
if (!immediate) func.apply(context, args);
|
|
};
|
|
var callNow = immediate && !timeout;
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(later, wait);
|
|
if (callNow) func.apply(context, args);
|
|
};
|
|
};
|
|
|
|
UI.Utils.removeCssRules = function(selectorRegEx) {
|
|
var idx, idxs, stylesheet, _i, _j, _k, _len, _len1, _len2, _ref;
|
|
|
|
if(!selectorRegEx) return;
|
|
|
|
setTimeout(function(){
|
|
try {
|
|
_ref = document.styleSheets;
|
|
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
|
stylesheet = _ref[_i];
|
|
idxs = [];
|
|
stylesheet.cssRules = stylesheet.cssRules;
|
|
for (idx = _j = 0, _len1 = stylesheet.cssRules.length; _j < _len1; idx = ++_j) {
|
|
if (stylesheet.cssRules[idx].type === CSSRule.STYLE_RULE && selectorRegEx.test(stylesheet.cssRules[idx].selectorText)) {
|
|
idxs.unshift(idx);
|
|
}
|
|
}
|
|
for (_k = 0, _len2 = idxs.length; _k < _len2; _k++) {
|
|
stylesheet.deleteRule(idxs[_k]);
|
|
}
|
|
}
|
|
} catch (_error) {}
|
|
}, 0);
|
|
};
|
|
|
|
UI.Utils.isInView = function(element, options) {
|
|
|
|
var $element = $(element);
|
|
|
|
if (!$element.is(':visible')) {
|
|
return false;
|
|
}
|
|
|
|
var window_left = UI.$win.scrollLeft(), window_top = UI.$win.scrollTop(), offset = $element.offset(), left = offset.left, top = offset.top;
|
|
|
|
options = $.extend({topoffset:0, leftoffset:0}, options);
|
|
|
|
if (top + $element.height() >= window_top && top - options.topoffset <= window_top + UI.$win.height() &&
|
|
left + $element.width() >= window_left && left - options.leftoffset <= window_left + UI.$win.width()) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
UI.Utils.checkDisplay = function(context, initanimation) {
|
|
|
|
var elements = UI.$('[data-uk-margin], [data-uk-grid-match], [data-uk-grid-margin], [data-uk-check-display]', context || document), animated;
|
|
|
|
if (context && !elements.length) {
|
|
elements = $(context);
|
|
}
|
|
|
|
elements.trigger('display.uk.check');
|
|
|
|
// fix firefox / IE animations
|
|
if (initanimation) {
|
|
|
|
if (typeof(initanimation)!='string') {
|
|
initanimation = '[class*="uk-animation-"]';
|
|
}
|
|
|
|
elements.find(initanimation).each(function(){
|
|
|
|
var ele = UI.$(this),
|
|
cls = ele.attr('class'),
|
|
anim = cls.match(/uk\-animation\-(.+)/);
|
|
|
|
ele.removeClass(anim[0]).width();
|
|
|
|
ele.addClass(anim[0]);
|
|
});
|
|
}
|
|
|
|
return elements;
|
|
};
|
|
|
|
UI.Utils.options = function(string) {
|
|
|
|
if ($.type(string)!='string') return string;
|
|
|
|
if (string.indexOf(':') != -1 && string.trim().substr(-1) != '}') {
|
|
string = '{'+string+'}';
|
|
}
|
|
|
|
var start = (string ? string.indexOf("{") : -1), options = {};
|
|
|
|
if (start != -1) {
|
|
try {
|
|
options = UI.Utils.str2json(string.substr(start));
|
|
} catch (e) {}
|
|
}
|
|
|
|
return options;
|
|
};
|
|
|
|
UI.Utils.animate = function(element, cls) {
|
|
|
|
var d = $.Deferred();
|
|
|
|
element = UI.$(element);
|
|
|
|
element.css('display', 'none').addClass(cls).one(UI.support.animation.end, function() {
|
|
element.removeClass(cls);
|
|
d.resolve();
|
|
});
|
|
|
|
element.css('display', '');
|
|
|
|
return d.promise();
|
|
};
|
|
|
|
UI.Utils.uid = function(prefix) {
|
|
return (prefix || 'id') + (new Date().getTime())+"RAND"+(Math.ceil(Math.random() * 100000));
|
|
};
|
|
|
|
UI.Utils.template = function(str, data) {
|
|
|
|
var tokens = str.replace(/\n/g, '\\n').replace(/\{\{\{\s*(.+?)\s*\}\}\}/g, "{{!$1}}").split(/(\{\{\s*(.+?)\s*\}\})/g),
|
|
i=0, toc, cmd, prop, val, fn, output = [], openblocks = 0;
|
|
|
|
while(i < tokens.length) {
|
|
|
|
toc = tokens[i];
|
|
|
|
if(toc.match(/\{\{\s*(.+?)\s*\}\}/)) {
|
|
i = i + 1;
|
|
toc = tokens[i];
|
|
cmd = toc[0];
|
|
prop = toc.substring(toc.match(/^(\^|\#|\!|\~|\:)/) ? 1:0);
|
|
|
|
switch(cmd) {
|
|
case '~':
|
|
output.push("for(var $i=0;$i<"+prop+".length;$i++) { var $item = "+prop+"[$i];");
|
|
openblocks++;
|
|
break;
|
|
case ':':
|
|
output.push("for(var $key in "+prop+") { var $val = "+prop+"[$key];");
|
|
openblocks++;
|
|
break;
|
|
case '#':
|
|
output.push("if("+prop+") {");
|
|
openblocks++;
|
|
break;
|
|
case '^':
|
|
output.push("if(!"+prop+") {");
|
|
openblocks++;
|
|
break;
|
|
case '/':
|
|
output.push("}");
|
|
openblocks--;
|
|
break;
|
|
case '!':
|
|
output.push("__ret.push("+prop+");");
|
|
break;
|
|
default:
|
|
output.push("__ret.push(escape("+prop+"));");
|
|
break;
|
|
}
|
|
} else {
|
|
output.push("__ret.push('"+toc.replace(/\'/g, "\\'")+"');");
|
|
}
|
|
i = i + 1;
|
|
}
|
|
|
|
fn = new Function('$data', [
|
|
'var __ret = [];',
|
|
'try {',
|
|
'with($data){', (!openblocks ? output.join('') : '__ret = ["Not all blocks are closed correctly."]'), '};',
|
|
'}catch(e){__ret = [e.message];}',
|
|
'return __ret.join("").replace(/\\n\\n/g, "\\n");',
|
|
"function escape(html) { return String(html).replace(/&/g, '&').replace(/\"/g, '"').replace(/</g, '<').replace(/>/g, '>');}"
|
|
].join("\n"));
|
|
|
|
return data ? fn(data) : fn;
|
|
};
|
|
|
|
UI.Utils.events = {};
|
|
UI.Utils.events.click = UI.support.touch ? 'tap' : 'click';
|
|
|
|
global.UIkit = UI;
|
|
|
|
// deprecated
|
|
|
|
UI.fn = function(command, options) {
|
|
|
|
var args = arguments, cmd = command.match(/^([a-z\-]+)(?:\.([a-z]+))?/i), component = cmd[1], method = cmd[2];
|
|
|
|
if (!UI[component]) {
|
|
$.error("UIkit component [" + component + "] does not exist.");
|
|
return this;
|
|
}
|
|
|
|
return this.each(function() {
|
|
var $this = $(this), data = $this.data(component);
|
|
if (!data) $this.data(component, (data = UI[component](this, method ? undefined : options)));
|
|
if (method) data[method].apply(data, Array.prototype.slice.call(args, 1));
|
|
});
|
|
};
|
|
|
|
$.UIkit = UI;
|
|
$.fn.uk = UI.fn;
|
|
|
|
UI.langdirection = UI.$html.attr("dir") == "rtl" ? "right" : "left";
|
|
|
|
UI.components = {};
|
|
|
|
UI.component = function(name, def) {
|
|
|
|
var fn = function(element, options) {
|
|
|
|
var $this = this;
|
|
|
|
this.UIkit = UI;
|
|
this.element = element ? UI.$(element) : null;
|
|
this.options = $.extend(true, {}, this.defaults, options);
|
|
this.plugins = {};
|
|
|
|
if (this.element) {
|
|
this.element.data(name, this);
|
|
}
|
|
|
|
this.init();
|
|
|
|
(this.options.plugins.length ? this.options.plugins : Object.keys(fn.plugins)).forEach(function(plugin) {
|
|
|
|
if (fn.plugins[plugin].init) {
|
|
fn.plugins[plugin].init($this);
|
|
$this.plugins[plugin] = true;
|
|
}
|
|
|
|
});
|
|
|
|
this.trigger('init.uk.component', [name, this]);
|
|
|
|
return this;
|
|
};
|
|
|
|
fn.plugins = {};
|
|
|
|
$.extend(true, fn.prototype, {
|
|
|
|
defaults : {plugins: []},
|
|
|
|
boot: function(){},
|
|
init: function(){},
|
|
|
|
on: function(a1,a2,a3){
|
|
return UI.$(this.element || this).on(a1,a2,a3);
|
|
},
|
|
|
|
one: function(a1,a2,a3){
|
|
return UI.$(this.element || this).one(a1,a2,a3);
|
|
},
|
|
|
|
off: function(evt){
|
|
return UI.$(this.element || this).off(evt);
|
|
},
|
|
|
|
trigger: function(evt, params) {
|
|
return UI.$(this.element || this).trigger(evt, params);
|
|
},
|
|
|
|
find: function(selector) {
|
|
return UI.$(this.element ? this.element: []).find(selector);
|
|
},
|
|
|
|
proxy: function(obj, methods) {
|
|
|
|
var $this = this;
|
|
|
|
methods.split(' ').forEach(function(method) {
|
|
if (!$this[method]) $this[method] = function() { return obj[method].apply(obj, arguments); };
|
|
});
|
|
},
|
|
|
|
mixin: function(obj, methods) {
|
|
|
|
var $this = this;
|
|
|
|
methods.split(' ').forEach(function(method) {
|
|
if (!$this[method]) $this[method] = obj[method].bind($this);
|
|
});
|
|
},
|
|
|
|
option: function() {
|
|
|
|
if (arguments.length == 1) {
|
|
return this.options[arguments[0]] || undefined;
|
|
} else if (arguments.length == 2) {
|
|
this.options[arguments[0]] = arguments[1];
|
|
}
|
|
}
|
|
|
|
}, def);
|
|
|
|
this.components[name] = fn;
|
|
|
|
this[name] = function() {
|
|
|
|
var element, options;
|
|
|
|
if (arguments.length) {
|
|
|
|
switch(arguments.length) {
|
|
case 1:
|
|
|
|
if (typeof arguments[0] === "string" || arguments[0].nodeType || arguments[0] instanceof jQuery) {
|
|
element = $(arguments[0]);
|
|
} else {
|
|
options = arguments[0];
|
|
}
|
|
|
|
break;
|
|
case 2:
|
|
|
|
element = $(arguments[0]);
|
|
options = arguments[1];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (element && element.data(name)) {
|
|
return element.data(name);
|
|
}
|
|
|
|
return (new UI.components[name](element, options));
|
|
};
|
|
|
|
if (UI.domready) {
|
|
UI.component.boot(name);
|
|
}
|
|
|
|
return fn;
|
|
};
|
|
|
|
UI.plugin = function(component, name, def) {
|
|
this.components[component].plugins[name] = def;
|
|
};
|
|
|
|
UI.component.boot = function(name) {
|
|
|
|
if (UI.components[name].prototype && UI.components[name].prototype.boot && !UI.components[name].booted) {
|
|
UI.components[name].prototype.boot.apply(UI, []);
|
|
UI.components[name].booted = true;
|
|
}
|
|
};
|
|
|
|
UI.component.bootComponents = function() {
|
|
|
|
for (var component in UI.components) {
|
|
UI.component.boot(component);
|
|
}
|
|
};
|
|
|
|
|
|
// DOM mutation save ready helper function
|
|
|
|
UI.domObservers = [];
|
|
UI.domready = false;
|
|
|
|
UI.ready = function(fn) {
|
|
|
|
UI.domObservers.push(fn);
|
|
|
|
if (UI.domready) {
|
|
fn(document);
|
|
}
|
|
};
|
|
|
|
UI.on = function(a1,a2,a3){
|
|
|
|
if (a1 && a1.indexOf('ready.uk.dom') > -1 && UI.domready) {
|
|
a2.apply(UI.$doc);
|
|
}
|
|
|
|
return UI.$doc.on(a1,a2,a3);
|
|
};
|
|
|
|
UI.one = function(a1,a2,a3){
|
|
|
|
if (a1 && a1.indexOf('ready.uk.dom') > -1 && UI.domready) {
|
|
a2.apply(UI.$doc);
|
|
return UI.$doc;
|
|
}
|
|
|
|
return UI.$doc.one(a1,a2,a3);
|
|
};
|
|
|
|
UI.trigger = function(evt, params) {
|
|
return UI.$doc.trigger(evt, params);
|
|
};
|
|
|
|
UI.domObserve = function(selector, fn) {
|
|
|
|
if(!UI.support.mutationobserver) return;
|
|
|
|
fn = fn || function() {};
|
|
|
|
UI.$(selector).each(function() {
|
|
|
|
var element = this,
|
|
$element = UI.$(element);
|
|
|
|
if ($element.data('observer')) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
|
|
var observer = new UI.support.mutationobserver(UI.Utils.debounce(function(mutations) {
|
|
fn.apply(element, []);
|
|
$element.trigger('changed.uk.dom');
|
|
}, 50));
|
|
|
|
// pass in the target node, as well as the observer options
|
|
observer.observe(element, { childList: true, subtree: true });
|
|
|
|
$element.data('observer', observer);
|
|
|
|
} catch(e) {}
|
|
});
|
|
};
|
|
|
|
UI.init = function(root) {
|
|
|
|
root = root || document;
|
|
|
|
UI.domObservers.forEach(function(fn){
|
|
fn(root);
|
|
});
|
|
};
|
|
|
|
UI.on('domready.uk.dom', function(){
|
|
|
|
UI.init();
|
|
|
|
if (UI.domready) UI.Utils.checkDisplay();
|
|
});
|
|
|
|
document.addEventListener('DOMContentLoaded', function(){
|
|
|
|
var domReady = function() {
|
|
|
|
UI.$body = UI.$('body');
|
|
|
|
UI.ready(function(context){
|
|
UI.domObserve('[data-uk-observe]');
|
|
});
|
|
|
|
UI.on('changed.uk.dom', function(e) {
|
|
UI.init(e.target);
|
|
UI.Utils.checkDisplay(e.target);
|
|
});
|
|
|
|
UI.trigger('beforeready.uk.dom');
|
|
|
|
UI.component.bootComponents();
|
|
|
|
// custom scroll observer
|
|
requestAnimationFrame((function(){
|
|
|
|
var memory = {dir: {x:0, y:0}, x: window.pageXOffset, y:window.pageYOffset};
|
|
|
|
var fn = function(){
|
|
// reading this (window.page[X|Y]Offset) causes a full page recalc of the layout in Chrome,
|
|
// so we only want to do this once
|
|
var wpxo = window.pageXOffset;
|
|
var wpyo = window.pageYOffset;
|
|
|
|
// Did the scroll position change since the last time we were here?
|
|
if (memory.x != wpxo || memory.y != wpyo) {
|
|
|
|
// Set the direction of the scroll and store the new position
|
|
if (wpxo != memory.x) {memory.dir.x = wpxo > memory.x ? 1:-1; } else { memory.dir.x = 0; }
|
|
if (wpyo != memory.y) {memory.dir.y = wpyo > memory.y ? 1:-1; } else { memory.dir.y = 0; }
|
|
|
|
memory.x = wpxo;
|
|
memory.y = wpyo;
|
|
|
|
// Trigger the scroll event, this could probably be sent using memory.clone() but this is
|
|
// more explicit and easier to see exactly what is being sent in the event.
|
|
UI.$doc.trigger('scrolling.uk.document', [{
|
|
"dir": {"x": memory.dir.x, "y": memory.dir.y}, "x": wpxo, "y": wpyo
|
|
}]);
|
|
}
|
|
|
|
requestAnimationFrame(fn);
|
|
};
|
|
|
|
if (UI.support.touch) {
|
|
UI.$html.on('touchmove touchend MSPointerMove MSPointerUp pointermove pointerup', fn);
|
|
}
|
|
|
|
if (memory.x || memory.y) fn();
|
|
|
|
return fn;
|
|
|
|
})());
|
|
|
|
// run component init functions on dom
|
|
UI.trigger('domready.uk.dom');
|
|
|
|
if (UI.support.touch) {
|
|
|
|
// remove css hover rules for touch devices
|
|
// UI.Utils.removeCssRules(/\.uk-(?!navbar).*:hover/);
|
|
|
|
// viewport unit fix for uk-height-viewport - should be fixed in iOS 8
|
|
if (navigator.userAgent.match(/(iPad|iPhone|iPod)/g)) {
|
|
|
|
UI.$win.on('load orientationchange resize', UI.Utils.debounce((function(){
|
|
|
|
var fn = function() {
|
|
$('.uk-height-viewport').css('height', window.innerHeight);
|
|
return fn;
|
|
};
|
|
|
|
return fn();
|
|
|
|
})(), 100));
|
|
}
|
|
}
|
|
|
|
UI.trigger('afterready.uk.dom');
|
|
|
|
// mark that domready is left behind
|
|
UI.domready = true;
|
|
};
|
|
|
|
if (document.readyState == 'complete' || document.readyState == 'interactive') {
|
|
setTimeout(domReady);
|
|
}
|
|
|
|
return domReady;
|
|
|
|
}());
|
|
|
|
// add touch identifier class
|
|
UI.$html.addClass(UI.support.touch ? "uk-touch" : "uk-notouch");
|
|
|
|
// add uk-hover class on tap to support overlays on touch devices
|
|
if (UI.support.touch) {
|
|
|
|
var hoverset = false,
|
|
exclude,
|
|
hovercls = 'uk-hover',
|
|
selector = '.uk-overlay, .uk-overlay-hover, .uk-overlay-toggle, .uk-animation-hover, .uk-has-hover';
|
|
|
|
UI.$html.on('mouseenter touchstart MSPointerDown pointerdown', selector, function() {
|
|
|
|
if (hoverset) $('.'+hovercls).removeClass(hovercls);
|
|
|
|
hoverset = $(this).addClass(hovercls);
|
|
|
|
}).on('mouseleave touchend MSPointerUp pointerup', function(e) {
|
|
|
|
exclude = $(e.target).parents(selector);
|
|
|
|
if (hoverset) {
|
|
hoverset.not(exclude).removeClass(hovercls);
|
|
}
|
|
});
|
|
}
|
|
|
|
return UI;
|
|
});
|