/*!

 * jquery.qtip. The jQuery tooltip plugin

 *

 * Copyright (c) 2009 Craig Thompson

 * http://craigsworks.com

 *

 * Licensed under MIT

 * http://www.opensource.org/licenses/mit-license.php

 *

 * Launch  : February 2009

 * Version : 1.0.0-rc3

 * Released: Tuesday 12th May, 2009 - 00:00

 * Debug: jquery.qtip.debug.js

 */

(function($)

{

   // Implementation

   $.fn.qtip = function(options, blanket)

   {

      var i, id, interfaces, opts, obj, command, config, api;

      // Return API / Interfaces if requested

      if(typeof options == 'string')

      {

         // Make sure API data exists if requested

         if(typeof $(this).data('qtip') !== 'object')

            $.fn.qtip.log.error.call(self, 1, $.fn.qtip.constants.NO_TOOLTIP_PRESENT, false);

         // Return requested object

         if(options == 'api')

            return $(this).data('qtip').interfaces[ $(this).data('qtip').current ];

         else if(options == 'interfaces')

            return $(this).data('qtip').interfaces;

      }

      // Validate provided options

      else

      {

         // Set null options object if no options are provided

         if(!options) options = {};

         // Sanitize option data

         if(typeof options.content !== 'object' || (options.content.jquery && options.content.length > 0)) options.content = { text: options.content };

         if(typeof options.content.title !== 'object') options.content.title = { text: options.content.title };

         if(typeof options.position !== 'object') options.position = { corner: options.position };

         if(typeof options.position.corner !== 'object') options.position.corner = { target: options.position.corner, tooltip: options.position.corner };

         if(typeof options.show !== 'object') options.show = { when: options.show };

         if(typeof options.show.when !== 'object') options.show.when = { event: options.show.when };

         if(typeof options.show.effect !== 'object') options.show.effect = { type: options.show.effect };

         if(typeof options.hide !== 'object') options.hide = { when: options.hide };

         if(typeof options.hide.when !== 'object') options.hide.when = { event: options.hide.when };

         if(typeof options.hide.effect !== 'object') options.hide.effect = { type: options.hide.effect };

         if(typeof options.style !== 'object') options.style = { name: options.style };

         options.style = sanitizeStyle(options.style);

         // Build main options object

         opts = $.extend(true, {}, $.fn.qtip.defaults, options);

         // Inherit all style properties into one syle object and include original options

         opts.style = buildStyle.call({ options: opts }, opts.style);

         opts.user = $.extend(true, {}, options);

      };

      // Iterate each matched element

      return $(this).each(function() // Return original elements as per jQuery guidelines

      {

         // Check for API commands

         if(typeof options == 'string')

         {

            command = options.toLowerCase();

            interfaces = $(this).qtip('interfaces');

            // Make sure API data exists$('.qtip').qtip('destroy')

            if(typeof interfaces == 'object')

            {

               // Check if API call is a BLANKET DESTROY command

               if(blanket === true && command == 'destroy')

                  while(interfaces.length > 0) interfaces[interfaces.length-1].destroy();

               // API call is not a BLANKET DESTROY command

               else

               {

                  // Check if supplied command effects this tooltip only (NOT BLANKET)

                  if(blanket !== true) interfaces = [ $(this).qtip('api') ];

                  // Execute command on chosen qTips

                  for(i = 0; i < interfaces.length; i++)

                  {

                     // Destroy command doesn't require tooltip to be rendered

                     if(command == 'destroy') interfaces[i].destroy();

                     // Only call API if tooltip is rendered and it wasn't a destroy call

                     else if(interfaces[i].status.rendered === true)

                     {

                        if(command == 'show') interfaces[i].show();

                        else if(command == 'hide') interfaces[i].hide();

                        else if(command == 'focus') interfaces[i].focus();

                        else if(command == 'disable') interfaces[i].disable(true);

                        else if(command == 'enable') interfaces[i].disable(false);

                     };

                  };

               };

            };

         }

         // No API commands, continue with qTip creation

         else

         {

            // Create unique configuration object

            config = $.extend(true, {}, opts);

            config.hide.effect.length = opts.hide.effect.length;

            config.show.effect.length = opts.show.effect.length;

            // Sanitize target options

            if(config.position.container === false) config.position.container = $(document.body);

            if(config.position.target === false) config.position.target = $(this);

            if(config.show.when.target === false) config.show.when.target = $(this);

            if(config.hide.when.target === false) config.hide.when.target = $(this);

            // Determine tooltip ID (Reuse array slots if possible)

            id = $.fn.qtip.interfaces.length;

            for(i = 0; i < id; i++)

            {

               if(typeof $.fn.qtip.interfaces[i] == 'undefined'){ id = i; break; };

            };

            // Instantiate the tooltip

            obj = new qTip($(this), config, id);

            // Add API references

            $.fn.qtip.interfaces[id] = obj;

            // Check if element already has qTip data assigned

            if(typeof $(this).data('qtip') == 'object')

            {

               // Set new current interface id

               if(typeof $(this).attr('qtip') === 'undefined')

                  $(this).data('qtip').current = $(this).data('qtip').interfaces.length;

               // Push new API interface onto interfaces array

               $(this).data('qtip').interfaces.push(obj);

            }

            // No qTip data is present, create now

            else $(this).data('qtip', { current: 0, interfaces: [obj] });

            // If prerendering is disabled, create tooltip on showEvent

            if(config.content.prerender === false && config.show.when.event !== false && config.show.ready !== true)

            {

               config.show.when.target.bind(config.show.when.event+'.qtip-'+id+'-create', { qtip: id }, function(event)

               {

                  // Retrieve API interface via passed qTip Id

                  api = $.fn.qtip.interfaces[ event.data.qtip ];

                  // Unbind show event and cache mouse coords

                  api.options.show.when.target.unbind(api.options.show.when.event+'.qtip-'+event.data.qtip+'-create');

                  api.cache.mouse = { x: event.pageX, y: event.pageY };

                  // Render tooltip and start the event sequence

                  construct.call( api );

                  api.options.show.when.target.trigger(api.options.show.when.event);

               });

            }

            // Prerendering is enabled, create tooltip now

            else

            {

               // Set mouse position cache to top left of the element

               obj.cache.mouse = {

                  x: config.show.when.target.offset().left,

                  y: config.show.when.target.offset().top

               };

               // Construct the tooltip

               construct.call(obj);

            }

         };

      });

   };

   // Instantiator

   function qTip(target, options, id)

   {

      // Declare this reference

      var self = this;

      // Setup class attributes

      self.id = id;

      self.options = options;

      self.status = {

         animated: false,

         rendered: false,

         disabled: false,

         focused: false

      };

      self.elements = {

         target: target.addClass(self.options.style.classes.target),

         tooltip: null,

         wrapper: null,

         content: null,

         contentWrapper: null,

         title: null,

         button: null,

         tip: null,

         bgiframe: null

      };

      self.cache = {

         mouse: {},

         position: {},

         toggle: 0

      };

      self.timers = {};

      // Define exposed API methods

      $.extend(self, self.options.api,

      {

         show: function(event)

         {

            var returned, solo;

            // Make sure tooltip is rendered and if not, return

            if(!self.status.rendered)

               return $.fn.qtip.log.error.call(self, 2, $.fn.qtip.constants.TOOLTIP_NOT_RENDERED, 'show');

            // Only continue if element is visible

            if(self.elements.tooltip.css('display') !== 'none') return self;

            // Clear animation queue

            self.elements.tooltip.stop(true, false);

            // Call API method and if return value is false, halt

            returned = self.beforeShow.call(self, event);

            if(returned === false) return self;

            // Define afterShow callback method

            function afterShow()

            {

               // Call API method and focus if it isn't static

               if(self.options.position.type !== 'static') self.focus();

               self.onShow.call(self, event);

               // Prevent antialias from disappearing in IE7 by removing filter attribute

               if($.browser.msie) self.elements.tooltip.get(0).style.removeAttribute('filter');

            };

            // Maintain toggle functionality if enabled

            self.cache.toggle = 1;

            // Update tooltip position if it isn't static

            if(self.options.position.type !== 'static')

               self.updatePosition(event, (self.options.show.effect.length > 0));

            // Hide other tooltips if tooltip is solo

            if(typeof self.options.show.solo == 'object') solo = $(self.options.show.solo);

            else if(self.options.show.solo === true) solo = $('div.qtip').not(self.elements.tooltip);

            if(solo) solo.each(function(){ if($(this).qtip('api').status.rendered === true) $(this).qtip('api').hide(); });

            // Show tooltip

            if(typeof self.options.show.effect.type == 'function')

            {

               self.options.show.effect.type.call(self.elements.tooltip, self.options.show.effect.length);

               self.elements.tooltip.queue(function(){ afterShow(); $(this).dequeue(); });

            }

            else

            {

               switch(self.options.show.effect.type.toLowerCase())

               {

                  case 'fade':

                     self.elements.tooltip.fadeIn(self.options.show.effect.length, afterShow);

                     break;

                  case 'slide':

                     self.elements.tooltip.slideDown(self.options.show.effect.length, function()

                     {

                        afterShow();

                        if(self.options.position.type !== 'static') self.updatePosition(event, true);

                     });

                     break;

                  case 'grow':

                     self.elements.tooltip.show(self.options.show.effect.length, afterShow);

                     break;

                  default:

                     self.elements.tooltip.show(null, afterShow);

                     break;

               };

               // Add active class to tooltip

               self.elements.tooltip.addClass(self.options.style.classes.active);

            };

            // Log event and return

            return $.fn.qtip.log.error.call(self, 1, $.fn.qtip.constants.EVENT_SHOWN, 'show');

         },

         hide: function(event)

         {

            var returned;

            // Make sure tooltip is rendered and if not, return

            if(!self.status.rendered)

               return $.fn.qtip.log.error.call(self, 2, $.fn.qtip.constants.TOOLTIP_NOT_RENDERED, 'hide');

            // Only continue if element is visible

            else if(self.elements.tooltip.css('display') === 'none') return self;

            // Stop show timer and animation queue

            clearTimeout(self.timers.show);

            self.elements.tooltip.stop(true, false);

            // Call API method and if return value is false, halt

            returned = self.beforeHide.call(self, event);

            if(returned === false) return self;

            // Define afterHide callback method

            function afterHide(){ self.onHide.call(self, event); };

            // Maintain toggle functionality if enabled

            self.cache.toggle = 0;

            // Hide tooltip

            if(typeof self.options.hide.effect.type == 'function')

            {

               self.options.hide.effect.type.call(self.elements.tooltip, self.options.hide.effect.length);

               self.elements.tooltip.queue(function(){ afterHide(); $(this).dequeue(); });

            }

            else

            {

               switch(self.options.hide.effect.type.toLowerCase())

               {

                  case 'fade':

                     self.elements.tooltip.fadeOut(self.options.hide.effect.length, afterHide);

                     break;

                  case 'slide':

                     self.elements.tooltip.slideUp(self.options.hide.effect.length, afterHide);

                     break;