jquery-qtip2-rails 0.0.1

data/vendor/assets/javascripts/jquery-qtip/outro.js

@@ -0,0 +1,2 @@
+
+}));

data/vendor/assets/javascripts/jquery-qtip/svg/svg.js

@@ -0,0 +1,43 @@
+PLUGINS.svg = function(svg, corner)
+{
+	var doc = $(document),
+		elem = svg[0],
+		result = {
+			width: 0, height: 0,
+			offset: { top: 1e10, left: 1e10 }
+		},
+		box, mtx, root, point, tPoint;
+
+	if (elem.getBBox && elem.parentNode) {
+		box = elem.getBBox();
+		mtx = elem.getScreenCTM();
+		root = elem.farthestViewportElement || elem;
+
+		// Return if no method is found
+		if(!root.createSVGPoint) { return result; }
+
+		// Create our point var
+		point = root.createSVGPoint();
+
+		// Adjust top and left
+		point.x = box.x;
+		point.y = box.y;
+		tPoint = point.matrixTransform(mtx);
+		result.offset.left = tPoint.x;
+		result.offset.top = tPoint.y;
+
+		// Adjust width and height
+		point.x += box.width;
+		point.y += box.height;
+		tPoint = point.matrixTransform(mtx);
+		result.width = tPoint.x - result.offset.left;
+		result.height = tPoint.y - result.offset.top;
+
+		// Adjust by scroll offset
+		result.offset.left += doc.scrollLeft();
+		result.offset.top += doc.scrollTop();
+	}
+
+	return result;
+};
+

data/vendor/assets/javascripts/jquery-qtip/tips/tips.js

