/*!

 PowerTip - v1.2.0 - 2013-04-03

 http://stevenbenner.github.com/jquery-powertip/

 Copyright (c) 2013 Steven Benner (http://stevenbenner.com/).

 Released under MIT license.

 https://raw.github.com/stevenbenner/jquery-powertip/master/LICENSE.txt

*/

(function(factory) {

	if (typeof define === 'function' && define.amd) {

		// AMD. Register as an anonymous module.

		define(['jquery'], factory);

	} else {

		// Browser globals

		factory(jQuery);

	}

}(function($) {

	// useful private variables

	var $document = $(document),

		$window = $(window),

		$body = $('body');

	// constants

	var DATA_DISPLAYCONTROLLER = 'displayController',

		DATA_HASACTIVEHOVER = 'hasActiveHover',

		DATA_FORCEDOPEN = 'forcedOpen',

		DATA_HASMOUSEMOVE = 'hasMouseMove',

		DATA_MOUSEONTOTIP = 'mouseOnToPopup',

		DATA_ORIGINALTITLE = 'originalTitle',

		DATA_POWERTIP = 'powertip',

		DATA_POWERTIPJQ = 'powertipjq',

		DATA_POWERTIPTARGET = 'powertiptarget',

		RAD2DEG = 180 / Math.PI;

	/**

	 * Session data

	 * Private properties global to all powerTip instances

	 */

	var session = {

		isTipOpen: false,

		isFixedTipOpen: false,

		isClosing: false,

		tipOpenImminent: false,

		activeHover: null,

		currentX: 0,

		currentY: 0,

		previousX: 0,

		previousY: 0,

		desyncTimeout: null,

		mouseTrackingActive: false,

		delayInProgress: false,

		windowWidth: 0,

		windowHeight: 0,

		scrollTop: 0,

		scrollLeft: 0

	};

	/**

	 * Collision enumeration

	 * @enum {number}

	 */

	var Collision = {

		none: 0,

		top: 1,

		bottom: 2,

		left: 4,

		right: 8

	};

	/**

	 * Display hover tooltips on the matched elements.

	 * @param {(Object|string)} opts The options object to use for the plugin, or

	 *     the name of a method to invoke on the first matched element.

	 * @param {*=} [arg] Argument for an invoked method (optional).

	 * @return {jQuery} jQuery object for the matched selectors.

	 */

	$.fn.powerTip = function(opts, arg) {

		// don't do any work if there were no matched elements

		if (!this.length) {

			return this;

		}

		// handle api method calls on the plugin, e.g. powerTip('hide')

		if ($.type(opts) === 'string' && $.powerTip[opts]) {

			return $.powerTip[opts].call(this, this, arg);

		}

		// extend options and instantiate TooltipController

		var options = $.extend({}, $.fn.powerTip.defaults, opts),

			tipController = new TooltipController(options);

		// hook mouse and viewport dimension tracking

		initTracking();

		// setup the elements

		this.each(function elementSetup() {

			var $this = $(this),

				dataPowertip = $this.data(DATA_POWERTIP),

				dataElem = $this.data(DATA_POWERTIPJQ),

				dataTarget = $this.data(DATA_POWERTIPTARGET),

				title;

			// handle repeated powerTip calls on the same element by destroying the

			// original instance hooked to it and replacing it with this call

			if ($this.data(DATA_DISPLAYCONTROLLER)) {

				$.powerTip.destroy($this);

			}

			// attempt to use title attribute text if there is no data-powertip,

			// data-powertipjq or data-powertiptarget. If we do use the title

			// attribute, delete the attribute so the browser will not show it

			title = $this.attr('title');

			if (!dataPowertip && !dataTarget && !dataElem && title) {

				$this.data(DATA_POWERTIP, title);

				$this.data(DATA_ORIGINALTITLE, title);

				$this.removeAttr('title');

			}

			// create hover controllers for each element

			$this.data(

				DATA_DISPLAYCONTROLLER,

				new DisplayController($this, options, tipController)

			);

		});

		// attach events to matched elements if the manual options is not enabled

		if (!options.manual) {

			this.on({

				// mouse events

				'mouseenter.powertip': function elementMouseEnter(event) {

					$.powerTip.show(this, event);

				},

				'mouseleave.powertip': function elementMouseLeave() {

					$.powerTip.hide(this);

				},

				// keyboard events

				'focus.powertip': function elementFocus() {

					$.powerTip.show(this);

				},

				'blur.powertip': function elementBlur() {

					$.powerTip.hide(this, true);

				},

				'keydown.powertip': function elementKeyDown(event) {

					// close tooltip when the escape key is pressed

					if (event.keyCode === 27) {

						$.powerTip.hide(this, true);

					}

				}

			});

		}

		return this;

	};

	/**

	 * Default options for the powerTip plugin.

	 */

	$.fn.powerTip.defaults = {

		fadeInTime: 200,

		fadeOutTime: 100,

		followMouse: false,

		popupId: 'powerTip',

		intentSensitivity: 7,

		intentPollInterval: 100,

		closeDelay: 100,

		placement: 'n',

		smartPlacement: false,

		offset: 10,

		mouseOnToPopup: false,

		manual: false

	};

	/**

	 * Default smart placement priority lists.

	 * The first item in the array is the highest priority, the last is the lowest.

	 * The last item is also the default, which will be used if all previous options

	 * do not fit.

	 */

	$.fn.powerTip.smartPlacementLists = {

		n: ['n', 'ne', 'nw', 's'],

		e: ['e', 'ne', 'se', 'w', 'nw', 'sw', 'n', 's', 'e'],

		s: ['s', 'se', 'sw', 'n'],

		w: ['w', 'nw', 'sw', 'e', 'ne', 'se', 'n', 's', 'w'],

		nw: ['nw', 'w', 'sw', 'n', 's', 'se', 'nw'],

		ne: ['ne', 'e', 'se', 'n', 's', 'sw', 'ne'],

		sw: ['sw', 'w', 'nw', 's', 'n', 'ne', 'sw'],

		se: ['se', 'e', 'ne', 's', 'n', 'nw', 'se'],

		'nw-alt': ['nw-alt', 'n', 'ne-alt', 'sw-alt', 's', 'se-alt', 'w', 'e'],

		'ne-alt': ['ne-alt', 'n', 'nw-alt', 'se-alt', 's', 'sw-alt', 'e', 'w'],

		'sw-alt': ['sw-alt', 's', 'se-alt', 'nw-alt', 'n', 'ne-alt', 'w', 'e'],

		'se-alt': ['se-alt', 's', 'sw-alt', 'ne-alt', 'n', 'nw-alt', 'e', 'w']

	};

	/**

	 * Public API

	 */

	$.powerTip = {

		/**

		 * Attempts to show the tooltip for the specified element.

		 * @param {jQuery|Element} element The element to open the tooltip for.

		 * @param {jQuery.Event=} event jQuery event for hover intent and mouse

		 *     tracking (optional).

		 */

		show: function apiShowTip(element, event) {

			if (event) {

				trackMouse(event);

				session.previousX = event.pageX;

				session.previousY = event.pageY;

				$(element).data(DATA_DISPLAYCONTROLLER).show();

			} else {

				$(element).first().data(DATA_DISPLAYCONTROLLER).show(true, true);

			}

			return element;

		},

		/**

		 * Repositions the tooltip on the element.

		 * @param {jQuery|Element} element The element the tooltip is shown for.

		 */

		reposition: function apiResetPosition(element) {

			$(element).first().data(DATA_DISPLAYCONTROLLER).resetPosition();

			return element;

		},

		/**

		 * Attempts to close any open tooltips.

		 * @param {(jQuery|Element)=} element The element with the tooltip that

		 *     should be closed (optional).

		 * @param {boolean=} immediate Disable close delay (optional).

		 */

		hide: function apiCloseTip(element, immediate) {

			if (element) {

				$(element).first().data(DATA_DISPLAYCONTROLLER).hide(immediate);

			} else {

				if (session.activeHover) {

					session.activeHover.data(DATA_DISPLAYCONTROLLER).hide(true);

				}

			}

			return element;

		},

		/**

		 * Destroy and roll back any powerTip() instance on the specified element.

		 * @param {jQuery|Element} element The element with the powerTip instance.

		 */

		destroy: function apiDestroy(element) {

			$(element).off('.powertip').each(function destroy() {

				var $this = $(this),

					dataAttributes = [

						DATA_ORIGINALTITLE,

						DATA_DISPLAYCONTROLLER,

						DATA_HASACTIVEHOVER,

						DATA_FORCEDOPEN

					];

				if ($this.data(DATA_ORIGINALTITLE)) {

					$this.attr('title', $this.data(DATA_ORIGINALTITLE));

					dataAttributes.push(DATA_POWERTIP);

				}

				$this.removeData(dataAttributes);

			});

			return element;

		}

	};

	// API aliasing

	$.powerTip.showTip = $.powerTip.show;

	$.powerTip.closeTip = $.powerTip.hide;

	/**

	 * Creates a new CSSCoordinates object.

	 * @private

	 * @constructor

	 */

	function CSSCoordinates() {

		var me = this;

		// initialize object properties

		me.top = 'auto';

		me.left = 'auto';

		me.right = 'auto';

		me.bottom = 'auto';

		/**

		 * Set a property to a value.

		 * @private

		 * @param {string} property The name of the property.

		 * @param {number} value The value of the property.

		 */

		me.set = function(property, value) {

			if ($.isNumeric(value)) {

				me[property] = Math.round(value);

			}

		};

	}

	/**

	 * Creates a new tooltip display controller.

	 * @private

	 * @constructor

	 * @param {jQuery} element The element that this controller will handle.

	 * @param {Object} options Options object containing settings.

	 * @param {TooltipController} tipController The TooltipController object for

	 *     this instance.

	 */

	function DisplayController(element, options, tipController) {

		var hoverTimer = null;

		/**

		 * Begins the process of showing a tooltip.

		 * @private

		 * @param {boolean=} immediate Skip intent testing (optional).

		 * @param {boolean=} forceOpen Ignore cursor position and force tooltip to

		 *     open (optional).

		 */

		function openTooltip(immediate, forceOpen) {

			cancelTimer();

			if (!element.data(DATA_HASACTIVEHOVER)) {

				if (!immediate) {

					session.tipOpenImminent = true;

					hoverTimer = setTimeout(

						function intentDelay() {

							hoverTimer = null;

							checkForIntent();

						},

						options.intentPollInterval

					);

				} else {

					if (forceOpen) {

						element.data(DATA_FORCEDOPEN, true);

					}

					tipController.showTip(element);

				}

			}

		}

		/**

		 * Begins the process of closing a tooltip.

		 * @private

		 * @param {boolean=} disableDelay Disable close delay (optional).

		 */

		function closeTooltip(disableDelay) {

			cancelTimer();

			session.tipOpenImminent = false;

			if (element.data(DATA_HASACTIVEHOVER)) {

				element.data(DATA_FORCEDOPEN, false);

				if (!disableDelay) {

					session.delayInProgress = true;

					hoverTimer = setTimeout(

						function closeDelay() {

							hoverTimer = null;

							tipController.hideTip(element);

							session.delayInProgress = false;

						},

						options.closeDelay

					);

				} else {

					tipController.hideTip(element);

				}

			}

		}

		/**

		 * Checks mouse position to make sure that the user intended to hover on the

		 * specified element before showing the tooltip.

		 * @private

		 */

		function checkForIntent() {

			// calculate mouse position difference

			var xDifference = Math.abs(session.previousX - session.currentX),

				yDifference = Math.abs(session.previousY - session.currentY),

				totalDifference = xDifference + yDifference;

			// check if difference has passed the sensitivity threshold

			if (totalDifference < options.intentSensitivity) {

				tipController.showTip(element);

			} else {

				// try again

				session.previousX = session.currentX;

				session.previousY = session.currentY;

				openTooltip();

			}

		}

		/**

		 * Cancels active hover timer.

		 * @private

		 */

		function cancelTimer() {

			hoverTimer = clearTimeout(hoverTimer);

			session.delayInProgress = false;

		}

		/**

		 * Repositions the tooltip on this element.

		 * @private

		 */

		function repositionTooltip() {

			tipController.resetPosition(element);

		}

		// expose the methods

		this.show = openTooltip;

		this.hide = closeTooltip;

		this.cancel = cancelTimer;

		this.resetPosition = repositionTooltip;

	}

	/**

	 * Creates a new Placement Calculator.

	 * @private

	 * @constructor

	 */

	function PlacementCalculator() {

		/**

		 * Compute the CSS position to display a tooltip at the specified placement

		 * relative to the specified element.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 * @param {string} placement The placement for the tooltip.

		 * @param {number} tipWidth Width of the tooltip element in pixels.

		 * @param {number} tipHeight Height of the tooltip element in pixels.

		 * @param {number} offset Distance to offset tooltips in pixels.

		 * @return {CSSCoordinates} A CSSCoordinates object with the position.

		 */

		function computePlacementCoords(element, placement, tipWidth, tipHeight, offset) {

			var placementBase = placement.split('-')[0], // ignore 'alt' for corners

				coords = new CSSCoordinates(),

				position;

			if (isSvgElement(element)) {

				position = getSvgPlacement(element, placementBase);

			} else {

				position = getHtmlPlacement(element, placementBase);

			}

			// calculate the appropriate x and y position in the document

			switch (placement) {

			case 'n':

				coords.set('left', position.left - (tipWidth / 2));

				coords.set('bottom', session.windowHeight - position.top + offset);

				break;

			case 'e':

				coords.set('left', position.left + offset);

				coords.set('top', position.top - (tipHeight / 2));

				break;

			case 's':

				coords.set('left', position.left - (tipWidth / 2));

				coords.set('top', position.top + offset);

				break;

			case 'w':

				coords.set('top', position.top - (tipHeight / 2));

				coords.set('right', session.windowWidth - position.left + offset);

				break;

			case 'nw':

				coords.set('bottom', session.windowHeight - position.top + offset);

				coords.set('right', session.windowWidth - position.left - 20);

				break;

			case 'nw-alt':

				coords.set('left', position.left);

				coords.set('bottom', session.windowHeight - position.top + offset);

				break;

			case 'ne':

				coords.set('left', position.left - 20);

				coords.set('bottom', session.windowHeight - position.top + offset);

				break;

			case 'ne-alt':

				coords.set('bottom', session.windowHeight - position.top + offset);

				coords.set('right', session.windowWidth - position.left);

				break;

			case 'sw':

				coords.set('top', position.top + offset);

				coords.set('right', session.windowWidth - position.left - 20);

				break;

			case 'sw-alt':

				coords.set('left', position.left);

				coords.set('top', position.top + offset);

				break;

			case 'se':

				coords.set('left', position.left - 20);

				coords.set('top', position.top + offset);

				break;

			case 'se-alt':

				coords.set('top', position.top + offset);

				coords.set('right', session.windowWidth - position.left);

				break;

			}

			return coords;

		}

		/**

		 * Finds the tooltip attachment point in the document for a HTML DOM element

		 * for the specified placement.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 * @param {string} placement The placement for the tooltip.

		 * @return {Object} An object with the top,left position values.

		 */

		function getHtmlPlacement(element, placement) {

			var objectOffset = element.offset(),

				objectWidth = element.outerWidth(),

				objectHeight = element.outerHeight(),

				left,

				top;

			// calculate the appropriate x and y position in the document

			switch (placement) {

			case 'n':

				left = objectOffset.left + objectWidth / 2;

				top = objectOffset.top;

				break;

			case 'e':

				left = objectOffset.left + objectWidth;

				top = objectOffset.top + objectHeight / 2;

				break;

			case 's':

				left = objectOffset.left + objectWidth / 2;

				top = objectOffset.top + objectHeight;

				break;

			case 'w':

				left = objectOffset.left;

				top = objectOffset.top + objectHeight / 2;

				break;

			case 'nw':

				left = objectOffset.left;

				top = objectOffset.top;

				break;

			case 'ne':

				left = objectOffset.left + objectWidth;

				top = objectOffset.top;

				break;

			case 'sw':

				left = objectOffset.left;

				top = objectOffset.top + objectHeight;

				break;

			case 'se':

				left = objectOffset.left + objectWidth;

				top = objectOffset.top + objectHeight;

				break;

			}

			return {

				top: top,

				left: left

			};

		}

		/**

		 * Finds the tooltip attachment point in the document for a SVG element for

		 * the specified placement.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 * @param {string} placement The placement for the tooltip.

		 * @return {Object} An object with the top,left position values.

		 */

		function getSvgPlacement(element, placement) {

			var svgElement = element.closest('svg')[0],

				domElement = element[0],

				point = svgElement.createSVGPoint(),

				boundingBox = domElement.getBBox(),

				matrix = domElement.getScreenCTM(),

				halfWidth = boundingBox.width / 2,

				halfHeight = boundingBox.height / 2,

				placements = [],

				placementKeys = ['nw', 'n', 'ne', 'e', 'se', 's', 'sw', 'w'],

				coords,

				rotation,

				steps,

				x;

			function pushPlacement() {

				placements.push(point.matrixTransform(matrix));

			}

			// get bounding box corners and midpoints

			point.x = boundingBox.x;

			point.y = boundingBox.y;

			pushPlacement();

			point.x += halfWidth;

			pushPlacement();

			point.x += halfWidth;

			pushPlacement();

			point.y += halfHeight;

			pushPlacement();

			point.y += halfHeight;

			pushPlacement();

			point.x -= halfWidth;

			pushPlacement();

			point.x -= halfWidth;

			pushPlacement();

			point.y -= halfHeight;

			pushPlacement();

			// determine rotation

			if (placements[0].y !== placements[1].y || placements[0].x !== placements[7].x) {

				rotation = Math.atan2(matrix.b, matrix.a) * RAD2DEG;

				steps = Math.ceil(((rotation % 360) - 22.5) / 45);

				if (steps < 1) {

					steps += 8;

				}

				while (steps--) {

					placementKeys.push(placementKeys.shift());

				}

			}

			// find placement

			for (x = 0; x < placements.length; x++) {

				if (placementKeys[x] === placement) {

					coords = placements[x];

					break;

				}

			}

			return {

				top: coords.y + session.scrollTop,

				left: coords.x + session.scrollLeft

			};

		}

		// expose methods

		this.compute = computePlacementCoords;

	}

	/**

	 * Creates a new tooltip controller.

	 * @private

	 * @constructor

	 * @param {Object} options Options object containing settings.

	 */

	function TooltipController(options) {

		var placementCalculator = new PlacementCalculator(),

			tipElement = $('#' + options.popupId);

		// build and append tooltip div if it does not already exist

		if (tipElement.length === 0) {

			tipElement = $('
', { id: options.popupId });

			// grab body element if it was not populated when the script loaded

			// note: this hack exists solely for jsfiddle support

			if ($body.length === 0) {

				$body = $('body');

			}

			$body.append(tipElement);

		}

		// hook mousemove for cursor follow tooltips

		if (options.followMouse) {

			// only one positionTipOnCursor hook per tooltip element, please

			if (!tipElement.data(DATA_HASMOUSEMOVE)) {

				$document.on('mousemove', positionTipOnCursor);

				$window.on('scroll', positionTipOnCursor);

				tipElement.data(DATA_HASMOUSEMOVE, true);

			}

		}

		// if we want to be able to mouse onto the tooltip then we need to attach

		// hover events to the tooltip that will cancel a close request on hover and

		// start a new close request on mouseleave

		if (options.mouseOnToPopup) {

			tipElement.on({

				mouseenter: function tipMouseEnter() {

					// we only let the mouse stay on the tooltip if it is set to let

					// users interact with it

					if (tipElement.data(DATA_MOUSEONTOTIP)) {

						// check activeHover in case the mouse cursor entered the

						// tooltip during the fadeOut and close cycle

						if (session.activeHover) {

							session.activeHover.data(DATA_DISPLAYCONTROLLER).cancel();

						}

					}

				},

				mouseleave: function tipMouseLeave() {

					// check activeHover in case the mouse cursor entered the

					// tooltip during the fadeOut and close cycle

					if (session.activeHover) {

						session.activeHover.data(DATA_DISPLAYCONTROLLER).hide();

					}

				}

			});

		}

		/**

		 * Gives the specified element the active-hover state and queues up the

		 * showTip function.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 */

		function beginShowTip(element) {

			element.data(DATA_HASACTIVEHOVER, true);

			// show tooltip, asap

			tipElement.queue(function queueTipInit(next) {

				showTip(element);

				next();

			});

		}

		/**

		 * Shows the tooltip, as soon as possible.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 */

		function showTip(element) {

			var tipContent;

			// it is possible, especially with keyboard navigation, to move on to

			// another element with a tooltip during the queue to get to this point

			// in the code. if that happens then we need to not proceed or we may

			// have the fadeout callback for the last tooltip execute immediately

			// after this code runs, causing bugs.

			if (!element.data(DATA_HASACTIVEHOVER)) {

				return;

			}

			// if the tooltip is open and we got asked to open another one then the

			// old one is still in its fadeOut cycle, so wait and try again

			if (session.isTipOpen) {

				if (!session.isClosing) {

					hideTip(session.activeHover);

				}

				tipElement.delay(100).queue(function queueTipAgain(next) {

					showTip(element);

					next();

				});

				return;

			}

			// trigger powerTipPreRender event

			element.trigger('powerTipPreRender');

			// set tooltip content

			tipContent = getTooltipContent(element);

			if (tipContent) {

				tipElement.empty().append(tipContent);

			} else {

				// we have no content to display, give up

				return;

			}

			// trigger powerTipRender event

			element.trigger('powerTipRender');

			session.activeHover = element;

			session.isTipOpen = true;

			tipElement.data(DATA_MOUSEONTOTIP, options.mouseOnToPopup);

			// set tooltip position

			if (!options.followMouse) {

				positionTipOnElement(element);

				session.isFixedTipOpen = true;

			} else {

				positionTipOnCursor();

			}

			// fadein

			tipElement.fadeIn(options.fadeInTime, function fadeInCallback() {

				// start desync polling

				if (!session.desyncTimeout) {

					session.desyncTimeout = setInterval(closeDesyncedTip, 500);

				}

				// trigger powerTipOpen event

				element.trigger('powerTipOpen');

			});

		}

		/**

		 * Hides the tooltip.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 */

		function hideTip(element) {

			// reset session

			session.isClosing = true;

			session.activeHover = null;

			session.isTipOpen = false;

			// stop desync polling

			session.desyncTimeout = clearInterval(session.desyncTimeout);

			// reset element state

			element.data(DATA_HASACTIVEHOVER, false);

			element.data(DATA_FORCEDOPEN, false);

			// fade out

			tipElement.fadeOut(options.fadeOutTime, function fadeOutCallback() {

				var coords = new CSSCoordinates();

				// reset session and tooltip element

				session.isClosing = false;

				session.isFixedTipOpen = false;

				tipElement.removeClass();

				// support mouse-follow and fixed position tips at the same time by

				// moving the tooltip to the last cursor location after it is hidden

				coords.set('top', session.currentY + options.offset);

				coords.set('left', session.currentX + options.offset);

				tipElement.css(coords);

				// trigger powerTipClose event

				element.trigger('powerTipClose');

			});

		}

		/**

		 * Moves the tooltip to the users mouse cursor.

		 * @private

		 */

		function positionTipOnCursor() {

			// to support having fixed tooltips on the same page as cursor tooltips,

			// where both instances are referencing the same tooltip element, we

			// need to keep track of the mouse position constantly, but we should

			// only set the tip location if a fixed tip is not currently open, a tip

			// open is imminent or active, and the tooltip element in question does

			// have a mouse-follow using it.

			if (!session.isFixedTipOpen && (session.isTipOpen || (session.tipOpenImminent && tipElement.data(DATA_HASMOUSEMOVE)))) {

				// grab measurements

				var tipWidth = tipElement.outerWidth(),

					tipHeight = tipElement.outerHeight(),

					coords = new CSSCoordinates(),

					collisions,

					collisionCount;

				// grab collisions

				coords.set('top', session.currentY + options.offset);

				coords.set('left', session.currentX + options.offset);

				collisions = getViewportCollisions(

					coords,

					tipWidth,

					tipHeight

				);

				// handle tooltip view port collisions

				if (collisions !== Collision.none) {

					collisionCount = countFlags(collisions);

					if (collisionCount === 1) {

						// if there is only one collision (bottom or right) then

						// simply constrain the tooltip to the view port

						if (collisions === Collision.right) {

							coords.set('left', session.windowWidth - tipWidth);

						} else if (collisions === Collision.bottom) {

							coords.set('top', session.scrollTop + session.windowHeight - tipHeight);

						}

					} else {

						// if the tooltip has more than one collision then it is

						// trapped in the corner and should be flipped to get it out

						// of the users way

						coords.set('left', session.currentX - tipWidth - options.offset);

						coords.set('top', session.currentY - tipHeight - options.offset);

					}

				}

				// position the tooltip

				tipElement.css(coords);

			}

		}

		/**

		 * Sets the tooltip to the correct position relative to the specified target

		 * element. Based on options settings.

		 * @private

		 * @param {jQuery} element The element that the tooltip should target.

		 */

		function positionTipOnElement(element) {

			var priorityList,

				finalPlacement;

			if (options.smartPlacement) {

				priorityList = $.fn.powerTip.smartPlacementLists[options.placement];

				// iterate over the priority list and use the first placement option

				// that does not collide with the view port. if they all collide

				// then the last placement in the list will be used.

				$.each(priorityList, function(idx, pos) {

					// place tooltip and find collisions

					var collisions = getViewportCollisions(

						placeTooltip(element, pos),

						tipElement.outerWidth(),

						tipElement.outerHeight()