/*
 * jQuery clueTip plugin
 * Version 1.0.5  (August 22, 2009)
 * @requires jQuery v1.2.6+
 *
 * Dual licensed under the MIT and GPL licenses:
 * http://www.opensource.org/licenses/mit-license.php
 * http://www.gnu.org/licenses/gpl.html
 *
 */
 
/*
 *
 * Full list of options/settings can be found at the bottom of this file and at http://plugins.learningjquery.com/cluetip/
 *
 * Examples can be found at http://plugins.learningjquery.com/cluetip/demo/
 *
*/

;(function($) { 
  $.cluetip = {version: '1.0.5'};
  var $cluetip, $cluetipInner, $cluetipOuter, $cluetipTitle, $cluetipArrows, $cluetipWait, $dropShadow, imgCount;
  $.fn.cluetip = function(js, options) {
	if (typeof js == 'object') {
	  options = js;
	  js = null;
	}
	if (js == 'destroy') {
	  return this.unbind('.cluetip');
	}
	return this.each(function(index) {
	  var link = this, $this = $(this);
	  
	  // support metadata plugin (v1.0 and 2.0)
	  var opts = $.extend(true, {}, $.fn.cluetip.defaults, options || {}, $.metadata ? $this.metadata() : $.meta ? $this.data() : {});

	  // start out with no contents (for ajax activation)
	  var cluetipContents = false;
	  var cluezIndex = +opts.cluezIndex;
	  $this.data('thisInfo', {title: link.title, zIndex: cluezIndex});
	  var isActive = false, closeOnDelay = 0;

	  // create the cluetip divs
	  if (!$('#cluetip').length) {
		$(['<div id="cluetip">',
		  '<div id="cluetip-outer">',
			'<h3 id="cluetip-title"></h3>',
			'<div id="cluetip-inner"></div>',
		  '</div>',
		  '<div id="cluetip-extra"></div>',
		  '<div id="cluetip-arrows" class="cluetip-arrows"></div>',
		'</div>'].join(''))
		[insertionType](insertionElement).hide();
		
		$cluetip = $('#cluetip').css({position: 'absolute'});
		$cluetipOuter = $('#cluetip-outer').css({position: 'relative', zIndex: cluezIndex});
		$cluetipInner = $('#cluetip-inner');
		$cluetipTitle = $('#cluetip-title');        
		$cluetipArrows = $('#cluetip-arrows');
		$cluetipWait = $('<div id="cluetip-waitimage"></div>')
		  .css({position: 'absolute'}).insertBefore($cluetip).hide();
	  }
	  var dropShadowSteps = (opts.dropShadow) ? +opts.dropShadowSteps : 0;
	  if (!$dropShadow) {
		$dropShadow = $([]);
		for (var i=0; i < dropShadowSteps; i++) {
		  $dropShadow = $dropShadow.add($('<div></div>').css({zIndex: cluezIndex-1, opacity:.1, top: 1+i, left: 1+i}));
		};
		$dropShadow.css({position: 'absolute', backgroundColor: '#000'})
		.prependTo($cluetip);
	  }
	  var tipAttribute = $this.attr(opts.attribute), ctClass = opts.cluetipClass;
	  if (!tipAttribute && !opts.splitTitle && !js) return true;
	  // if hideLocal is set to true, on DOM ready hide the local content that will be displayed in the clueTip
	  if (opts.local && opts.localPrefix) {tipAttribute = opts.localPrefix + tipAttribute;}
	  if (opts.local && opts.hideLocal) { $(tipAttribute + ':first').hide(); }
	  var tOffset = parseInt(opts.topOffset, 10), lOffset = parseInt(opts.leftOffset, 10);
	  // vertical measurement variables
	  var tipHeight, wHeight,
		  defHeight = isNaN(parseInt(opts.height, 10)) ? 'auto' : (/\D/g).test(opts.height) ? opts.height : opts.height + 'px';
	  var sTop, linkTop, posY, tipY, mouseY, baseline;
	  // horizontal measurement variables
	  var tipInnerWidth = parseInt(opts.width, 10) || 275,
		  tipWidth = tipInnerWidth + (parseInt($cluetip.css('paddingLeft'),10)||0) + (parseInt($cluetip.css('paddingRight'),10)||0) + dropShadowSteps,
		  linkWidth = this.offsetWidth,
		  linkLeft, posX, tipX, mouseX, winWidth;
			
	  // parse the title
	  var tipParts;
	  var tipTitle = (opts.attribute != 'title') ? $this.attr(opts.titleAttribute) : '';
	  if (opts.splitTitle) {
		if(tipTitle == undefined) {tipTitle = '';}
		tipParts = tipTitle.split(opts.splitTitle);
		tipTitle = tipParts.shift();
	  }
	  if (opts.escapeTitle) {
		tipTitle = tipTitle.replace(/&/g,'&amp;').replace(/>/g,'&gt;').replace(/</g,'&lt;');
	  }
	  
	  var localContent;
	  function returnFalse() { return false; }

/***************************************      
* ACTIVATION
****************************************/
	
//activate clueTip
	var activate = function(event) {
	  if (!opts.onActivate($this)) {
		return false;
	  }
	  isActive = true;
	  $cluetip.removeClass().css({width: tipInnerWidth});
	  if (tipAttribute == $this.attr('href')) {
		$this.css('cursor', opts.cursor);
	  }
	  if (opts.hoverClass) {
		$this.addClass(opts.hoverClass);
	  }
	  linkTop = posY = $this.offset().top;
	  linkLeft = $this.offset().left;
	  mouseX = event.pageX;
	  mouseY = event.pageY;
	  if (link.tagName.toLowerCase() != 'area') {
		sTop = $(document).scrollTop();
		winWidth = $(window).width();
	  }
// position clueTip horizontally
	  if (opts.positionBy == 'fixed') {
		posX = linkWidth + linkLeft + lOffset;
		$cluetip.css({left: posX});
	  } else {
		posX = (linkWidth > linkLeft && linkLeft > tipWidth)
		  || linkLeft + linkWidth + tipWidth + lOffset > winWidth 
		  ? linkLeft - tipWidth - lOffset 
		  : linkWidth + linkLeft + lOffset;
		if (link.tagName.toLowerCase() == 'area' || opts.positionBy == 'mouse' || linkWidth + tipWidth > winWidth) { // position by mouse
		  if (mouseX + 20 + tipWidth > winWidth) {  
			$cluetip.addClass(' cluetip-' + ctClass);
			posX = (mouseX - tipWidth - lOffset) >= 0 ? mouseX - tipWidth - lOffset - parseInt($cluetip.css('marginLeft'),10) + parseInt($cluetipInner.css('marginRight'),10) :  mouseX - (tipWidth/2);
		  } else {
			posX = mouseX + lOffset;
		  }
		}
		var pY = posX < 0 ? event.pageY + tOffset : event.pageY;
		$cluetip.css({
		  left: (posX > 0 && opts.positionBy != 'bottomTop') ? posX : (mouseX + (tipWidth/2) > winWidth) ? winWidth/2 - tipWidth/2 : Math.max(mouseX - (tipWidth/2),0),
		  zIndex: $this.data('thisInfo').zIndex
		});
		$cluetipArrows.css({zIndex: $this.data('thisInfo').zIndex+1});
	  }
		wHeight = $(window).height();

/***************************************
* load a string from cluetip method's first argument
***************************************/
	  if (js) {
		if (typeof js == 'function') {
		  js = js.call(link);
		}
		$cluetipInner.html(js);
		cluetipShow(pY);
	  }
/***************************************
* load the title attribute only (or user-selected attribute). 
* clueTip title is the string before the first delimiter
* subsequent delimiters place clueTip body text on separate lines
***************************************/

	  else if (tipParts) {
		var tpl = tipParts.length;
		$cluetipInner.html(tipParts[0]);
		if (tpl > 1) {
		  for (var i=1; i < tpl; i++){
			$cluetipInner.append('<div class="split-body">' + tipParts[i] + '</div>');
		  }          
		}
		cluetipShow(pY);
	  }
/***************************************
* load external file via ajax          
***************************************/

	  else if (!opts.local && tipAttribute.indexOf('#') != 0) {
		if (/\.(jpe?g|tiff?|gif|png)$/i.test(tipAttribute)) {
		  $cluetipInner.html('<img src="' + tipAttribute + '" alt="' + tipTitle + '" />');
		  cluetipShow(pY);
		} else if (cluetipContents && opts.ajaxCache) {
		  $cluetipInner.html(cluetipContents);
		  cluetipShow(pY);
		} else {
		  var optionBeforeSend = opts.ajaxSettings.beforeSend,
			  optionError = opts.ajaxSettings.error,
			  optionSuccess = opts.ajaxSettings.success,
			  optionComplete = opts.ajaxSettings.complete;
		  var ajaxSettings = {
			cache: false, // force requested page not to be cached by browser
			url: tipAttribute,
			beforeSend: function(xhr) {
			  if (optionBeforeSend) {optionBeforeSend.call(link, xhr, $cluetip, $cluetipInner);}
			  $cluetipOuter.children().empty();
			  if (opts.waitImage) {
				$cluetipWait
				.css({top: mouseY+20, left: mouseX+20, zIndex: $this.data('thisInfo').zIndex-1})
				.show();
			  }
			},
			error: function(xhr, textStatus) {
			  if (isActive) {
				if (optionError) {
				  optionError.call(link, xhr, textStatus, $cluetip, $cluetipInner);
				} else {
				  $cluetipInner.html('<i>sorry, the contents could not be loaded</i>');  
				}
			  }
			},
			success: function(data, textStatus) {       
			  cluetipContents = opts.ajaxProcess.call(link, data);
			  if (isActive) {
				if (optionSuccess) {optionSuccess.call(link, data, textStatus, $cluetip, $cluetipInner);}
				$cluetipInner.html(cluetipContents);
			  }
			},
			complete: function(xhr, textStatus) {
			  if (optionComplete) {optionComplete.call(link, xhr, textStatus, $cluetip, $cluetipInner);}
			  imgCount = $('#cluetip-inner img').length;
			  if (imgCount && !$.browser.opera) {
				$('#cluetip-inner img').bind('load error', function() {
				  imgCount--;
				  if (imgCount<1) {
					$cluetipWait.hide();
					if (isActive) cluetipShow(pY);
				  }
				}); 
			  } else {
				$cluetipWait.hide();
				if (isActive) { cluetipShow(pY); }
			  } 
			}
		  };
		  var ajaxMergedSettings = $.extend(true, {}, opts.ajaxSettings, ajaxSettings);
		  
		  $.ajax(ajaxMergedSettings);
		}

/***************************************
* load an element from the same page
***************************************/
	  } else if (opts.local) {
		
		var $localContent = $(tipAttribute + (/#\S+$/.test(tipAttribute) ? '' : ':eq(' + index + ')')).clone(true).show();
		$cluetipInner.html($localContent);
		cluetipShow(pY);
	  }
	};

// get dimensions and options for cluetip and prepare it to be shown
	var cluetipShow = function(bpY) {
	  $cluetip.addClass('cluetip-' + ctClass);
	  if (opts.truncate) { 
		var $truncloaded = $cluetipInner.text().slice(0,opts.truncate) + '...';
		$cluetipInner.html($truncloaded);
	  }
	  function doNothing() {}; //empty function
	  tipTitle ? $cluetipTitle.show().html(tipTitle) : (opts.showTitle) ? $cluetipTitle.show().html('&nbsp;') : $cluetipTitle.hide();
	  if (opts.sticky) {
		var $closeLink = $('<div id="cluetip-close"><a href="#">' + opts.closeText + '</a></div>');
		(opts.closePosition == 'bottom') ? $closeLink.appendTo($cluetipInner) : (opts.closePosition == 'title') ? $closeLink.prependTo($cluetipTitle) : $closeLink.prependTo($cluetipInner);
		$closeLink.bind('click.cluetip', function() {
		  cluetipClose();
		  return false;
		});
		if (opts.mouseOutClose) {
		  $cluetip.bind('mouseleave.cluetip', function() {
			cluetipClose();
		  });
		} else {
		  $cluetip.unbind('mouseleave.cluetip');
		}
	  }
// now that content is loaded, finish the positioning 
	  var direction = '';
	  $cluetipOuter.css({zIndex: $this.data('thisInfo').zIndex, overflow: defHeight == 'auto' ? 'visible' : 'auto', height: defHeight});
	  tipHeight = defHeight == 'auto' ? Math.max($cluetip.outerHeight(),$cluetip.height()) : parseInt(defHeight,10);   
	  tipY = posY;
	  baseline = sTop + wHeight;
	  if (opts.positionBy == 'fixed') {
		tipY = posY - opts.dropShadowSteps + tOffset;
	  } else if ( (posX < mouseX && Math.max(posX, 0) + tipWidth > mouseX) || opts.positionBy == 'bottomTop') {
		if (posY + tipHeight + tOffset > baseline && mouseY - sTop > tipHeight + tOffset) { 
		  tipY = mouseY - tipHeight - tOffset;
		  direction = 'top';
		} else { 
		  tipY = mouseY + tOffset;
		  direction = 'bottom';
		}
	  } else if ( posY + tipHeight + tOffset > baseline ) {
		tipY = (tipHeight >= wHeight) ? sTop : baseline - tipHeight - tOffset;
	  } else if ($this.css('display') == 'block' || link.tagName.toLowerCase() == 'area' || opts.positionBy == "mouse") {
		tipY = bpY - tOffset;
	  } else {
		tipY = posY - opts.dropShadowSteps;
	  }
	  if (direction == '') {
		posX < linkLeft ? direction = 'left' : direction = 'right';
	  }
	  $cluetip.css({top: tipY + 'px'}).removeClass().addClass('clue-' + direction + '-' + ctClass).addClass(' cluetip-' + ctClass);
	  if (opts.arrows) { // set up arrow positioning to align with element
		var bgY = (posY - tipY - opts.dropShadowSteps);
		$cluetipArrows.css({top: (/(left|right)/.test(direction) && posX >=0 && bgY > 0) ? bgY + 'px' : /(left|right)/.test(direction) ? 0 : ''}).show();
	  } else {
		$cluetipArrows.hide();
	  }

// (first hide, then) ***SHOW THE CLUETIP***
	  $dropShadow.hide();
	  $cluetip.hide()[opts.fx.open](opts.fx.open != 'show' && opts.fx.openSpeed);
	  if (opts.dropShadow) { $dropShadow.css({height: tipHeight, width: tipInnerWidth, zIndex: $this.data('thisInfo').zIndex-1}).show(); }
	  if ($.fn.bgiframe) { $cluetip.bgiframe(); }
	  // delayed close (not fully tested)
	  if (opts.delayedClose > 0) {
		closeOnDelay = setTimeout(cluetipClose, opts.delayedClose);
	  }
	  // trigger the optional onShow function
	  opts.onShow.call(link, $cluetip, $cluetipInner);
	};

/***************************************
   =INACTIVATION
-------------------------------------- */
	var inactivate = function(event) {
	  isActive = false;
	  $cluetipWait.hide();
	  if (!opts.sticky || (/click|toggle/).test(opts.activation) ) {
		cluetipClose();
		clearTimeout(closeOnDelay);        
	  };
	  if (opts.hoverClass) {
		$this.removeClass(opts.hoverClass);
	  }
	};
// close cluetip and reset some things
	var cluetipClose = function() {
	  $cluetipOuter 
	  .parent().hide().removeClass();
	  opts.onHide.call(link, $cluetip, $cluetipInner);
	  $this.removeClass('cluetip-clicked');
	  if (tipTitle) {
		$this.attr(opts.titleAttribute, tipTitle);
	  }
	  $this.css('cursor','');
	  if (opts.arrows) $cluetipArrows.css({top: ''});
	};

	$(document).bind('hideCluetip', function(e) {
	  cluetipClose();
	});
/***************************************
   =BIND EVENTS
-------------------------------------- */
  // activate by click
	  if ( (/click|toggle/).test(opts.activation) ) {
		$this.bind('click.cluetip', function(event) {
		  if ($cluetip.is(':hidden') || !$this.is('.cluetip-clicked')) {
			activate(event);
			$('.cluetip-clicked').removeClass('cluetip-clicked');
			$this.addClass('cluetip-clicked');
		  } else {
			inactivate(event);
		  }
		  this.blur();
		  return false;
		});
  // activate by focus; inactivate by blur    
	  } else if (opts.activation == 'focus') {
		$this.bind('focus.cluetip', function(event) {
		  activate(event);
		});
		$this.bind('blur.cluetip', function(event) {
		  inactivate(event);
		});
  // activate by hover
	  } else {
		// clicking is returned false if clickThrough option is set to false
		$this[opts.clickThrough ? 'unbind' : 'bind']('click', returnFalse);
		//set up mouse tracking
		var mouseTracks = function(evt) {
		  if (opts.tracking == true) {
			var trackX = posX - evt.pageX;
			var trackY = tipY ? tipY - evt.pageY : posY - evt.pageY;
			$this.bind('mousemove.cluetip', function(evt) {
			  $cluetip.css({left: evt.pageX + trackX, top: evt.pageY + trackY });
			});
		  }
		};
		if ($.fn.hoverIntent && opts.hoverIntent) {
		  $this.hoverIntent({
			sensitivity: opts.hoverIntent.sensitivity,
			interval: opts.hoverIntent.interval,  
			over: function(event) {
			  activate(event);
			  mouseTracks(event);
			}, 
			timeout: opts.hoverIntent.timeout,  
			out: function(event) {inactivate(event); $this.unbind('mousemove.cluetip');}
		  });           
		} else {
		  $this.bind('mouseenter.cluetip', function(event) {
			activate(event);
			mouseTracks(event);
		  })
		  .bind('mouseleave.cluetip', function(event) {
			inactivate(event);
			$this.unbind('mousemove.cluetip');
		  });
		}
		$this.bind('mouseover.cluetip', function(event) {
		  $this.attr('title','');
		}).bind('mouseleave.cluetip', function(event) {
		  $this.attr('title', $this.data('thisInfo').title);
		});
	  }
	});
  };
  
/*
 * options for clueTip
 *
 * each one can be explicitly overridden by changing its value. 
 * for example: $.fn.cluetip.defaults.width = 200; 
 * would change the default width for all clueTips to 200. 
 *
 * each one can also be overridden by passing an options map to the cluetip method.
 * for example: $('a.example').cluetip({width: 200}); 
 * would change the default width to 200 for clueTips invoked by a link with class of "example"
 *
 */
  
  $.fn.cluetip.defaults = {  // set up default options
	width:            275,      // The width of the clueTip
	height:           'auto',   // The height of the clueTip
	cluezIndex:       97,       // Sets the z-index style property of the clueTip
	positionBy:       'auto',   // Sets the type of positioning: 'auto', 'mouse','bottomTop', 'fixed'
	topOffset:        15,       // Number of px to offset clueTip from top of invoking element
	leftOffset:       15,       // Number of px to offset clueTip from left of invoking element
	local:            false,    // Whether to use content from the same page for the clueTip's body
	localPrefix:      null,       // string to be prepended to the tip attribute if local is true
	hideLocal:        true,     // If local option is set to true, this determines whether local content
								// to be shown in clueTip should be hidden at its original location
	attribute:        'rel',    // the attribute to be used for fetching the clueTip's body content
	titleAttribute:   'title',  // the attribute to be used for fetching the clueTip's title
	splitTitle:       '',       // A character used to split the title attribute into the clueTip title and divs
								// within the clueTip body. more info below [6]
	escapeTitle:      false,    // whether to html escape the title attribute
	showTitle:        true,     // show title bar of the clueTip, even if title attribute not set
	cluetipClass:     'default',// class added to outermost clueTip div in the form of 'cluetip-' + clueTipClass.
	hoverClass:       '',       // class applied to the invoking element onmouseover and removed onmouseout
	waitImage:        true,     // whether to show a "loading" img, which is set in jquery.cluetip.css
	cursor:           'help',
	arrows:           false,    // if true, displays arrow on appropriate side of clueTip
	dropShadow:       true,     // set to false if you don't want the drop-shadow effect on the clueTip
	dropShadowSteps:  6,        // adjusts the size of the drop shadow
	sticky:           false,    // keep visible until manually closed
	mouseOutClose:    false,    // close when clueTip is moused out
	activation:       'hover',  // set to 'click' to force user to click to show clueTip
								// set to 'focus' to show on focus of a form element and hide on blur
	clickThrough:     false,    // if true, and activation is not 'click', then clicking on link will take user to the link's href,
								// even if href and tipAttribute are equal
	tracking:         false,    // if true, clueTip will track mouse movement (experimental)
	delayedClose:     0,        // close clueTip on a timed delay (experimental)
	closePosition:    'top',    // location of close text for sticky cluetips; can be 'top' or 'bottom' or 'title'
	closeText:        'Close',  // text (or HTML) to to be clicked to close sticky clueTips
	truncate:         0,        // number of characters to truncate clueTip's contents. if 0, no truncation occurs
	
	// effect and speed for opening clueTips
	fx: {             
					  open:       'show', // can be 'show' or 'slideDown' or 'fadeIn'
					  openSpeed:  ''
	},     

	// settings for when hoverIntent plugin is used             
	hoverIntent: {    
					  sensitivity:  3,
						  interval:     50,
						  timeout:      0
	},

	// short-circuit function to run just before clueTip is shown. 
	onActivate:       function(e) {return true;},

	// function to run just after clueTip is shown. 
	onShow:           function(ct, ci){},
	// function to run just after clueTip is hidden.
	onHide:           function(ct, ci){},
	// whether to cache results of ajax request to avoid unnecessary hits to server    
	ajaxCache:        true,  

	// process data retrieved via xhr before it's displayed
	ajaxProcess:      function(data) {
						data = data.replace(/<(script|style|title)[^<]+<\/(script|style|title)>/gm, '').replace(/<(link|meta)[^>]+>/g,'');
						return data;
	},                

	// can pass in standard $.ajax() parameters. Callback functions, such as beforeSend, 
	// will be queued first within the default callbacks. 
	// The only exception is error, which overrides the default
	ajaxSettings: {
					  // error: function(ct, ci) { /* override default error callback */ }
					  // beforeSend: function(ct, ci) { /* called first within default beforeSend callback }
					  dataType: 'html'
	},
	debug: false
  };


/*
 * Global defaults for clueTips. Apply to all calls to the clueTip plugin.
 *
 * @example $.cluetip.setup({
 *   insertionType: 'prependTo',
 *   insertionElement: '#container'
 * });
 * 
 * @property
 * @name $.cluetip.setup
 * @type Map
 * @cat Plugins/tooltip
 * @option String insertionType: Default is 'appendTo'. Determines the method to be used for inserting the clueTip into the DOM. Permitted values are 'appendTo', 'prependTo', 'insertBefore', and 'insertAfter'
 * @option String insertionElement: Default is 'body'. Determines which element in the DOM the plugin will reference when inserting the clueTip.
 *
 */
   
  var insertionType = 'appendTo', insertionElement = 'body';

  $.cluetip.setup = function(options) {
	if (options && options.insertionType && (options.insertionType).match(/appendTo|prependTo|insertBefore|insertAfter/)) {
	  insertionType = options.insertionType;
	}
	if (options && options.insertionElement) {
	  insertionElement = options.insertionElement;
	}
  };
  
})(jQuery);