jquery-qtip2-rails 0.4.0 → 0.5.0

data/vendor/assets/jquery-qtip/jquery-qtip/src/ie6/ie6.js

@@ -1,8 +1,10 @@
+var IE6;
+
 /* 
  * BGIFrame adaption (http://plugins.jquery.com/project/bgiframe)
  * Special thanks to Brandon Aaron
  */
-function IE6(api)
+function Ie6(api)
 {
 	var self = this,
 		elems = api.elements,
@@ -138,19 +140,15 @@ function IE6(api)
 	self.init();
 }
 
-PLUGINS.ie6 = function(api)
+IE6 = PLUGINS.ie6 = function(api)
 {
-	var browser = $.browser,
-		self = api.plugins.ie6;
+	var self = api.plugins.ie6;
 	
 	// Proceed only if the browser is IE6
-	if(!(browser.msie && (''+browser.version).charAt(0) === '6')) {
-		return FALSE;
-	}
+	if(PLUGINS.ie !== 6) { return FALSE; }
 
-	return 'object' === typeof self ? self : (api.plugins.ie6 = new IE6(api));
+	return 'object' === typeof self ? self : (api.plugins.ie6 = new Ie6(api));
 };
 
-// Plugin needs to be initialized on render
-PLUGINS.ie6.initialize = 'render';
+IE6.initialize = 'render';
 

data/vendor/assets/jquery-qtip/jquery-qtip/src/intro.js

@@ -23,22 +23,30 @@
 		FALSE = false,
 		NULL = null,
 
-		// Side names and other stuff
+		// Common variables
 		X = 'x', Y = 'y',
 		WIDTH = 'width',
 		HEIGHT = 'height',
+
+		// Positioning sides
 		TOP = 'top',
 		LEFT = 'left',
 		BOTTOM = 'bottom',
 		RIGHT = 'right',
 		CENTER = 'center',
+
+		// Position adjustment types
 		FLIP = 'flip',
 		FLIPINVERT = 'flipinvert',
 		SHIFT = 'shift',
 
+		// Used by image load detection (see core.js)
+		BLANKIMG = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==', 
+
 		// Shortcut vars
 		QTIP, PLUGINS, MOUSE,
 		NAMESPACE = 'qtip',
+		HASATTR = 'data-hasqtip',
 		usedIDs = {},
 		widget = ['ui-widget', 'ui-tooltip'],
 		selector = 'div.qtip.'+NAMESPACE,

data/vendor/assets/jquery-qtip/jquery-qtip/src/modal/modal.js