@@ -0,0 +1,610 @@
+// Tip coordinates calculator
+function calculateTip(corner, width, height)
+{	
+	var width2 = Math.ceil(width / 2), height2 = Math.ceil(height / 2),
+
+	// Define tip coordinates in terms of height and width values
+	tips = {
+		bottomright:	[[0,0],				[width,height],		[width,0]],
+		bottomleft:		[[0,0],				[width,0],				[0,height]],
+		topright:		[[0,height],		[width,0],				[width,height]],
+		topleft:			[[0,0],				[0,height],				[width,height]],
+		topcenter:		[[0,height],		[width2,0],				[width,height]],
+		bottomcenter:	[[0,0],				[width,0],				[width2,height]],
+		rightcenter:	[[0,0],				[width,height2],		[0,height]],
+		leftcenter:		[[width,0],			[width,height],		[0,height2]]
+	};
+
+	// Set common side shapes
+	tips.lefttop = tips.bottomright; tips.righttop = tips.bottomleft;
+	tips.leftbottom = tips.topright; tips.rightbottom = tips.topleft;
+
+	return tips[ corner.string() ];
+}
+
+
+function Tip(qTip, command)
+{
+	var self = this,
+		opts = qTip.options.style.tip,
+		elems = qTip.elements,
+		tooltip = elems.tooltip,
+		cache = { top: 0, left: 0 },
+		size = {
+			width: opts.width,
+			height: opts.height
+		},
+		color = { },
+		border = opts.border || 0,
+		namespace = '.qtip-tip',
+		hasCanvas = !!($('<canvas />')[0] || {}).getContext;
+
+	self.corner = NULL;
+	self.mimic = NULL;
+	self.border = border;
+	self.offset = opts.offset;
+	self.size = size;
+
+	// Add new option checks for the plugin
+	qTip.checks.tip = {
+		'^position.my|style.tip.(corner|mimic|border)$': function() {
+			// Make sure a tip can be drawn
+			if(!self.init()) {
+				self.destroy();
+			}
+
+			// Reposition the tooltip
+			qTip.reposition();
+		},
+		'^style.tip.(height|width)$': function() {
+			// Re-set dimensions and redraw the tip
+			size = {
+				width: opts.width,
+				height: opts.height
+			};
+			self.create();
+			self.update();
+
+			// Reposition the tooltip
+			qTip.reposition();
+		},
+		'^content.title.text|style.(classes|widget)$': function() {
+			if(elems.tip && elems.tip.length) {
+				self.update();
+			}
+		}
+	};
+
+	function swapDimensions() {
+		var temp = size.width;
+		size.width = size.height;
+		size.height = temp;
+	}
+
+	function resetDimensions() {
+		size.width = opts.width;
+		size.height = opts.height;
+	}
+
+	function reposition(event, api, pos, viewport) {
+		if(!elems.tip) { return; }
+
+		var newCorner = self.corner.clone(),
+			adjust = pos.adjusted,
+			method = qTip.options.position.adjust.method.split(' '),
+			horizontal = method[0],
+			vertical = method[1] || method[0],
+			shift = { left: FALSE, top: FALSE, x: 0, y: 0 },
+			offset, css = {}, props;
+
+		// Make sure our tip position isn't fixed e.g. doesn't adjust with viewport
+		if(self.corner.fixed !== TRUE) {
+			// Horizontal - Shift or flip method
+			if(horizontal === 'shift' && newCorner.precedance === 'x' && adjust.left && newCorner.y !== 'center') {
+				newCorner.precedance = newCorner.precedance === 'x' ? 'y' : 'x';
+			}
+			else if(horizontal !== 'shift' && adjust.left){
+				newCorner.x = newCorner.x === 'center' ? (adjust.left > 0 ? 'left' : 'right') : (newCorner.x === 'left' ? 'right' : 'left');
+			}
+
+			// Vertical - Shift or flip method
+			if(vertical === 'shift' && newCorner.precedance === 'y' && adjust.top && newCorner.x !== 'center') {
+				newCorner.precedance = newCorner.precedance === 'y' ? 'x' : 'y';
+			}
+			else if(vertical !== 'shift' && adjust.top) {
+				newCorner.y = newCorner.y === 'center' ? (adjust.top > 0 ? 'top' : 'bottom') : (newCorner.y === 'top' ? 'bottom' : 'top');
+			}
+
+			// Update and redraw the tip if needed (check cached details of last drawn tip)
+			if(newCorner.string() !== cache.corner.string() && (cache.top !== adjust.top || cache.left !== adjust.left)) {
+				self.update(newCorner, FALSE);
+			}
+		}
+
+		// Setup tip offset properties
+		offset = self.position(newCorner, adjust);
+		if(offset.right !== undefined) { offset.left = -offset.right; }
+		if(offset.bottom !== undefined) { offset.top = -offset.bottom; }
+		offset.user = Math.max(0, opts.offset);
+
+		// Viewport "shift" specific adjustments
+		if(shift.left = (horizontal === 'shift' && !!adjust.left)) {
+			if(newCorner.x === 'center') {
+				css['margin-left'] = shift.x = offset['margin-left'] - adjust.left;
+			}
+			else {
+				props = offset.right !== undefined ?
+					[ adjust.left, -offset.left ] : [ -adjust.left, offset.left ];
+
+				if( (shift.x = Math.max(props[0], props[1])) > props[0] ) {
+					pos.left -= adjust.left;
+					shift.left = FALSE;
+				}
+				
+				css[ offset.right !== undefined ? 'right' : 'left' ] = shift.x;
+			}
+		}
+		if(shift.top = (vertical === 'shift' && !!adjust.top)) {
+			if(newCorner.y === 'center') {
+				css['margin-top'] = shift.y = offset['margin-top'] - adjust.top;
+			}
+			else {
+				props = offset.bottom !== undefined ?
+					[ adjust.top, -offset.top ] : [ -adjust.top, offset.top ];
+
+				if( (shift.y = Math.max(props[0], props[1])) > props[0] ) {
+					pos.top -= adjust.top;
+					shift.top = FALSE;
+				}
+
+				css[ offset.bottom !== undefined ? 'bottom' : 'top' ] = shift.y;
+			}
+		}
+
+		/*
+		 * If the tip is adjusted in both dimensions, or in a
+		 * direction that would cause it to be anywhere but the
+		 * outer border, hide it!
+		 */
+		elems.tip.css(css).toggle(
+			!((shift.x && shift.y) || (newCorner.x === 'center' && shift.y) || (newCorner.y === 'center' && shift.x))
+		);
+
+		// Adjust position to accomodate tip dimensions
+		pos.left -= offset.left.charAt ? offset.user : horizontal !== 'shift' || shift.top || !shift.left && !shift.top ? offset.left : 0;
+		pos.top -= offset.top.charAt ? offset.user : vertical !== 'shift' || shift.left || !shift.left && !shift.top ? offset.top : 0;
+
+		// Cache details
+		cache.left = adjust.left; cache.top = adjust.top;
+		cache.corner = newCorner.clone();
+	}
+
+	/* border width calculator */
+	function borderWidth(corner, side, backup) {
+		side = !side ? corner[corner.precedance] : side;
+		
+		var isFluid = tooltip.hasClass(fluidClass),
+			isTitleTop = elems.titlebar && corner.y === 'top',
+			elem = isTitleTop ? elems.titlebar : elems.content,
+			css = 'border-' + side + '-width',
+			val;
+
+		// Grab the border-width value (add fluid class if needed)
+		tooltip.addClass(fluidClass);
+		val = parseInt(elem.css(css), 10);
+		val = (backup ? val || parseInt(tooltip.css(css), 10) : val) || 0;
+		tooltip.toggleClass(fluidClass, isFluid);
+
+		return val;
+	}
+
+	function borderRadius(corner) {
+		var isTitleTop = elems.titlebar && corner.y === 'top',
+			elem = isTitleTop ? elems.titlebar : elems.content,
+			moz = $.browser.mozilla,
+			prefix = moz ? '-moz-' : $.browser.webkit ? '-webkit-' : '',
+			side = corner.y + (moz ? '' : '-') + corner.x,
+			css = prefix + (moz ? 'border-radius-' + side : 'border-' + side + '-radius');
+
+		return parseInt(elem.css(css), 10) || parseInt(tooltip.css(css), 10) || 0;
+	}
+
+	function calculateSize(corner) {
+		var y = corner.precedance === 'y',
+			width = size [ y ? 'width' : 'height' ],
+			height = size [ y ? 'height' : 'width' ],
+			isCenter = corner.string().indexOf('center') > -1,
+			base = width * (isCenter ? 0.5 : 1),
+			pow = Math.pow,
+			round = Math.round,
+			bigHyp, ratio, result,
+
+		smallHyp = Math.sqrt( pow(base, 2) + pow(height, 2) ),
+		
+		hyp = [
+			(border / base) * smallHyp, (border / height) * smallHyp
+		];
+		hyp[2] = Math.sqrt( pow(hyp[0], 2) - pow(border, 2) );
+		hyp[3] = Math.sqrt( pow(hyp[1], 2) - pow(border, 2) );
+
+		bigHyp = smallHyp + hyp[2] + hyp[3] + (isCenter ? 0 : hyp[0]);
+		ratio = bigHyp / smallHyp;
+
+		result = [ round(ratio * height), round(ratio * width) ];
+		return { height: result[ y ? 0 : 1 ], width: result[ y ? 1 : 0 ] };
+	}
+
+	$.extend(self, {
+		init: function()
+		{
+			var enabled = self.detectCorner() && (hasCanvas || $.browser.msie);
+
+			// Determine tip corner and type
+			if(enabled) {
+				// Create a new tip and draw it
+				self.create();
+				self.update();
+
+				// Bind update events
+				tooltip.unbind(namespace).bind('tooltipmove'+namespace, reposition);
+			}
+			
+			return enabled;
+		},
+
+		detectCorner: function()
+		{
+			var corner = opts.corner,
+				posOptions = qTip.options.position,
+				at = posOptions.at,
+				my = posOptions.my.string ? posOptions.my.string() : posOptions.my;
+
+			// Detect corner and mimic properties
+			if(corner === FALSE || (my === FALSE && at === FALSE)) {
+				return FALSE;
+			}
+			else {
+				if(corner === TRUE) {
+					self.corner = new PLUGINS.Corner(my);
+				}
+				else if(!corner.string) {
+					self.corner = new PLUGINS.Corner(corner);
+					self.corner.fixed = TRUE;
+				}
+			}
+
+			// Cache it
+			cache.corner = new PLUGINS.Corner( self.corner.string() );
+
+			return self.corner.string() !== 'centercenter';
+		},
+
+		detectColours: function(actual) {
+			var i, fill, border,
+				tip = elems.tip.css('cssText', ''),
+				corner = actual || self.corner,
+				precedance = corner[ corner.precedance ],
+
+				borderSide = 'border-' + precedance + '-color',
+				borderSideCamel = 'border' + precedance.charAt(0) + precedance.substr(1) + 'Color',
+
+				invalid = /rgba?\(0, 0, 0(, 0)?\)|transparent|#123456/i,
+				backgroundColor = 'background-color',
+				transparent = 'transparent',
+				important = ' !important',
+
+				bodyBorder = $(document.body).css('color'),
+				contentColour = qTip.elements.content.css('color'),
+
+				useTitle = elems.titlebar && (corner.y === 'top' || (corner.y === 'center' && tip.position().top + (size.height / 2) + opts.offset < elems.titlebar.outerHeight(1))),
+				colorElem = useTitle ? elems.titlebar : elems.content;
+
+			// Apply the fluid class so we can see our CSS values properly
+			tooltip.addClass(fluidClass);
+
+			// Detect tip colours from CSS styles
+			color.fill = fill = tip.css(backgroundColor);
+			color.border = border = tip[0].style[ borderSideCamel ] || tip.css(borderSide) || tooltip.css(borderSide);
+
+			// Make sure colours are valid
+			if(!fill || invalid.test(fill)) {
+				color.fill = colorElem.css(backgroundColor) || transparent;
+				if(invalid.test(color.fill)) {
+					color.fill = tooltip.css(backgroundColor) || fill;
+				}
+			}
+			if(!border || invalid.test(border) || border === bodyBorder) {
+				color.border = colorElem.css(borderSide) || transparent;
+				if(invalid.test(color.border)) {
+					color.border = border;
+				}
+			}
+
+			// Reset background and border colours
+			$('*', tip).add(tip).css('cssText', backgroundColor+':'+transparent+important+';border:0'+important+';');
+
+			// Remove fluid class
+			tooltip.removeClass(fluidClass);
+		},
+
+		create: function()
+		{
+			var width = size.width,
+				height = size.height,
+				vml;
+
+			// Remove previous tip element if present
+			if(elems.tip) { elems.tip.remove(); }
+
+			// Create tip element and prepend to the tooltip
+			elems.tip = $('<div />', { 'class': 'ui-tooltip-tip' }).css({ width: width, height: height }).prependTo(tooltip);
+
+			// Create tip drawing element(s)
+			if(hasCanvas) {
+				// save() as soon as we create the canvas element so FF2 doesn't bork on our first restore()!
+				$('<canvas />').appendTo(elems.tip)[0].getContext('2d').save();
+			}
+			else {
+				vml = '<vml:shape coordorigin="0,0" style="display:inline-block; position:absolute; behavior:url(#default#VML);"></vml:shape>';
+				elems.tip.html(vml + vml);
+
+				// Prevent mousing down on the tip since it causes problems with .live() handling in IE due to VML
+				$('*', elems.tip).bind('click mousedown', function(event) { event.stopPropagation(); });
+			}
+		},
+
+		update: function(corner, position)
+		{
+			var tip = elems.tip,
+				inner = tip.children(),
+				width = size.width,
+				height = size.height,
+				regular = 'px solid ',
+				transparent = 'px dashed transparent', // Dashed IE6 border-transparency hack. Awesome!
+				mimic = opts.mimic,
+				round = Math.round,
+				precedance, context, coords, translate, newSize;
+
+			// Re-determine tip if not already set
+			if(!corner) { corner = cache.corner || self.corner; }
+
+			// Use corner property if we detect an invalid mimic value
+			if(mimic === FALSE) { mimic = corner; }
+
+			// Otherwise inherit mimic properties from the corner object as necessary
+			else {
+				mimic = new PLUGINS.Corner(mimic);
+				mimic.precedance = corner.precedance;
+
+				if(mimic.x === 'inherit') { mimic.x = corner.x; }
+				else if(mimic.y === 'inherit') { mimic.y = corner.y; }
+				else if(mimic.x === mimic.y) {
+					mimic[ corner.precedance ] = corner[ corner.precedance ];
+				}
+			}
+			precedance = mimic.precedance;
+
+			// Ensure the tip width.height are relative to the tip position
+			if(corner.precedance === 'x') { swapDimensions(); }
+			else { resetDimensions(); }
+
+			// Set the tip dimensions
+			elems.tip.css({
+				width: (width = size.width),
+				height: (height = size.height)
+			});
+
+			// Update our colours
+			self.detectColours(corner);
+
+			// Detect border width, taking into account colours
+			if(color.border !== 'transparent' && color.border !== '#123456') {
+				// Grab border width
+				border = borderWidth(corner, NULL, TRUE);
+
+				// If border width isn't zero, use border color as fill (1.0 style tips)
+				if(opts.border === 0 && border > 0) { color.fill = color.border; }
+
+				// Set border width (use detected border width if opts.border is true)
+				self.border = border = opts.border !== TRUE ? opts.border : border;
+			}
+
+			// Border colour was invalid, set border to zero
+			else { self.border = border = 0; }
+
+			// Calculate coordinates
+			coords = calculateTip(mimic, width , height);
+
+			// Determine tip size
+			self.size = newSize = calculateSize(corner);
+			tip.css(newSize);
+
+			// Calculate tip translation
+			if(corner.precedance === 'y') {
+				translate = [
+					round(mimic.x === 'left' ? border : mimic.x === 'right' ? newSize.width - width - border : (newSize.width - width) / 2),
+					round(mimic.y === 'top' ?  newSize.height - height : 0)
+				];
+			}
+			else {
+				translate = [
+					round(mimic.x === 'left' ? newSize.width - width : 0),
+					round(mimic.y === 'top' ? border : mimic.y === 'bottom' ? newSize.height - height - border : (newSize.height - height) / 2)
+				];
+			}
+
+			// Canvas drawing implementation
+			if(hasCanvas) {
+				// Set the canvas size using calculated size
+				inner.attr(newSize);
+				
+				// Grab canvas context and clear/save it
+				context = inner[0].getContext('2d');
+				context.restore(); context.save();
+				context.clearRect(0,0,3000,3000);
+				
+				// Translate origin
+				context.translate(translate[0], translate[1]);
+				
+				// Draw the tip
+				context.beginPath();
+				context.moveTo(coords[0][0], coords[0][1]);
+				context.lineTo(coords[1][0], coords[1][1]);
+				context.lineTo(coords[2][0], coords[2][1]);
+				context.closePath();
+				context.fillStyle = color.fill;
+				context.strokeStyle = color.border;
+				context.lineWidth = border * 2;
+				context.lineJoin = 'miter';
+				context.miterLimit = 100;
+				if(border) { context.stroke(); }
+				context.fill();
+			}
+
+			// VML (IE Proprietary implementation)
+			else {
+				// Setup coordinates string
+				coords = 'm' + coords[0][0] + ',' + coords[0][1] + ' l' + coords[1][0] +
+					',' + coords[1][1] + ' ' + coords[2][0] + ',' + coords[2][1] + ' xe';
+
+				// Setup VML-specific offset for pixel-perfection
+				translate[2] = border && /^(r|b)/i.test(corner.string()) ?
+					parseFloat($.browser.version, 10) === 8 ? 2 : 1 : 0;
+
+				// Set initial CSS
+				inner.css({
+					antialias: ''+(mimic.string().indexOf('center') > -1),
+					left: translate[0] - (translate[2] * Number(precedance === 'x')),
+					top: translate[1] - (translate[2] * Number(precedance === 'y')),
+					width: width + border,
+					height: height + border
+				})
+				.each(function(i) {
+					var $this = $(this);
+
+					// Set shape specific attributes
+					$this[ $this.prop ? 'prop' : 'attr' ]({
+						coordsize: (width+border) + ' ' + (height+border),
+						path: coords,
+						fillcolor: color.fill,
+						filled: !!i,
+						stroked: !!!i
+					})
+					.css({ display: border || i ? 'block' : 'none' });
+
+					// Check if border is enabled and add stroke element
+					if(!i && $this.html() === '') {
+						$this.html(
+							'<vml:stroke weight="'+(border*2)+'px" color="'+color.border+'" miterlimit="1000" joinstyle="miter" ' +
+							' style="behavior:url(#default#VML); display:inline-block;" />'
+						);
+					}
+				});
+			}
+
+			// Position if needed
+			if(position !== FALSE) { self.position(corner); }
+		},
+
+		// Tip positioning method
+		position: function(corner)
+		{
+			var tip = elems.tip,
+				position = {},
+				userOffset = Math.max(0, opts.offset),
+				precedance, dimensions, corners;
+
+			// Return if tips are disabled or tip is not yet rendered
+			if(opts.corner === FALSE || !tip) { return FALSE; }
+
+			// Inherit corner if not provided
+			corner = corner || self.corner;
+			precedance = corner.precedance;
+
+			// Determine which tip dimension to use for adjustment
+			dimensions = calculateSize(corner);
+
+			// Setup corners and offset array
+			corners = [ corner.x, corner.y ];
+			if(precedance === 'x') { corners.reverse(); }
+
+			// Calculate tip position
+			$.each(corners, function(i, side) {
+				var b, br;
+
+				if(side === 'center') {
+					b = precedance === 'y' ? 'left' : 'top';
+					position[ b ] = '50%';
+					position['margin-' + b] = -Math.round(dimensions[ precedance === 'y' ? 'width' : 'height' ] / 2) + userOffset;
+				}
+				else {
+					b = borderWidth(corner, side, TRUE);
+					br = borderRadius(corner);
+					
+					position[ side ] = i ?
+						border ? borderWidth(corner, side) : 0 : 
+						userOffset + (br > b ? br : 0);
+				}
+			});
+
+			// Adjust for tip dimensions
+			position[ corner[precedance] ] -= dimensions[ precedance === 'x' ? 'width' : 'height' ];
+
+			// Set and return new position
+			tip.css({ top: '', bottom: '', left: '', right: '', margin: '' }).css(position);
+			return position;
+		},
+		
+		destroy: function()
+		{
+			// Remove the tip element
+			if(elems.tip) { elems.tip.remove(); }
+			elems.tip = false;
+
+			// Unbind events
+			tooltip.unbind(namespace);
+		}
+	});
+
+	self.init();
+}
+
+PLUGINS.tip = function(api)
+{
+	var self = api.plugins.tip;
+	
+	return 'object' === typeof self ? self : (api.plugins.tip = new Tip(api));
+};
+
+// Initialize tip on render
+PLUGINS.tip.initialize = 'render';
+
+// Setup plugin sanitization options
+PLUGINS.tip.sanitize = function(options)
+{
+	var style = options.style, opts;
+	if(style && 'tip' in style) {
+		opts = options.style.tip;
+		if(typeof opts !== 'object'){ options.style.tip = { corner: opts }; }
+		if(!(/string|boolean/i).test(typeof opts.corner)) { opts.corner = TRUE; }
+		if(typeof opts.width !== 'number'){ delete opts.width; }
+		if(typeof opts.height !== 'number'){ delete opts.height; }
+		if(typeof opts.border !== 'number' && opts.border !== TRUE){ delete opts.border; }
+		if(typeof opts.offset !== 'number'){ delete opts.offset; }
+	}
+};
+
+// Extend original qTip defaults
+$.extend(TRUE, QTIP.defaults, {
+	style: {
+		tip: {
+			corner: TRUE,
+			mimic: FALSE,
+			width: 6,
+			height: 6,
+			border: TRUE,
+			offset: 0
+		}
+	}
+});
+