/*

 * jQuery clueTip plugin

 * Version 1.0.3  (May 29, 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.3'};

  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: ''})

        .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;



/***************************************      

* 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(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) {

          if ($.fn.hoverIntent && opts.hoverIntent) { 

            $cluetip.hoverIntent({

              over: doNothing, 

              timeout: opts.hoverIntent.timeout,  

              out: function() { $closeLink.trigger('click.cluetip'); }

            });

          } else {

            $cluetip.hover(doNothing, 

            function() {$closeLink.trigger('click.cluetip'); });

          }

        } else {

          $cluetip.unbind('mouseout');

        }

      }

// 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

    // clicking is returned false if cluetip url is same as href url

      } else {

        $this.bind('click.cluetip', function() {

          if ($this.attr('href') && $this.attr('href') == tipAttribute && !opts.clickThrough) {

            return false;

          }

        });

        //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');

          });

        }

        // remove default title tooltip on hover

        $this.bind('mouseenter.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:            'auto',      // 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:        25,       // Number of px to offset clueTip from top of invoking element

    leftOffset:       20,       // 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);