@@ -1,37 +1,43 @@
-function Modal(api)
+var MODAL, OVERLAY,
+	MODALATTR = 'is-modal-qtip',
+	MODALSELECTOR = selector + '['+MODALATTR+']',
+	MODALNS = '.qtipmodal';
+
+OVERLAY = function()
 {
 	var self = this,
-		options = api.options.show.modal,
-		elems = api.elements,
-		tooltip = elems.tooltip,
-		overlaySelector = '#qtip-overlay',
-		globalNamespace = '.qtipmodal',
-		namespace = globalNamespace + api.id,
-		attr = 'is-modal-qtip',
-		docBody = $(document.body),
-		focusableSelector = PLUGINS.modal.focusable.join(','),
-		focusableElems = {}, overlay;
-
-	// Setup option set checks
-	api.checks.modal = {
-		'^show.modal.(on|blur)$': function() {
-			// Initialise
-			self.init();
-			
-			// Show the modal if not visible already and tooltip is visible
-			elems.overlay.toggle( tooltip.is(':visible') );
-		},
-		'^content.text$': function() {
-			updateFocusable();
+		focusableElems = {},
+		current, onLast,
+		prevState, elem;
+
+	// Modified code from jQuery UI 1.10.0 source
+	// http://code.jquery.com/ui/1.10.0/jquery-ui.js
+	function focusable(element) {
+		// Use the defined focusable checker when possible
+		if($.expr[':'].focusable) { return $.expr[':'].focusable; }
+
+		var isTabIndexNotNaN = !isNaN($.attr(element, 'tabindex')),
+			nodeName = element.nodeName.toLowerCase(),
+			map, mapName, img;
+
+		if('area' === nodeName) {
+			map = element.parentNode;
+			mapName = map.name;
+			if(!element.href || !mapName || map.nodeName.toLowerCase() !== 'map') {
+				return false;
+			}
+			img = $('img[usemap=#' + mapName + ']')[0];
+			return !!img && img.is(':visible');
 		}
-	};
-
-	function updateFocusable() {
-		focusableElems = $(focusableSelector, tooltip).not('[disabled]').map(function() {
-			return typeof this.focus === 'function' ? this : null;
-		});
+		return (/input|select|textarea|button|object/.test( nodeName ) ?
+				!element.disabled :
+				'a' === nodeName ? 
+					element.href || isTabIndexNotNaN : 
+					isTabIndexNotNaN
+			);
 	}
 
+	// Focus inputs using cached focusable elements (see update())
 	function focusInputs(blurElems) {
 		// Blurring body element in IE causes window.open windows to unfocus!
 		if(focusableElems.length < 1 && blurElems.length) { blurElems.not('body').blur(); }
@@ -40,9 +46,13 @@ function Modal(api)
 		else { focusableElems.first().focus(); }
 	}
 
+	// Steal focus from elements outside tooltip
 	function stealFocus(event) {
+		if(!elem.is(':visible')) { return; }
+
 		var target = $(event.target),
-			container = target.closest('.qtip'),
+			tooltip = current.elements.tooltip,
+			container = target.closest(selector),
 			targetOnTop;
 
 		// Determine if input container target is above this
@@ -52,31 +62,184 @@ function Modal(api)
 		// If we're showing a modal, but focus has landed on an input below
 		// this modal, divert focus to the first visible input in this modal
 		// or if we can't find one... the tooltip itself
-		if(!targetOnTop && ($(event.target).closest(selector)[0] !== tooltip[0])) {
+		if(!targetOnTop && target.closest(selector)[0] !== tooltip[0]) {
 			focusInputs(target);
 		}
+
+		// Detect when we leave the last focusable element...
+		onLast = event.target === focusableElems[focusableElems.length - 1];
 	}
 
+	$.extend(self, {
+		init: function()
+		{
+			// Create document overlay
+			elem = self.elem = $('<div />', {
+				id: 'qtip-overlay',
+				html: '<div></div>',
+				mousedown: function() { return FALSE; }
+			})
+			.hide();
+
+			// Update position on window resize or scroll
+			function resize() {
+				var win = $(this);
+				elem.css({
+					height: win.height(),
+					width: win.width()
+				});
+			}
+			$(window).bind('resize'+MODALNS, resize);
+			resize(); // Fire it initially too
+
+			// Make sure we can't focus anything outside the tooltip
+			$(document.body).bind('focusin'+MODALNS, stealFocus);
+
+			// Apply keyboard "Escape key" close handler
+			$(document).bind('keydown'+MODALNS, function(event) {
+				if(current && current.options.show.modal.escape && event.keyCode === 27) {
+					current.hide(event);
+				}
+			});
+
+			// Apply click handler for blur option
+			elem.bind('click'+MODALNS, function(event) {
+				if(current && current.options.show.modal.blur) {
+					current.hide(event);
+				}
+			});
+
+			return self;
+		},
+
+		update: function(api) {
+			// Update current API reference
+			current = api;
+
+			// Update focusable elements if enabled
+			if(api.options.show.modal.stealfocus !== FALSE) {
+				focusableElems = api.elements.tooltip.find('*').filter(function() {
+					return focusable(this);
+				});
+			}
+			else { focusableElems = []; }
+		},
+
+		toggle: function(api, state, duration)
+		{
+			var docBody = $(document.body),
+				tooltip = api.elements.tooltip,
+				options = api.options.show.modal,
+				effect = options.effect,
+				type = state ? 'show': 'hide',
+				visible = elem.is(':visible'),
+				modals = $(MODALSELECTOR).filter(':visible:not(:animated)').not(tooltip),
+				zindex;
+
+			// Set active tooltip API reference
+			self.update(api);
+
+			// If the modal can steal the focus...
+			// Blur the current item and focus anything in the modal we an
+			if(state && options.stealfocus !== FALSE) {
+				focusInputs( $(':focus') );
+			}
+
+			// Toggle backdrop cursor style on show
+			elem.toggleClass('blurs', options.blur);
+
+			// Set position and append to body on show
+			if(state) {
+				elem.css({ left: 0, top: 0 })
+					.appendTo(document.body);
+			}
+
+			// Prevent modal from conflicting with show.solo, and don't hide backdrop is other modals are visible
+			if((elem.is(':animated') && visible === state && prevState !== FALSE) || (!state && modals.length)) {
+				return self;
+			}
+
+			// Stop all animations
+			elem.stop(TRUE, FALSE);
+
+			// Use custom function if provided
+			if($.isFunction(effect)) {
+				effect.call(elem, state);
+			}
+
+			// If no effect type is supplied, use a simple toggle
+			else if(effect === FALSE) {
+				elem[ type ]();
+			}
+
+			// Use basic fade function
+			else {
+				elem.fadeTo( parseInt(duration, 10) || 90, state ? 1 : 0, function() {
+					if(!state) { elem.hide(); }
+				});
+			}
+
+			// Reset position and detach from body on hide
+			if(!state) {
+				elem.queue(function(next) {
+					elem.css({ left: '', top: '' });
+					if(!modals.length) { elem.detach(); }
+					next();
+				});
+			}
+
+			// Cache the state
+			prevState = state;
+
+			// If the tooltip is destroyed, set referenceto null
+			if(current.destroyed) { current = NULL; }
+
+			return self;
+		}
+	});	
+
+	self.init();
+};
+OVERLAY = new OVERLAY();
+
+function Modal(api)
+{
+	var self = this,
+		options = api.options.show.modal,
+		elems = api.elements,
+		tooltip = elems.tooltip,
+		namespace = MODALNS + api.id,
+		overlay;
+
+	// Setup option set checks
+	api.checks.modal = {
+		'^show.modal.(on|blur)$': function() {
+			// Initialise
+			self.destroy();
+			self.init();
+			
+			// Show the modal if not visible already and tooltip is visible
+			overlay.toggle( tooltip.is(':visible') );
+		}
+	};
+
 	$.extend(self, {
 		init: function()
 		{
 			// If modal is disabled... return
 			if(!options.on) { return self; }
 
-			// Create the overlay if needed
-			overlay = self.create();
+			// Set overlay reference
+			overlay = elems.overlay = OVERLAY.elem;
 
 			// Add unique attribute so we can grab modal tooltips easily via a selector
-			tooltip.attr(attr, TRUE)
+			tooltip.attr(MODALATTR, TRUE)
 
 			// Set z-index
-			.css('z-index', PLUGINS.modal.zindex + $(selector+'['+attr+']').length)
+			.css('z-index', PLUGINS.modal.zindex + $(MODALSELECTOR).length)
 			
-			// Remove previous bound events in globalNamespace
-			.unbind(globalNamespace).unbind(namespace)
-
 			// Apply our show/hide/focus modal events
-			.bind('tooltipshow'+globalNamespace+' tooltiphide'+globalNamespace, function(event, api, duration) {
+			.bind('tooltipshow'+namespace+' tooltiphide'+namespace, function(event, api, duration) {
 				var oEvent = event.originalEvent;
 
 				// Make sure mouseout doesn't trigger a hide when showing the modal and mousing onto backdrop
@@ -85,24 +248,24 @@ function Modal(api)
 						try { event.preventDefault(); } catch(e) {}
 					}
 					else if(!oEvent || (oEvent && !oEvent.solo)) {
-						self[ event.type.replace('tooltip', '') ](event, duration);
+						self.toggle(event, event.type === 'tooltipshow', duration);
 					}
 				}
 			})
 
 			// Adjust modal z-index on tooltip focus
-			.bind('tooltipfocus'+globalNamespace, function(event) {
-				// If focus was cancelled before it reearch us, don't do anything
+			.bind('tooltipfocus'+namespace, function(event, api) {
+				// If focus was cancelled before it reached us, don't do anything
 				if(event.isDefaultPrevented() || event.target !== tooltip[0]) { return; }
 
-				var qtips = $(selector).filter('['+attr+']'),
+				var qtips = $(MODALSELECTOR),
 
 				// Keep the modal's lower than other, regular qtips
 				newIndex = PLUGINS.modal.zindex + qtips.length,
 				curIndex = parseInt(tooltip[0].style.zIndex, 10);
 
 				// Set overlay z-index
-				overlay[0].style.zIndex = newIndex - 2;
+				overlay[0].style.zIndex = newIndex - 1;
 
 				// Reduce modal z-index's and keep them properly ordered
 				qtips.each(function() {
@@ -112,191 +275,60 @@ function Modal(api)
 				});
 
 				// Fire blur event for focused tooltip
-				qtips.end().filter('.' + focusClass).qtip('blur', event.originalEvent);
+				qtips.filter('.' + focusClass).qtip('blur', event.originalEvent);
 
 				// Set the new z-index
 				tooltip.addClass(focusClass)[0].style.zIndex = newIndex;
 
+				// Set current
+				OVERLAY.update(api);
+
 				// Prevent default handling
 				try { event.preventDefault(); } catch(e) {}
 			})
 
 			// Focus any other visible modals when this one hides
-			.bind('tooltiphide'+globalNamespace, function(event) {
+			.bind('tooltiphide'+namespace, function(event) {
 				if(event.target === tooltip[0]) {
-					$('[' + attr + ']').filter(':visible').not(tooltip).last().qtip('focus', event);
+					$(MODALSELECTOR).filter(':visible').not(tooltip).last().qtip('focus', event);
 				}
 			});
 
-			// Apply keyboard "Escape key" close handler
-			if(options.escape) {
-				$(document).unbind(namespace).bind('keydown'+namespace, function(event) {
-					if(event.keyCode === 27 && tooltip.hasClass(focusClass)) {
-						api.hide(event);
-					}
-				});
-			}
-
-			// Apply click handler for blur option
-			if(options.blur) {
-				elems.overlay.unbind(namespace).bind('click'+namespace, function(event) {
-					if(tooltip.hasClass(focusClass)) { api.hide(event); }
-				});
-			}
-
-			// Update focusable elements
-			updateFocusable();
-
 			return self;
 		},
 
-		create: function()
-		{
-			var elem = $(overlaySelector), win = $(window);
-
-			// Return if overlay is already rendered
-			if(elem.length) {
-				// Modal overlay should always be below all tooltips if possible
-				return (elems.overlay = elem.insertAfter( $(selector).last() ));
-			}
-
-			// Create document overlay
-			overlay = elems.overlay = $('<div />', {
-				id: overlaySelector.substr(1),
-				html: '<div></div>',
-				mousedown: function() { return FALSE; }
-			})
-			.hide()
-			.insertAfter( $(selector).last() );
-
-			// Update position on window resize or scroll
-			function resize() {
-				overlay.css({
-					height: win.height(),
-					width: win.width()
-				});
-			}
-			win.unbind(globalNamespace).bind('resize'+globalNamespace, resize);
-			resize(); // Fire it initially too
-
-			return overlay;
-		},
-
 		toggle: function(event, state, duration)
 		{
 			// Make sure default event hasn't been prevented
 			if(event && event.isDefaultPrevented()) { return self; }
 
-			var effect = options.effect,
-				type = state ? 'show': 'hide',
-				visible = overlay.is(':visible'),
-				modals = $('[' + attr + ']').filter(':visible').not(tooltip),
-				zindex;
-
-			// Create our overlay if it isn't present already
-			if(!overlay) { overlay = self.create(); }
-
-			// Prevent modal from conflicting with show.solo, and don't hide backdrop is other modals are visible
-			if((overlay.is(':animated') && visible === state && overlay.data('toggleState') !== FALSE) || (!state && modals.length)) {
-				return self;
-			}
-
-			// State specific...
-			if(state) {
-				// Set position
-				overlay.css({ left: 0, top: 0 });
-
-				// Toggle backdrop cursor style on show
-				overlay.toggleClass('blurs', options.blur);
-
-				// IF the modal can steal the focus
-				if(options.stealfocus !== FALSE) {
-					// Make sure we can't focus anything outside the tooltip
-					docBody.bind('focusin'+namespace, stealFocus);
-
-					// Blur the current item and focus anything in the modal we an
-					focusInputs( $('body :focus') );
-				}
-			}
-			else {
-				// Undelegate focus handler
-				docBody.unbind('focusin'+namespace);
-			}
-
-			// Stop all animations
-			overlay.stop(TRUE, FALSE).data('toggleState', state);
-
-			// Use custom function if provided
-			if($.isFunction(effect)) {
-				effect.call(overlay, state);
-			}
-
-			// If no effect type is supplied, use a simple toggle
-			else if(effect === FALSE) {
-				overlay[ type ]();
-			}
-
-			// Use basic fade function
-			else {
-				overlay.fadeTo( parseInt(duration, 10) || 90, state ? 1 : 0, function() {
-					if(!state) { $(this).hide(); }
-				});
-			}
-
-			// Reset position on hide
-			if(!state) {
-				overlay.queue(function(next) {
-					overlay.css({ left: '', top: '' }).removeData('toggleState');
-					next();
-				});
-			}
+			// Toggle it
+			OVERLAY.toggle(api, !!state, duration);
 
 			return self;
 		},
 
-		show: function(event, duration) { return self.toggle(event, TRUE, duration); },
-		hide: function(event, duration) { return self.toggle(event, FALSE, duration); },
-
-		destroy: function()
-		{
-			var delBlanket = overlay;
-
-			if(delBlanket) {
-				// Check if any other modal tooltips are present
-				delBlanket = $('[' + attr + ']').not(tooltip).length < 1;
-
-				// Remove overlay if needed
-				if(delBlanket) {
-					elems.overlay.remove();
-					$(document).unbind(globalNamespace);
-				}
-				else {
-					elems.overlay.unbind(globalNamespace+api.id);
-				}
-
-				// Undelegate focus handler
-				docBody.unbind('focusin'+namespace);
-			}
-
+		destroy: function() {
 			// Remove bound events
-			return tooltip.removeAttr(attr).unbind(globalNamespace);
+			$([document, tooltip]).removeAttr(MODALATTR).unbind(namespace);
+
+			// Delete element reference
+			OVERLAY.toggle(api, FALSE);
+			delete elems.overlay;
 		}
 	});
 
 	self.init();
 }
 
-PLUGINS.modal = function(api) {
+MODAL = PLUGINS.modal = function(api) {
 	var self = api.plugins.modal;
 
 	return 'object' === typeof self ? self : (api.plugins.modal = new Modal(api));
 };
 
-// Plugin needs to be initialized on render
-PLUGINS.modal.initialize = 'render';
-
 // Setup sanitiztion rules
-PLUGINS.modal.sanitize = function(opts) {
+MODAL.sanitize = function(opts) {
 	if(opts.show) { 
 		if(typeof opts.show.modal !== 'object') { opts.show.modal = { on: !!opts.show.modal }; }
 		else if(typeof opts.show.modal.on === 'undefined') { opts.show.modal.on = TRUE; }
@@ -304,11 +336,10 @@ PLUGINS.modal.sanitize = function(opts) {
 };
 
 // Base z-index for all modal tooltips (use qTip core z-index as a base)
-PLUGINS.modal.zindex = QTIP.zindex - 200;
+MODAL.zindex = QTIP.zindex - 200;
 
-// Defines the selector used to select all 'focusable' elements within the modal when using the show.modal.stealfocus option.
-// Selectors initially taken from http://stackoverflow.com/questions/7668525/is-there-a-jquery-selector-to-get-all-elements-that-can-get-focus
-PLUGINS.modal.focusable = ['a[href]', 'area[href]', 'input', 'select', 'textarea', 'button', 'iframe', 'object', 'embed', '[tabindex]', '[contenteditable]'];
+// Plugin needs to be initialized on render
+MODAL.initialize = 'render';
 
 // Extend original api defaults
 $.extend(TRUE, QTIP.defaults, {