You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1095 lines
34 KiB
1095 lines
34 KiB
/*! |
|
* # Semantic UI 2.2.9 - Transition |
|
* http://github.com/semantic-org/semantic-ui/ |
|
* |
|
* |
|
* Released under the MIT license |
|
* http://opensource.org/licenses/MIT |
|
* |
|
*/ |
|
|
|
;(function ($, window, document, undefined) { |
|
|
|
"use strict"; |
|
|
|
window = (typeof window != 'undefined' && window.Math == Math) |
|
? window |
|
: (typeof self != 'undefined' && self.Math == Math) |
|
? self |
|
: Function('return this')() |
|
; |
|
|
|
$.fn.transition = function() { |
|
var |
|
$allModules = $(this), |
|
moduleSelector = $allModules.selector || '', |
|
|
|
time = new Date().getTime(), |
|
performance = [], |
|
|
|
moduleArguments = arguments, |
|
query = moduleArguments[0], |
|
queryArguments = [].slice.call(arguments, 1), |
|
methodInvoked = (typeof query === 'string'), |
|
|
|
requestAnimationFrame = window.requestAnimationFrame |
|
|| window.mozRequestAnimationFrame |
|
|| window.webkitRequestAnimationFrame |
|
|| window.msRequestAnimationFrame |
|
|| function(callback) { setTimeout(callback, 0); }, |
|
|
|
returnedValue |
|
; |
|
$allModules |
|
.each(function(index) { |
|
var |
|
$module = $(this), |
|
element = this, |
|
|
|
// set at run time |
|
settings, |
|
instance, |
|
|
|
error, |
|
className, |
|
metadata, |
|
animationEnd, |
|
animationName, |
|
|
|
namespace, |
|
moduleNamespace, |
|
eventNamespace, |
|
module |
|
; |
|
|
|
module = { |
|
|
|
initialize: function() { |
|
|
|
// get full settings |
|
settings = module.get.settings.apply(element, moduleArguments); |
|
|
|
// shorthand |
|
className = settings.className; |
|
error = settings.error; |
|
metadata = settings.metadata; |
|
|
|
// define namespace |
|
eventNamespace = '.' + settings.namespace; |
|
moduleNamespace = 'module-' + settings.namespace; |
|
instance = $module.data(moduleNamespace) || module; |
|
|
|
// get vendor specific events |
|
animationEnd = module.get.animationEndEvent(); |
|
|
|
if(methodInvoked) { |
|
methodInvoked = module.invoke(query); |
|
} |
|
|
|
// method not invoked, lets run an animation |
|
if(methodInvoked === false) { |
|
module.verbose('Converted arguments into settings object', settings); |
|
if(settings.interval) { |
|
module.delay(settings.animate); |
|
} |
|
else { |
|
module.animate(); |
|
} |
|
module.instantiate(); |
|
} |
|
}, |
|
|
|
instantiate: function() { |
|
module.verbose('Storing instance of module', module); |
|
instance = module; |
|
$module |
|
.data(moduleNamespace, instance) |
|
; |
|
}, |
|
|
|
destroy: function() { |
|
module.verbose('Destroying previous module for', element); |
|
$module |
|
.removeData(moduleNamespace) |
|
; |
|
}, |
|
|
|
refresh: function() { |
|
module.verbose('Refreshing display type on next animation'); |
|
delete module.displayType; |
|
}, |
|
|
|
forceRepaint: function() { |
|
module.verbose('Forcing element repaint'); |
|
var |
|
$parentElement = $module.parent(), |
|
$nextElement = $module.next() |
|
; |
|
if($nextElement.length === 0) { |
|
$module.detach().appendTo($parentElement); |
|
} |
|
else { |
|
$module.detach().insertBefore($nextElement); |
|
} |
|
}, |
|
|
|
repaint: function() { |
|
module.verbose('Repainting element'); |
|
var |
|
fakeAssignment = element.offsetWidth |
|
; |
|
}, |
|
|
|
delay: function(interval) { |
|
var |
|
direction = module.get.animationDirection(), |
|
shouldReverse, |
|
delay |
|
; |
|
if(!direction) { |
|
direction = module.can.transition() |
|
? module.get.direction() |
|
: 'static' |
|
; |
|
} |
|
interval = (interval !== undefined) |
|
? interval |
|
: settings.interval |
|
; |
|
shouldReverse = (settings.reverse == 'auto' && direction == className.outward); |
|
delay = (shouldReverse || settings.reverse == true) |
|
? ($allModules.length - index) * settings.interval |
|
: index * settings.interval |
|
; |
|
module.debug('Delaying animation by', delay); |
|
setTimeout(module.animate, delay); |
|
}, |
|
|
|
animate: function(overrideSettings) { |
|
settings = overrideSettings || settings; |
|
if(!module.is.supported()) { |
|
module.error(error.support); |
|
return false; |
|
} |
|
module.debug('Preparing animation', settings.animation); |
|
if(module.is.animating()) { |
|
if(settings.queue) { |
|
if(!settings.allowRepeats && module.has.direction() && module.is.occurring() && module.queuing !== true) { |
|
module.debug('Animation is currently occurring, preventing queueing same animation', settings.animation); |
|
} |
|
else { |
|
module.queue(settings.animation); |
|
} |
|
return false; |
|
} |
|
else if(!settings.allowRepeats && module.is.occurring()) { |
|
module.debug('Animation is already occurring, will not execute repeated animation', settings.animation); |
|
return false; |
|
} |
|
else { |
|
module.debug('New animation started, completing previous early', settings.animation); |
|
instance.complete(); |
|
} |
|
} |
|
if( module.can.animate() ) { |
|
module.set.animating(settings.animation); |
|
} |
|
else { |
|
module.error(error.noAnimation, settings.animation, element); |
|
} |
|
}, |
|
|
|
reset: function() { |
|
module.debug('Resetting animation to beginning conditions'); |
|
module.remove.animationCallbacks(); |
|
module.restore.conditions(); |
|
module.remove.animating(); |
|
}, |
|
|
|
queue: function(animation) { |
|
module.debug('Queueing animation of', animation); |
|
module.queuing = true; |
|
$module |
|
.one(animationEnd + '.queue' + eventNamespace, function() { |
|
module.queuing = false; |
|
module.repaint(); |
|
module.animate.apply(this, settings); |
|
}) |
|
; |
|
}, |
|
|
|
complete: function (event) { |
|
module.debug('Animation complete', settings.animation); |
|
module.remove.completeCallback(); |
|
module.remove.failSafe(); |
|
if(!module.is.looping()) { |
|
if( module.is.outward() ) { |
|
module.verbose('Animation is outward, hiding element'); |
|
module.restore.conditions(); |
|
module.hide(); |
|
} |
|
else if( module.is.inward() ) { |
|
module.verbose('Animation is outward, showing element'); |
|
module.restore.conditions(); |
|
module.show(); |
|
} |
|
else { |
|
module.verbose('Static animation completed'); |
|
module.restore.conditions(); |
|
settings.onComplete.call(element); |
|
} |
|
} |
|
}, |
|
|
|
force: { |
|
visible: function() { |
|
var |
|
style = $module.attr('style'), |
|
userStyle = module.get.userStyle(), |
|
displayType = module.get.displayType(), |
|
overrideStyle = userStyle + 'display: ' + displayType + ' !important;', |
|
currentDisplay = $module.css('display'), |
|
emptyStyle = (style === undefined || style === '') |
|
; |
|
if(currentDisplay !== displayType) { |
|
module.verbose('Overriding default display to show element', displayType); |
|
$module |
|
.attr('style', overrideStyle) |
|
; |
|
} |
|
else if(emptyStyle) { |
|
$module.removeAttr('style'); |
|
} |
|
}, |
|
hidden: function() { |
|
var |
|
style = $module.attr('style'), |
|
currentDisplay = $module.css('display'), |
|
emptyStyle = (style === undefined || style === '') |
|
; |
|
if(currentDisplay !== 'none' && !module.is.hidden()) { |
|
module.verbose('Overriding default display to hide element'); |
|
$module |
|
.css('display', 'none') |
|
; |
|
} |
|
else if(emptyStyle) { |
|
$module |
|
.removeAttr('style') |
|
; |
|
} |
|
} |
|
}, |
|
|
|
has: { |
|
direction: function(animation) { |
|
var |
|
hasDirection = false |
|
; |
|
animation = animation || settings.animation; |
|
if(typeof animation === 'string') { |
|
animation = animation.split(' '); |
|
$.each(animation, function(index, word){ |
|
if(word === className.inward || word === className.outward) { |
|
hasDirection = true; |
|
} |
|
}); |
|
} |
|
return hasDirection; |
|
}, |
|
inlineDisplay: function() { |
|
var |
|
style = $module.attr('style') || '' |
|
; |
|
return $.isArray(style.match(/display.*?;/, '')); |
|
} |
|
}, |
|
|
|
set: { |
|
animating: function(animation) { |
|
var |
|
animationClass, |
|
direction |
|
; |
|
// remove previous callbacks |
|
module.remove.completeCallback(); |
|
|
|
// determine exact animation |
|
animation = animation || settings.animation; |
|
animationClass = module.get.animationClass(animation); |
|
|
|
// save animation class in cache to restore class names |
|
module.save.animation(animationClass); |
|
|
|
// override display if necessary so animation appears visibly |
|
module.force.visible(); |
|
|
|
module.remove.hidden(); |
|
module.remove.direction(); |
|
|
|
module.start.animation(animationClass); |
|
|
|
}, |
|
duration: function(animationName, duration) { |
|
duration = duration || settings.duration; |
|
duration = (typeof duration == 'number') |
|
? duration + 'ms' |
|
: duration |
|
; |
|
if(duration || duration === 0) { |
|
module.verbose('Setting animation duration', duration); |
|
$module |
|
.css({ |
|
'animation-duration': duration |
|
}) |
|
; |
|
} |
|
}, |
|
direction: function(direction) { |
|
direction = direction || module.get.direction(); |
|
if(direction == className.inward) { |
|
module.set.inward(); |
|
} |
|
else { |
|
module.set.outward(); |
|
} |
|
}, |
|
looping: function() { |
|
module.debug('Transition set to loop'); |
|
$module |
|
.addClass(className.looping) |
|
; |
|
}, |
|
hidden: function() { |
|
$module |
|
.addClass(className.transition) |
|
.addClass(className.hidden) |
|
; |
|
}, |
|
inward: function() { |
|
module.debug('Setting direction to inward'); |
|
$module |
|
.removeClass(className.outward) |
|
.addClass(className.inward) |
|
; |
|
}, |
|
outward: function() { |
|
module.debug('Setting direction to outward'); |
|
$module |
|
.removeClass(className.inward) |
|
.addClass(className.outward) |
|
; |
|
}, |
|
visible: function() { |
|
$module |
|
.addClass(className.transition) |
|
.addClass(className.visible) |
|
; |
|
} |
|
}, |
|
|
|
start: { |
|
animation: function(animationClass) { |
|
animationClass = animationClass || module.get.animationClass(); |
|
module.debug('Starting tween', animationClass); |
|
$module |
|
.addClass(animationClass) |
|
.one(animationEnd + '.complete' + eventNamespace, module.complete) |
|
; |
|
if(settings.useFailSafe) { |
|
module.add.failSafe(); |
|
} |
|
module.set.duration(settings.duration); |
|
settings.onStart.call(element); |
|
} |
|
}, |
|
|
|
save: { |
|
animation: function(animation) { |
|
if(!module.cache) { |
|
module.cache = {}; |
|
} |
|
module.cache.animation = animation; |
|
}, |
|
displayType: function(displayType) { |
|
if(displayType !== 'none') { |
|
$module.data(metadata.displayType, displayType); |
|
} |
|
}, |
|
transitionExists: function(animation, exists) { |
|
$.fn.transition.exists[animation] = exists; |
|
module.verbose('Saving existence of transition', animation, exists); |
|
} |
|
}, |
|
|
|
restore: { |
|
conditions: function() { |
|
var |
|
animation = module.get.currentAnimation() |
|
; |
|
if(animation) { |
|
$module |
|
.removeClass(animation) |
|
; |
|
module.verbose('Removing animation class', module.cache); |
|
} |
|
module.remove.duration(); |
|
} |
|
}, |
|
|
|
add: { |
|
failSafe: function() { |
|
var |
|
duration = module.get.duration() |
|
; |
|
module.timer = setTimeout(function() { |
|
$module.triggerHandler(animationEnd); |
|
}, duration + settings.failSafeDelay); |
|
module.verbose('Adding fail safe timer', module.timer); |
|
} |
|
}, |
|
|
|
remove: { |
|
animating: function() { |
|
$module.removeClass(className.animating); |
|
}, |
|
animationCallbacks: function() { |
|
module.remove.queueCallback(); |
|
module.remove.completeCallback(); |
|
}, |
|
queueCallback: function() { |
|
$module.off('.queue' + eventNamespace); |
|
}, |
|
completeCallback: function() { |
|
$module.off('.complete' + eventNamespace); |
|
}, |
|
display: function() { |
|
$module.css('display', ''); |
|
}, |
|
direction: function() { |
|
$module |
|
.removeClass(className.inward) |
|
.removeClass(className.outward) |
|
; |
|
}, |
|
duration: function() { |
|
$module |
|
.css('animation-duration', '') |
|
; |
|
}, |
|
failSafe: function() { |
|
module.verbose('Removing fail safe timer', module.timer); |
|
if(module.timer) { |
|
clearTimeout(module.timer); |
|
} |
|
}, |
|
hidden: function() { |
|
$module.removeClass(className.hidden); |
|
}, |
|
visible: function() { |
|
$module.removeClass(className.visible); |
|
}, |
|
looping: function() { |
|
module.debug('Transitions are no longer looping'); |
|
if( module.is.looping() ) { |
|
module.reset(); |
|
$module |
|
.removeClass(className.looping) |
|
; |
|
} |
|
}, |
|
transition: function() { |
|
$module |
|
.removeClass(className.visible) |
|
.removeClass(className.hidden) |
|
; |
|
} |
|
}, |
|
get: { |
|
settings: function(animation, duration, onComplete) { |
|
// single settings object |
|
if(typeof animation == 'object') { |
|
return $.extend(true, {}, $.fn.transition.settings, animation); |
|
} |
|
// all arguments provided |
|
else if(typeof onComplete == 'function') { |
|
return $.extend({}, $.fn.transition.settings, { |
|
animation : animation, |
|
onComplete : onComplete, |
|
duration : duration |
|
}); |
|
} |
|
// only duration provided |
|
else if(typeof duration == 'string' || typeof duration == 'number') { |
|
return $.extend({}, $.fn.transition.settings, { |
|
animation : animation, |
|
duration : duration |
|
}); |
|
} |
|
// duration is actually settings object |
|
else if(typeof duration == 'object') { |
|
return $.extend({}, $.fn.transition.settings, duration, { |
|
animation : animation |
|
}); |
|
} |
|
// duration is actually callback |
|
else if(typeof duration == 'function') { |
|
return $.extend({}, $.fn.transition.settings, { |
|
animation : animation, |
|
onComplete : duration |
|
}); |
|
} |
|
// only animation provided |
|
else { |
|
return $.extend({}, $.fn.transition.settings, { |
|
animation : animation |
|
}); |
|
} |
|
}, |
|
animationClass: function(animation) { |
|
var |
|
animationClass = animation || settings.animation, |
|
directionClass = (module.can.transition() && !module.has.direction()) |
|
? module.get.direction() + ' ' |
|
: '' |
|
; |
|
return className.animating + ' ' |
|
+ className.transition + ' ' |
|
+ directionClass |
|
+ animationClass |
|
; |
|
}, |
|
currentAnimation: function() { |
|
return (module.cache && module.cache.animation !== undefined) |
|
? module.cache.animation |
|
: false |
|
; |
|
}, |
|
currentDirection: function() { |
|
return module.is.inward() |
|
? className.inward |
|
: className.outward |
|
; |
|
}, |
|
direction: function() { |
|
return module.is.hidden() || !module.is.visible() |
|
? className.inward |
|
: className.outward |
|
; |
|
}, |
|
animationDirection: function(animation) { |
|
var |
|
direction |
|
; |
|
animation = animation || settings.animation; |
|
if(typeof animation === 'string') { |
|
animation = animation.split(' '); |
|
// search animation name for out/in class |
|
$.each(animation, function(index, word){ |
|
if(word === className.inward) { |
|
direction = className.inward; |
|
} |
|
else if(word === className.outward) { |
|
direction = className.outward; |
|
} |
|
}); |
|
} |
|
// return found direction |
|
if(direction) { |
|
return direction; |
|
} |
|
return false; |
|
}, |
|
duration: function(duration) { |
|
duration = duration || settings.duration; |
|
if(duration === false) { |
|
duration = $module.css('animation-duration') || 0; |
|
} |
|
return (typeof duration === 'string') |
|
? (duration.indexOf('ms') > -1) |
|
? parseFloat(duration) |
|
: parseFloat(duration) * 1000 |
|
: duration |
|
; |
|
}, |
|
displayType: function(shouldDetermine) { |
|
shouldDetermine = (shouldDetermine !== undefined) |
|
? shouldDetermine |
|
: true |
|
; |
|
if(settings.displayType) { |
|
return settings.displayType; |
|
} |
|
if(shouldDetermine && $module.data(metadata.displayType) === undefined) { |
|
// create fake element to determine display state |
|
module.can.transition(true); |
|
} |
|
return $module.data(metadata.displayType); |
|
}, |
|
userStyle: function(style) { |
|
style = style || $module.attr('style') || ''; |
|
return style.replace(/display.*?;/, ''); |
|
}, |
|
transitionExists: function(animation) { |
|
return $.fn.transition.exists[animation]; |
|
}, |
|
animationStartEvent: function() { |
|
var |
|
element = document.createElement('div'), |
|
animations = { |
|
'animation' :'animationstart', |
|
'OAnimation' :'oAnimationStart', |
|
'MozAnimation' :'mozAnimationStart', |
|
'WebkitAnimation' :'webkitAnimationStart' |
|
}, |
|
animation |
|
; |
|
for(animation in animations){ |
|
if( element.style[animation] !== undefined ){ |
|
return animations[animation]; |
|
} |
|
} |
|
return false; |
|
}, |
|
animationEndEvent: function() { |
|
var |
|
element = document.createElement('div'), |
|
animations = { |
|
'animation' :'animationend', |
|
'OAnimation' :'oAnimationEnd', |
|
'MozAnimation' :'mozAnimationEnd', |
|
'WebkitAnimation' :'webkitAnimationEnd' |
|
}, |
|
animation |
|
; |
|
for(animation in animations){ |
|
if( element.style[animation] !== undefined ){ |
|
return animations[animation]; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
}, |
|
|
|
can: { |
|
transition: function(forced) { |
|
var |
|
animation = settings.animation, |
|
transitionExists = module.get.transitionExists(animation), |
|
displayType = module.get.displayType(false), |
|
elementClass, |
|
tagName, |
|
$clone, |
|
currentAnimation, |
|
inAnimation, |
|
directionExists |
|
; |
|
if( transitionExists === undefined || forced) { |
|
module.verbose('Determining whether animation exists'); |
|
elementClass = $module.attr('class'); |
|
tagName = $module.prop('tagName'); |
|
|
|
$clone = $('<' + tagName + ' />').addClass( elementClass ).insertAfter($module); |
|
currentAnimation = $clone |
|
.addClass(animation) |
|
.removeClass(className.inward) |
|
.removeClass(className.outward) |
|
.addClass(className.animating) |
|
.addClass(className.transition) |
|
.css('animationName') |
|
; |
|
inAnimation = $clone |
|
.addClass(className.inward) |
|
.css('animationName') |
|
; |
|
if(!displayType) { |
|
displayType = $clone |
|
.attr('class', elementClass) |
|
.removeAttr('style') |
|
.removeClass(className.hidden) |
|
.removeClass(className.visible) |
|
.show() |
|
.css('display') |
|
; |
|
module.verbose('Determining final display state', displayType); |
|
module.save.displayType(displayType); |
|
} |
|
|
|
$clone.remove(); |
|
if(currentAnimation != inAnimation) { |
|
module.debug('Direction exists for animation', animation); |
|
directionExists = true; |
|
} |
|
else if(currentAnimation == 'none' || !currentAnimation) { |
|
module.debug('No animation defined in css', animation); |
|
return; |
|
} |
|
else { |
|
module.debug('Static animation found', animation, displayType); |
|
directionExists = false; |
|
} |
|
module.save.transitionExists(animation, directionExists); |
|
} |
|
return (transitionExists !== undefined) |
|
? transitionExists |
|
: directionExists |
|
; |
|
}, |
|
animate: function() { |
|
// can transition does not return a value if animation does not exist |
|
return (module.can.transition() !== undefined); |
|
} |
|
}, |
|
|
|
is: { |
|
animating: function() { |
|
return $module.hasClass(className.animating); |
|
}, |
|
inward: function() { |
|
return $module.hasClass(className.inward); |
|
}, |
|
outward: function() { |
|
return $module.hasClass(className.outward); |
|
}, |
|
looping: function() { |
|
return $module.hasClass(className.looping); |
|
}, |
|
occurring: function(animation) { |
|
animation = animation || settings.animation; |
|
animation = '.' + animation.replace(' ', '.'); |
|
return ( $module.filter(animation).length > 0 ); |
|
}, |
|
visible: function() { |
|
return $module.is(':visible'); |
|
}, |
|
hidden: function() { |
|
return $module.css('visibility') === 'hidden'; |
|
}, |
|
supported: function() { |
|
return(animationEnd !== false); |
|
} |
|
}, |
|
|
|
hide: function() { |
|
module.verbose('Hiding element'); |
|
if( module.is.animating() ) { |
|
module.reset(); |
|
} |
|
element.blur(); // IE will trigger focus change if element is not blurred before hiding |
|
module.remove.display(); |
|
module.remove.visible(); |
|
module.set.hidden(); |
|
module.force.hidden(); |
|
settings.onHide.call(element); |
|
settings.onComplete.call(element); |
|
// module.repaint(); |
|
}, |
|
|
|
show: function(display) { |
|
module.verbose('Showing element', display); |
|
module.remove.hidden(); |
|
module.set.visible(); |
|
module.force.visible(); |
|
settings.onShow.call(element); |
|
settings.onComplete.call(element); |
|
// module.repaint(); |
|
}, |
|
|
|
toggle: function() { |
|
if( module.is.visible() ) { |
|
module.hide(); |
|
} |
|
else { |
|
module.show(); |
|
} |
|
}, |
|
|
|
stop: function() { |
|
module.debug('Stopping current animation'); |
|
$module.triggerHandler(animationEnd); |
|
}, |
|
|
|
stopAll: function() { |
|
module.debug('Stopping all animation'); |
|
module.remove.queueCallback(); |
|
$module.triggerHandler(animationEnd); |
|
}, |
|
|
|
clear: { |
|
queue: function() { |
|
module.debug('Clearing animation queue'); |
|
module.remove.queueCallback(); |
|
} |
|
}, |
|
|
|
enable: function() { |
|
module.verbose('Starting animation'); |
|
$module.removeClass(className.disabled); |
|
}, |
|
|
|
disable: function() { |
|
module.debug('Stopping animation'); |
|
$module.addClass(className.disabled); |
|
}, |
|
|
|
setting: function(name, value) { |
|
module.debug('Changing setting', name, value); |
|
if( $.isPlainObject(name) ) { |
|
$.extend(true, settings, name); |
|
} |
|
else if(value !== undefined) { |
|
if($.isPlainObject(settings[name])) { |
|
$.extend(true, settings[name], value); |
|
} |
|
else { |
|
settings[name] = value; |
|
} |
|
} |
|
else { |
|
return settings[name]; |
|
} |
|
}, |
|
internal: function(name, value) { |
|
if( $.isPlainObject(name) ) { |
|
$.extend(true, module, name); |
|
} |
|
else if(value !== undefined) { |
|
module[name] = value; |
|
} |
|
else { |
|
return module[name]; |
|
} |
|
}, |
|
debug: function() { |
|
if(!settings.silent && settings.debug) { |
|
if(settings.performance) { |
|
module.performance.log(arguments); |
|
} |
|
else { |
|
module.debug = Function.prototype.bind.call(console.info, console, settings.name + ':'); |
|
module.debug.apply(console, arguments); |
|
} |
|
} |
|
}, |
|
verbose: function() { |
|
if(!settings.silent && settings.verbose && settings.debug) { |
|
if(settings.performance) { |
|
module.performance.log(arguments); |
|
} |
|
else { |
|
module.verbose = Function.prototype.bind.call(console.info, console, settings.name + ':'); |
|
module.verbose.apply(console, arguments); |
|
} |
|
} |
|
}, |
|
error: function() { |
|
if(!settings.silent) { |
|
module.error = Function.prototype.bind.call(console.error, console, settings.name + ':'); |
|
module.error.apply(console, arguments); |
|
} |
|
}, |
|
performance: { |
|
log: function(message) { |
|
var |
|
currentTime, |
|
executionTime, |
|
previousTime |
|
; |
|
if(settings.performance) { |
|
currentTime = new Date().getTime(); |
|
previousTime = time || currentTime; |
|
executionTime = currentTime - previousTime; |
|
time = currentTime; |
|
performance.push({ |
|
'Name' : message[0], |
|
'Arguments' : [].slice.call(message, 1) || '', |
|
'Element' : element, |
|
'Execution Time' : executionTime |
|
}); |
|
} |
|
clearTimeout(module.performance.timer); |
|
module.performance.timer = setTimeout(module.performance.display, 500); |
|
}, |
|
display: function() { |
|
var |
|
title = settings.name + ':', |
|
totalTime = 0 |
|
; |
|
time = false; |
|
clearTimeout(module.performance.timer); |
|
$.each(performance, function(index, data) { |
|
totalTime += data['Execution Time']; |
|
}); |
|
title += ' ' + totalTime + 'ms'; |
|
if(moduleSelector) { |
|
title += ' \'' + moduleSelector + '\''; |
|
} |
|
if($allModules.length > 1) { |
|
title += ' ' + '(' + $allModules.length + ')'; |
|
} |
|
if( (console.group !== undefined || console.table !== undefined) && performance.length > 0) { |
|
console.groupCollapsed(title); |
|
if(console.table) { |
|
console.table(performance); |
|
} |
|
else { |
|
$.each(performance, function(index, data) { |
|
console.log(data['Name'] + ': ' + data['Execution Time']+'ms'); |
|
}); |
|
} |
|
console.groupEnd(); |
|
} |
|
performance = []; |
|
} |
|
}, |
|
// modified for transition to return invoke success |
|
invoke: function(query, passedArguments, context) { |
|
var |
|
object = instance, |
|
maxDepth, |
|
found, |
|
response |
|
; |
|
passedArguments = passedArguments || queryArguments; |
|
context = element || context; |
|
if(typeof query == 'string' && object !== undefined) { |
|
query = query.split(/[\. ]/); |
|
maxDepth = query.length - 1; |
|
$.each(query, function(depth, value) { |
|
var camelCaseValue = (depth != maxDepth) |
|
? value + query[depth + 1].charAt(0).toUpperCase() + query[depth + 1].slice(1) |
|
: query |
|
; |
|
if( $.isPlainObject( object[camelCaseValue] ) && (depth != maxDepth) ) { |
|
object = object[camelCaseValue]; |
|
} |
|
else if( object[camelCaseValue] !== undefined ) { |
|
found = object[camelCaseValue]; |
|
return false; |
|
} |
|
else if( $.isPlainObject( object[value] ) && (depth != maxDepth) ) { |
|
object = object[value]; |
|
} |
|
else if( object[value] !== undefined ) { |
|
found = object[value]; |
|
return false; |
|
} |
|
else { |
|
return false; |
|
} |
|
}); |
|
} |
|
if ( $.isFunction( found ) ) { |
|
response = found.apply(context, passedArguments); |
|
} |
|
else if(found !== undefined) { |
|
response = found; |
|
} |
|
|
|
if($.isArray(returnedValue)) { |
|
returnedValue.push(response); |
|
} |
|
else if(returnedValue !== undefined) { |
|
returnedValue = [returnedValue, response]; |
|
} |
|
else if(response !== undefined) { |
|
returnedValue = response; |
|
} |
|
return (found !== undefined) |
|
? found |
|
: false |
|
; |
|
} |
|
}; |
|
module.initialize(); |
|
}) |
|
; |
|
return (returnedValue !== undefined) |
|
? returnedValue |
|
: this |
|
; |
|
}; |
|
|
|
// Records if CSS transition is available |
|
$.fn.transition.exists = {}; |
|
|
|
$.fn.transition.settings = { |
|
|
|
// module info |
|
name : 'Transition', |
|
|
|
// hide all output from this component regardless of other settings |
|
silent : false, |
|
|
|
// debug content outputted to console |
|
debug : false, |
|
|
|
// verbose debug output |
|
verbose : false, |
|
|
|
// performance data output |
|
performance : true, |
|
|
|
// event namespace |
|
namespace : 'transition', |
|
|
|
// delay between animations in group |
|
interval : 0, |
|
|
|
// whether group animations should be reversed |
|
reverse : 'auto', |
|
|
|
// animation callback event |
|
onStart : function() {}, |
|
onComplete : function() {}, |
|
onShow : function() {}, |
|
onHide : function() {}, |
|
|
|
// whether timeout should be used to ensure callback fires in cases animationend does not |
|
useFailSafe : true, |
|
|
|
// delay in ms for fail safe |
|
failSafeDelay : 100, |
|
|
|
// whether EXACT animation can occur twice in a row |
|
allowRepeats : false, |
|
|
|
// Override final display type on visible |
|
displayType : false, |
|
|
|
// animation duration |
|
animation : 'fade', |
|
duration : false, |
|
|
|
// new animations will occur after previous ones |
|
queue : true, |
|
|
|
metadata : { |
|
displayType: 'display' |
|
}, |
|
|
|
className : { |
|
animating : 'animating', |
|
disabled : 'disabled', |
|
hidden : 'hidden', |
|
inward : 'in', |
|
loading : 'loading', |
|
looping : 'looping', |
|
outward : 'out', |
|
transition : 'transition', |
|
visible : 'visible' |
|
}, |
|
|
|
// possible errors |
|
error: { |
|
noAnimation : 'Element is no longer attached to DOM. Unable to animate. Use silent setting to surpress this warning in production.', |
|
repeated : 'That animation is already occurring, cancelling repeated animation', |
|
method : 'The method you called is not defined', |
|
support : 'This browser does not support CSS animations' |
|
} |
|
|
|
}; |
|
|
|
|
|
})( jQuery, window, document );
|
|
|