Changeset bde104 in indico


Ignore:
Timestamp:
04/13/12 10:13:39 (14 months ago)
Author:
Pedro Ferreira <jose.pedro.ferreira@…>
Branches:
master, hello-world-walkthrough, ipv6, v0.98-series, v0.98.2, v0.98.3, v0.99, 051b2622c51afb171a1dedb46a0df4fbb0cbd02e, 0da0c1403bae8e51d8229f460181c71b9e6dda72
Children:
1af5639
Parents:
2108190
git-author:
Pedro Ferreira <jose.pedro.ferreira@…> (04/05/12 11:46:00)
git-committer:
Pedro Ferreira <jose.pedro.ferreira@…> (04/13/12 10:13:39)
Message:

[IMP] update qTip version

Location:
indico/htdocs
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • indico/htdocs/css/jquery.qtip.css

    r683050 rbde104  
    1010*   http://en.wikipedia.org/wiki/GNU_General_Public_License 
    1111* 
    12 * Date: Fri Nov  4 13:47:48.0000000000 2011 
     12* Date: Mon Apr  2 13:46:17.0000000000 2012 
    1313*/ 
    1414 
    … …  
    2525        font-size: 10.5px; 
    2626        line-height: 12px; 
    27  
    28         z-index: 15000; 
    2927} 
    3028 
    … …  
    4139                padding: 5px 9px; 
    4240                overflow: hidden; 
    43                  
    44                 border-width: 1px; 
    45                 border-style: solid; 
    46                  
     41 
     42                border: 1px solid #000001; 
     43 
    4744                text-align: left; 
    4845                word-wrap: break-word; 
    … …  
    5552                padding: 5px 35px 5px 10px; 
    5653                overflow: hidden; 
    57                  
     54 
     55                border: 1px solid #000001; 
    5856                border-width: 1px 1px 0; 
    59                 border-style: solid; 
    6057 
    6158                font-weight: bold; 
    … …  
    558555        -ms-filter: none; 
    559556} 
     557 

  • indico/htdocs/js/jquery/jquery.qtip.js

    r683050 rbde104  
    1010*   http://en.wikipedia.org/wiki/GNU_General_Public_License 
    1111* 
    12 * Date: Fri Nov  4 13:47:48.0000000000 2011 
     12* Date: Mon Apr  2 13:46:17.0000000000 2012 
    1313*/ 
    1414 
    1515/*jslint browser: true, onevar: true, undef: true, nomen: true, bitwise: true, regexp: true, newcap: true, immed: true, strict: true */ 
    16 /*global window: false, jQuery: false, console: false */ 
    17  
    18  
    19 (function($, window, undefined) { 
     16/*global window: false, jQuery: false, console: false, define: false */ 
     17 
     18// Uses AMD or browser globals to create a jQuery plugin. 
     19(function(factory) { 
     20        if(typeof define === 'function' && define.amd) { 
     21                define(['jquery'], factory); 
     22        } 
     23        else { 
     24                factory(jQuery); 
     25        } 
     26} 
     27(function($) { 
    2028 
    2129        "use strict"; // Enable ECMAScript "strict" operation for this function. See more: http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/ 
    … …  
    2533                FALSE = false, 
    2634                NULL = null, 
     35                undefined, 
    2736                 
    2837                // Shortcut vars 
    … …  
    6978        if(!opts || 'object' !== typeof opts) { return FALSE; } 
    7079 
    71         if('object' !== typeof opts.metadata) { 
     80        if(opts.metadata === NULL || 'object' !== typeof opts.metadata) { 
    7281                opts.metadata = { 
    7382                        type: opts.metadata 
    … …  
    7685 
    7786        if('content' in opts) { 
    78                 if('object' !== typeof opts.content || opts.content.jquery) { 
     87                if(opts.content === NULL || 'object' !== typeof opts.content || opts.content.jquery) { 
    7988                        opts.content = { 
    8089                                text: opts.content 
    … …  
    8897 
    8998                if('title' in opts.content) { 
    90                         if('object' !== typeof opts.content.title) { 
     99                        if(opts.content.title === NULL || 'object' !== typeof opts.content.title) { 
    91100                                opts.content.title = { 
    92101                                        text: opts.content.title 
    … …  
    102111 
    103112        if('position' in opts) { 
    104                 if('object' !== typeof opts.position) { 
     113                if(opts.position === NULL || 'object' !== typeof opts.position) { 
    105114                        opts.position = { 
    106115                                my: opts.position, 
    … …  
    111120 
    112121        if('show' in opts) { 
    113                 if('object' !== typeof opts.show) { 
     122                if(opts.show === NULL || 'object' !== typeof opts.show) { 
    114123                        if(opts.show.jquery) { 
    115124                                opts.show = { target: opts.show }; 
    … …  
    122131 
    123132        if('hide' in opts) { 
    124                 if('object' !== typeof opts.hide) { 
     133                if(opts.hide === NULL || 'object' !== typeof opts.hide) { 
    125134                        if(opts.hide.jquery) { 
    126135                                opts.hide = { target: opts.hide }; 
    … …  
    133142 
    134143        if('style' in opts) { 
    135                 if('object' !== typeof opts.style) { 
     144                if(opts.style === NULL || 'object' !== typeof opts.style) { 
    136145                        opts.style = { 
    137146                                classes: opts.style 
    … …  
    175184                target: $(), 
    176185                disabled: FALSE, 
    177                 attr: attr 
     186                attr: attr, 
     187                onTarget: FALSE 
    178188        }; 
    179189 
    … …  
    199209                var on = options.style.widget; 
    200210 
    201                 tooltip.toggleClass(widget, on).toggleClass(defaultClass, !on); 
     211                tooltip.toggleClass(widget, on).toggleClass(defaultClass, options.style.def && !on); 
    202212                elements.content.toggleClass(widget+'-content', on); 
    203213                 
    … …  
    325335                } 
    326336 
    327                 // Remove title if callback returns false 
    328                 if(content === FALSE) { return removeTitle(FALSE); } 
     337                // Remove title if callback returns false or null/undefined (but not '') 
     338                if(content === FALSE || (!content && content !== '')) { return removeTitle(FALSE); } 
    329339 
    330340                // Append new content if its a DOM array and show it if hidden 
    … …  
    387397 
    388398                        // Find all content images without dimensions, and if no images were found, continue 
    389                         if((images = elem.find('img:not([height]):not([width])')).length === 0) { return imageLoad(); } 
     399                        if((images = elem.find('img[src]:not([height]):not([width])')).length === 0) { return imageLoad(); } 
    390400 
    391401                        // Apply timer to each image to poll for dimensions 
    … …  
    394404                                if(srcs[elem.src] !== undefined) { return; } 
    395405 
    396         // Keep track of how many times we poll for image dimensions. 
    397         // If it doesn't return in a reasonable amount of time, it's better 
    398         // to display the tooltip, rather than hold up the queue. 
    399         var iterations = 0, maxIterations = 3; 
     406                                // Keep track of how many times we poll for image dimensions. 
     407                                // If it doesn't return in a reasonable amount of time, it's better 
     408                                // to display the tooltip, rather than hold up the queue. 
     409                                var iterations = 0, maxIterations = 3; 
    400410 
    401411                                (function timer(){ 
    … …  
    403413                                        if(elem.height || elem.width || (iterations > maxIterations)) { return imageLoad(elem); } 
    404414 
    405           iterations += 1; 
    406  
    407                                         // Restart timer 
     415                                        // Increase iterations and restart timer 
     416                                        iterations += 1; 
    408417                                        self.timers.img[elem.src] = setTimeout(timer, 700); 
    409418                                }());   
    … …  
    530539                        // Hide tooltips when leaving current window/frame (but not select/option elements) 
    531540                        if(options.hide.leave === 'window') { 
    532                                 targets.window.bind('mouseout' + namespace, function(event) { 
     541                                targets.window.bind('mouseout'+namespace+' blur'+namespace, function(event) { 
    533542                                        if(/select|option/.test(event.target) && !event.relatedTarget) { self.hide(event); } 
    534543                                }); 
    … …  
    548557                // Hide tooltip on document mousedown if unfocus events are enabled 
    549558                if(('' + options.hide.event).indexOf('unfocus') > -1) { 
    550                         targets.body.bind('mousedown'+namespace, function(event) { 
    551                                 var $target = $(event.target), 
    552                                         enabled = !tooltip.hasClass(disabled) && tooltip.is(':visible'); 
    553  
    554                                 if($target[0] !== tooltip[0] && $target.parents(selector).length === 0 && $target.add(target).length > 1 && !$target.attr('disabled')) { 
     559                        posOptions.container.closest('html').bind('mousedown'+namespace, function(event) { 
     560                                var elem = $(event.target), 
     561                                        enabled = !tooltip.hasClass(disabled) && tooltip.is(':visible'), 
     562                                        isAncestor = elem.parents(selector).filter(tooltip[0]).length > 0; 
     563 
     564                                if(elem[0] !== target[0] && elem[0] !== tooltip[0] && !isAncestor && 
     565                                        !target.has(elem[0]).length && !elem.attr('disabled') 
     566                                ) { 
    555567                                        self.hide(event); 
    556568                                } 
    … …  
    621633                                // Apply a mouseleave event so we don't get problems with overlapping 
    622634                                if(options.hide.event) { 
     635                                        // Hide when we leave the tooltip and not onto the show target 
    623636                                        tooltip.bind('mouseleave'+namespace, function(event) { 
    624637                                                if((event.relatedTarget || event.target) !== targets.show[0]) { self.hide(event); } 
    625638                                        }); 
     639 
     640                                        // Track if we're on the target or not 
     641                                        elements.target.bind('mouseenter'+namespace+' mouseleave'+namespace, function(event) { 
     642                                                cache.onTarget = event.type === 'mouseenter'; 
     643                                        }); 
    626644                                } 
    627645 
    … …  
    629647                                targets.document.bind('mousemove'+namespace, function(event) { 
    630648                                        // Update the tooltip position only if the tooltip is visible and adjustment is enabled 
    631                                         if(!tooltip.hasClass(disabled) && tooltip.is(':visible')) { 
     649                                        if(cache.onTarget && !tooltip.hasClass(disabled) && tooltip.is(':visible')) { 
    632650                                                self.reposition(event || MOUSE); 
    633651                                        } 
    … …  
    753771                        tooltip = elements.tooltip = $('<div/>', { 
    754772                                        'id': tooltipID, 
    755                                         'class': uitooltip + ' qtip ui-helper-reset ' + defaultClass + ' ' + options.style.classes + ' '+ uitooltip + '-pos-' + options.position.my.abbreviation(), 
     773                                        'class': uitooltip + ' qtip ui-helper-reset ' + defaultClass + ' ' + options.style.classes + ' '+ uitooltip + '-pos-' + options.position.my.abbrev(), 
    756774                                        'width': options.style.width || '', 
    757775                                        'height': options.style.height || '', 
    … …  
    829847                                // Show tooltip if needed 
    830848                                if(options.show.ready || show) { 
    831                                         self.toggle(TRUE, cache.event); 
     849                                        self.toggle(TRUE, cache.event, FALSE); 
    832850                                } 
    833851 
    … …  
    937955                                opts = options[type], 
    938956                                visible = tooltip.is(':visible'), 
    939                                 sameTarget = !event || options[type].target.length < 2 || cache.target[0] === event.target, 
     957                                sameTarget = !event || opts.target.length < 2 || cache.target[0] === event.target, 
     958                                eventAsTarget = event && opts.target.add(event.target).length !== opts.target.length, 
    940959                                posOptions = options.position, 
    941960                                contentOptions = options.content, 
    … …  
    952971                        if(event) { 
    953972                                if((/over|enter/).test(event.type) && (/out|leave/).test(cache.event.type) && 
    954                                         event.target === options.show.target[0] && tooltip.has(event.relatedTarget).length) { 
     973                                        options.show.target.add(event.target).length === options.show.target.length && 
     974                                        tooltip.has(event.relatedTarget).length) { 
    955975                                        return self; 
    956976                                } 
    … …  
    9901010 
    9911011                                // Update the tooltip position 
    992                                 self.reposition(event); 
     1012                                self.reposition(event, arguments[2]); 
    9931013 
    9941014                                // Hide other tooltips if tooltip is solo, using it as the context 
    … …  
    10251045                                                $(opts.autofocus, tooltip).focus(); 
    10261046                                        } 
    1027  
    1028                                         // Call API method 
    1029                                         callback = $.Event('tooltipvisible'); 
    1030                                         callback.originalEvent = event ? cache.event : NULL; 
    1031                                         tooltip.trigger(callback, [self]); 
    10321047 
    10331048                                        // If set, hide tooltip when inactive for delay period 
    … …  
    10441059                                        }); 
    10451060                                } 
    1046                         } 
    1047  
    1048                         // Clear animation queue if same target 
    1049                         if(sameTarget) { tooltip.stop(0, 1); } 
     1061 
     1062                                // Call API method 
     1063                                callback = $.Event('tooltip'+(state ? 'visible' : 'hidden')); 
     1064                                callback.originalEvent = event ? cache.event : NULL; 
     1065                                tooltip.trigger(callback, [self]); 
     1066                        } 
     1067 
     1068                        // Clear/stop animation 
     1069                        tooltip.stop(eventAsTarget, !eventAsTarget); 
    10501070 
    10511071                        // If no effect type is supplied, use a simple toggle 
    … …  
    11511171                                viewport = posOptions.viewport, 
    11521172                                position = { left: 0, top: 0 }, 
     1173                                container = posOptions.container, 
    11531174                                flipoffset = FALSE, 
    11541175                                tip = self.plugins.tip, 
    … …  
    11621183                                        left: function(posLeft) { 
    11631184                                                var isShift = readjust.horizontal === 'shift', 
    1164                                                         viewportScroll = viewport.offset.left + viewport.scrollLeft, 
     1185                                                        viewportScroll = -container.offset.left + viewport.offset.left + viewport.scrollLeft, 
    11651186                                                        myWidth = my.x === 'left' ? elemWidth : my.x === 'right' ? -elemWidth : -elemWidth / 2, 
    11661187                                                        atWidth = at.x === 'left' ? targetWidth : at.x === 'right' ? -targetWidth : -targetWidth / 2, 
    … …  
    11691190                                                        overflowLeft = viewportScroll - posLeft + tipAdjust, 
    11701191                                                        overflowRight = posLeft + elemWidth - viewport.width - viewportScroll + tipAdjust, 
    1171                                                         offset = myWidth - (my.precedance === 'x' || my.x === my.y ? atWidth : 0), 
     1192                                                        offset = myWidth - (my.precedance === 'x' || my.x === my.y ? atWidth : 0) - (at.x === 'center' ? targetWidth / 2 : 0), 
    11721193                                                        isCenter = my.x === 'center'; 
    11731194 
    … …  
    11801201                                                        position.left += overflowLeft > 0 ? overflowLeft : overflowRight > 0 ? -overflowRight : 0; 
    11811202                                                        position.left = Math.max( 
    1182                                                                 viewport.offset.left + (tipAdjust && tip.corner.x === 'center' ? tip.offset : 0), 
     1203                                                                -container.offset.left + viewport.offset.left + (tipAdjust && tip.corner.x === 'center' ? tip.offset : 0), 
    11831204                                                                posLeft - offset, 
    11841205                                                                Math.min( 
    1185                                                                         Math.max(viewport.offset.left + viewport.width, posLeft + offset), 
     1206                                                                        Math.max(-container.offset.left + viewport.offset.left + viewport.width, posLeft + offset), 
    11861207                                                                        position.left 
    11871208                                                                ) 
    … …  
    12071228                                        top: function(posTop) { 
    12081229                                                var isShift = readjust.vertical === 'shift', 
    1209                                                         viewportScroll = viewport.offset.top + viewport.scrollTop, 
     1230                                                        viewportScroll = -container.offset.top + viewport.offset.top + viewport.scrollTop, 
    12101231                                                        myHeight = my.y === 'top' ? elemHeight : my.y === 'bottom' ? -elemHeight : -elemHeight / 2, 
    12111232                                                        atHeight = at.y === 'top' ? targetHeight : at.y === 'bottom' ? -targetHeight : -targetHeight / 2, 
    … …  
    12141235                                                        overflowTop = viewportScroll - posTop + tipAdjust, 
    12151236                                                        overflowBottom = posTop + elemHeight - viewport.height - viewportScroll + tipAdjust, 
    1216                                                         offset = myHeight - (my.precedance === 'y' || my.x === my.y ? atHeight : 0), 
     1237                                                        offset = myHeight - (my.precedance === 'y' || my.x === my.y ? atHeight : 0) - (at.y === 'center' ? targetHeight / 2 : 0), 
    12171238                                                        isCenter = my.y === 'center'; 
    12181239                                                         
    … …  
    12251246                                                        position.top += overflowTop > 0 ? overflowTop : overflowBottom > 0 ? -overflowBottom : 0; 
    12261247                                                        position.top = Math.max( 
    1227                                                                 viewport.offset.top + (tipAdjust && tip.corner.x === 'center' ? tip.offset : 0), 
     1248                                                                -container.offset.top + viewport.offset.top + (tipAdjust && tip.corner.x === 'center' ? tip.offset : 0), 
    12281249                                                                posTop - offset, 
    12291250                                                                Math.min( 
    1230                                                                         Math.max(viewport.offset.top + viewport.height, posTop + offset), 
     1251                                                                        Math.max(-container.offset.top + viewport.offset.top + viewport.height, posTop + offset), 
    12311252                                                                        position.top 
    12321253                                                                ) 
    … …  
    12691290                                        event && event.pageX && event.type === 'mousemove' ? event : 
    12701291                                        MOUSE && MOUSE.pageX && (adjust.mouse || !event || !event.pageX) ? { pageX: MOUSE.pageX, pageY: MOUSE.pageY } : 
    1271                                         !adjust.mouse && cache.origin && cache.origin.pageX ? cache.origin : 
     1292                                        !adjust.mouse && cache.origin && cache.origin.pageX && options.show.distance ? cache.origin : 
    12721293                                        event) || event || cache.event || MOUSE || {}; 
    12731294 
    … …  
    12871308                                        } 
    12881309                                } 
    1289                                 else { cache.target = $(target); } 
     1310                                else { 
     1311                                        target = cache.target = $(target.jquery ? target : elements.target); 
     1312                                } 
    12901313 
    12911314                                // Parse the target into a jQuery object and make sure there's an element present 
    … …  
    13001323                                        if(target[0] === window) { 
    13011324                                                position = { 
    1302                                                         top: !fixed || PLUGINS.iOS ? (viewport || target).scrollTop() : 0, 
    1303                                                         left: !fixed || PLUGINS.iOS ? (viewport || target).scrollLeft() : 0 
     1325                                                        top: (viewport || target).scrollTop(), 
     1326                                                        left: (viewport || target).scrollLeft() 
    13041327                                                }; 
    13051328                                        } 
    … …  
    13181341                                        targetHeight = target.outerHeight(); 
    13191342 
    1320                                         position = PLUGINS.offset(target, posOptions.container); 
     1343                                        position = PLUGINS.offset(target, container); 
    13211344                                } 
    13221345 
    … …  
    13561379                                        offset: viewport.offset() || { left: 0, top: 0 } 
    13571380                                }; 
     1381                                container = { 
     1382                                        elem: container, 
     1383                                        scrollLeft: container.scrollLeft(), 
     1384                                        scrollTop: container.scrollTop(), 
     1385                                        offset: container.offset() || { left: 0, top: 0 } 
     1386                                }; 
    13581387 
    13591388                                // Adjust position based onviewport and adjustment options 
    … …  
    13651394                                // Set tooltip position class 
    13661395                                if(position.adjusted.left + position.adjusted.top) { 
    1367                                         tooltip.attr('class', function(i, val) { 
    1368                                                 return val.replace(/ui-tooltip-pos-\w+/i, uitooltip + '-pos-' + my.abbreviation()); 
    1369                                         }); 
     1396                                        tooltip.attr('class', tooltip[0].className.replace(/ui-tooltip-pos-\w+/i, uitooltip + '-pos-' + my.abbrev())); 
    13701397                                } 
    13711398 
    … …  
    14811508                        // Destroy tooltip and  any associated plugins if rendered 
    14821509                        if(self.rendered) { 
    1483                                 tooltip.remove(); 
     1510                                tooltip.stop(1,0).remove(); 
    14841511                                 
    14851512                                $.each(self.plugins, function() { 
    … …  
    15681595 
    15691596        // Setup target options 
    1570         if(posOptions.container === FALSE) { posOptions.container = docBody; } 
     1597        if(!posOptions.container.length) { posOptions.container = docBody; } 
    15711598        if(posOptions.target === FALSE) { posOptions.target = newTarget; } 
    15721599        if(config.show.target === FALSE) { config.show.target = newTarget; } 
    1573         if(config.show.solo === TRUE) { config.show.solo = docBody; } 
     1600        if(config.show.solo === TRUE) { config.show.solo = posOptions.container.closest('body'); } 
    15741601        if(config.hide.target === FALSE) { config.hide.target = newTarget; } 
    15751602        if(config.position.viewport === TRUE) { config.position.viewport = posOptions.container; } 
     1603 
     1604        // Ensure we only use a single container 
     1605        posOptions.container = posOptions.container.eq(0); 
    15761606 
    15771607        // Convert position corner values into x and y strings 
    … …  
    15981628        $.data(this, 'qtip', obj); 
    15991629 
    1600         // Catch remove events on target element to destroy redundant tooltip 
    1601         elem.bind('remove.qtip-'+id, function(){ obj.destroy(); }); 
     1630        // Catch remove/removeqtip events on target element to destroy redundant tooltip 
     1631        elem.bind('remove.qtip-'+id+' removeqtip.qtip-'+id, function(){ obj.destroy(); }); 
    16021632 
    16031633        return obj; 
    … …  
    16091639        var command = ('' + options).toLowerCase(), // Parse command 
    16101640                returned = NULL, 
    1611                 args = command === 'disable' ? [TRUE] : $.makeArray(arguments).slice(1), 
     1641                args = $.makeArray(arguments).slice(1), 
    16121642                event = args[args.length - 1], 
    16131643                opts = this[0] ? $.data(this[0], 'qtip') : NULL; 
    … …  
    17001730                 * Also make sure initial mouse targetting works correctly by caching mousemove coords 
    17011731                 * on show targets before the tooltip has rendered. 
     1732                 * 
     1733                 * Also set onTarget when triggered to keep mouse tracking working 
    17021734                 */ 
    17031735                targets.show.bind('mousemove'+namespace, function(event) { 
    17041736                        MOUSE = { pageX: event.pageX, pageY: event.pageY, type: 'mousemove' }; 
     1737                        api.cache.onTarget = TRUE; 
    17051738                }); 
    17061739 
    … …  
    17491782                this.y = (corner.match(/top|bottom|center/i) || ['inherit'])[0].toLowerCase(); 
    17501783 
    1751                 this.precedance = (corner.charAt(0).search(/^(t|b)/) > -1) ? 'y' : 'x'; 
     1784                var f = corner.charAt(0); this.precedance = (f === 't' || f === 'b' ? 'y' : 'x'); 
     1785 
    17521786                this.string = function() { return this.precedance === 'y' ? this.y+this.x : this.x+this.y; }; 
    1753                 this.abbreviation = function() {  
     1787                this.abbrev = function() {  
    17541788                        var x = this.x.substr(0,1), y = this.y.substr(0,1); 
    17551789                        return x === y ? x : (x === 'c' || (x !== 'c' && y !== 'c')) ? y + x : x + y; 
    17561790                }; 
     1791 
     1792                this.clone = function() { 
     1793                        return { x: this.x, y: this.y, precedance: this.precedance, string: this.string, abbrev: this.abbrev, clone: this.clone }; 
     1794                }; 
    17571795        }, 
    17581796 
    … …  
    17601798        offset: function(elem, container) { 
    17611799                var pos = elem.offset(), 
    1762                         parent = container, 
    1763                         deep = 0, 
    1764                         docBody = document.body, 
     1800                        docBody = elem.closest('body')[0], 
     1801                        parent = container, scrolled, 
    17651802                        coffset, overflow; 
    17661803 
    … …  
    17741811                        do { 
    17751812                                if(parent.css('position') !== 'static') { 
    1776                                         coffset = parent[0] === docBody ? 
    1777                                                 { left: parseInt(parent.css('left'), 10) || 0, top: parseInt(parent.css('top'), 10) || 0 } : 
    1778                                                 parent.position(); 
    1779  
     1813                                        coffset = parent.position(); 
     1814 
     1815                                        // Account for element positioning, borders and margins 
    17801816                                        pos.left -= coffset.left + (parseInt(parent.css('borderLeftWidth'), 10) || 0) + (parseInt(parent.css('marginLeft'), 10) || 0); 
    1781                                         pos.top -= coffset.top + (parseInt(parent.css('borderTopWidth'), 10) || 0); 
    1782  
    1783                                         overflow = parent.css('overflow'); 
    1784                                         if(overflow === 'scroll' || overflow === 'auto') { deep++; } 
    1785                                 } 
    1786                                  
    1787                                 if(parent[0] === docBody) { break; } 
    1788                         } 
    1789                         while(parent = parent.offsetParent()); 
     1817                                        pos.top -= coffset.top + (parseInt(parent.css('borderTopWidth'), 10) || 0) + (parseInt(parent.css('marginTop'), 10) || 0); 
     1818 
     1819                                        // If this is the first parent element with an overflow of "scroll" or "auto", store it 
     1820                                        if(!scrolled && (overflow = parent.css('overflow')) !== 'hidden' && overflow !== 'visible') { scrolled = parent; } 
     1821                                } 
     1822                        } 
     1823                        while((parent = $(parent[0].offsetParent)).length); 
    17901824 
    17911825                        // Compensate for containers scroll if it also has an offsetParent 
    1792                         if(container[0] !== docBody && deep) { scroll( container, 1 ); } 
     1826                        if(scrolled && scrolled[0] !== docBody) { scroll( scrolled, 1 ); } 
    17931827                } 
    17941828 
    … …  
    18501884 
    18511885                        return elems; 
    1852                 }, 
    1853  
    1854                 /*  
    1855                  * Taken directly from jQuery 1.8.2 widget source code 
    1856                  * Trigger 'remove' event on all elements on removal 
    1857                  */ 
    1858                 remove: $.ui ? NULL : function( selector, keepData ) { 
    1859                         if($.ui) { return; } // We don't need to do this if jQuery UI is present! 
    1860  
    1861                         $(this).each(function() { 
    1862                                 if (!keepData) { 
    1863                                         if (!selector || $.filter( selector, [ this ] ).length) { 
    1864                                                 $('*', this).add(this).each(function() { 
    1865                                                         $(this).triggerHandler('remove'); 
    1866                                                 }); 
    1867                                         } 
    1868                                 } 
    1869                         }); 
    18701886                } 
    18711887        } 
    … …  
    18811897        }; 
    18821898}); 
     1899 
     1900/* Fire off 'removeqtip' handler in $.cleanData if jQuery UI not present (it already does similar). 
     1901 * This snippet is taken directly from jQuery UI source code found here: 
     1902 *     http://code.jquery.com/ui/jquery-ui-git.js 
     1903 */ 
     1904if(!$.ui) { 
     1905        $['cleanData'+replaceSuffix] = $.cleanData; 
     1906        $.cleanData = function( elems ) { 
     1907                for(var i = 0, elem; (elem = elems[i]) !== undefined; i++) { 
     1908                        try { $( elem ).triggerHandler('removeqtip'); } 
     1909                        catch( e ) {} 
     1910                } 
     1911                $['cleanData'+replaceSuffix]( elems ); 
     1912        }; 
     1913} 
    18831914 
    18841915// Set global qTip properties 
    … …  
    19441975                widget: FALSE, 
    19451976                width: FALSE, 
    1946                 height: FALSE 
     1977                height: FALSE, 
     1978                def: TRUE 
    19471979        }, 
    19481980        events: { 
    … …  
    19531985                toggle: NULL, 
    19541986                visible: NULL, 
     1987                hidden: NULL, 
    19551988                focus: NULL, 
    19561989                blur: NULL 
    … …  
    19651998                namespace = '.qtip-ajax', 
    19661999                rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, 
    1967                 first = TRUE; 
     2000                first = TRUE, 
     2001                destroyed = FALSE, 
     2002                xhr; 
    19682003 
    19692004        api.checks.ajax = { 
    … …  
    20052040                        // Make sure default event hasn't been prevented 
    20062041                        else if(event && event.isDefaultPrevented()) { return self; } 
     2042 
     2043                        // Cancel old request 
     2044                        if(xhr && xhr.abort) { xhr.abort(); } 
    20072045                         
    20082046                        // Check if user delcared a content selector like in .load() 
    … …  
    20142052                        // Define common after callback for both success/error handlers 
    20152053                        function after() { 
     2054                                if(destroyed) { return; } 
     2055 
    20162056                                // Re-display tip if loading and first time, and reset first flag 
    20172057                                if(hideFirst) { api.show(event.originalEvent); first = FALSE; } 
    … …  
    20232063                        // Define success handler 
    20242064                        function successHandler(content) { 
     2065                                if(destroyed) { return; } 
     2066 
    20252067                                if(selector) { 
    20262068                                        // Create a dummy div to hold the results and grab the selector element 
    … …  
    20392081 
    20402082                        // Error handler 
    2041                         function errorHandler(xh, status, error) { 
    2042                                 if (xh.status === 0) { return; } 
     2083                        function errorHandler(xhr, status, error) { 
     2084                                if (destroyed || xhr.status === 0) { return; } 
    20432085                                api.set('content.text', status + ': ' + error); 
    20442086                        } 
    20452087 
    20462088                        // Setup $.ajax option object and process the request 
    2047                         $.ajax( $.extend({ success: successHandler, error: errorHandler, context: api }, opts, { url: url, complete: after }) ); 
     2089                        xhr = $.ajax( $.extend({ success: successHandler, error: errorHandler, context: api }, opts, { url: url, complete: after }) ); 
     2090                }, 
     2091 
     2092                destroy: function() { 
     2093                        // Cancel ajax request if possible 
     2094                        if(xhr && xhr.abort) { xhr.abort(); } 
     2095 
     2096                        // Set destroyed flag 
     2097                        destroyed = TRUE; 
    20482098                } 
    20492099        }); 
    … …  
    21142164                elems = qTip.elements, 
    21152165                tooltip = elems.tooltip, 
    2116                 cache = {  
    2117                         top: 0,  
    2118                         left: 0,  
    2119                         corner: '' 
    2120                 }, 
     2166                cache = { top: 0, left: 0 }, 
    21212167                size = { 
    21222168                        width: opts.width, 
    … …  
    21672213                if(!elems.tip) { return; } 
    21682214 
    2169                 var newCorner = $.extend({}, self.corner), 
     2215                var newCorner = self.corner.clone(), 
    21702216                        adjust = pos.adjusted, 
    21712217                        method = qTip.options.position.adjust.method.split(' '), 
    … …  
    21942240 
    21952241                        // Update and redraw the tip if needed (check cached details of last drawn tip) 
    2196                         if(newCorner.string() !== cache.corner && (cache.top !== adjust.top || cache.left !== adjust.left)) { 
     2242                        if(newCorner.string() !== cache.corner.string() && (cache.top !== adjust.top || cache.left !== adjust.left)) { 
    21972243                                self.update(newCorner, FALSE); 
    21982244                        } 
    … …  
    22542300                // Cache details 
    22552301                cache.left = adjust.left; cache.top = adjust.top; 
    2256                 cache.corner = newCorner.string(); 
     2302                cache.corner = newCorner.clone(); 
    22572303        } 
    22582304 
    … …  
    23512397                        } 
    23522398 
     2399                        // Cache it 
     2400                        cache.corner = new PLUGINS.Corner( self.corner.string() ); 
     2401 
    23532402                        return self.corner.string() !== 'centercenter'; 
    23542403                }, 
    … …  
    24222471                                vml = '<vml:shape coordorigin="0,0" style="display:inline-block; position:absolute; behavior:url(#default#VML);"></vml:shape>'; 
    24232472                                elems.tip.html(vml + vml); 
     2473 
     2474                                // Prevent mousing down on the tip since it causes problems with .live() handling in IE due to VML 
     2475                                $('*', elems.tip).bind('click mousedown', function(event) { event.stopPropagation(); }); 
    24242476                        } 
    24252477                }, 
    … …  
    24382490 
    24392491                        // Re-determine tip if not already set 
    2440                         if(!corner) { corner = self.corner; } 
     2492                        if(!corner) { corner = cache.corner || self.corner; } 
    24412493 
    24422494                        // Use corner property if we detect an invalid mimic value 
    … …  
    26242676                } 
    26252677        }); 
    2626          
     2678 
    26272679        self.init(); 
    26282680} 
    … …  
    27142766 
    27152767                                // Make sure mouseout doesn't trigger a hide when showing the modal and mousing onto backdrop 
    2716                                 if(oEvent && event.type === 'tooltiphide' && /mouse(leave|enter)/.test(oEvent.type) && $(oEvent.relatedTarget).closest(overlay[0]).length) { 
    2717                                         try { event.preventDefault(); } catch(e) {} 
    2718                                 } 
    2719                                 else if(!oEvent || (oEvent && !oEvent.solo)) { 
    2720                                         self[ event.type.replace('tooltip', '') ](event, duration); 
     2768                                if(event.target === tooltip[0]) { 
     2769                                        if(oEvent && event.type === 'tooltiphide' && /mouse(leave|enter)/.test(oEvent.type) && $(oEvent.relatedTarget).closest(overlay[0]).length) { 
     2770                                                try { event.preventDefault(); } catch(e) {} 
     2771                                        } 
     2772                                        else if(!oEvent || (oEvent && !oEvent.solo)) { 
     2773                                                self[ event.type.replace('tooltip', '') ](event, duration); 
     2774                                        } 
    27212775                                } 
    27222776                        }) 
    … …  
    27252779                        .bind('tooltipfocus'+globalNamespace, function(event) { 
    27262780                                // If focus was cancelled before it reearch us, don't do anything 
    2727                                 if(event.isDefaultPrevented()) { return; } 
     2781                                if(event.isDefaultPrevented() || event.target !== tooltip[0]) { return; } 
    27282782 
    27292783                                var qtips = $(selector).filter('['+attr+']'), 
    … …  
    27552809                        // Focus any other visible modals when this one hides 
    27562810                        .bind('tooltiphide'+globalNamespace, function(event) { 
    2757                                 $('[' + attr + ']').filter(':visible').not(tooltip).last().qtip('focus', event); 
     2811                                if(event.target === tooltip[0]) { 
     2812                                        $('[' + attr + ']').filter(':visible').not(tooltip).last().qtip('focus', event); 
     2813                                } 
    27582814                        }); 
    27592815 
    … …  
    27962852 
    27972853                        // Update position on window resize or scroll 
    2798                         $(window).unbind(globalNamespace).bind('resize'+globalNamespace, function() { 
     2854                        function resize() { 
    27992855                                overlay.css({ 
    28002856                                        height: $(window).height(), 
    28012857                                        width: $(window).width() 
    28022858                                }); 
    2803                         }) 
    2804                         .triggerHandler('resize'); 
     2859                        } 
     2860                        $(window).unbind(globalNamespace).bind('resize'+globalNamespace, resize); 
     2861                        resize(); // Fire it initially too 
    28052862 
    28062863                        return overlay; 
    … …  
    29342991 
    29352992// Base z-index for all modal tooltips (use qTip core z-index as a base) 
    2936 PLUGINS.modal.zindex = QTIP.zindex -= 200; 
     2993PLUGINS.modal.zindex = QTIP.zindex + 1000; 
    29372994 
    29382995// Extend original api defaults 
    … …  
    29493006 
    29503007 
    2951 }(jQuery, window)); 
     3008})); 
Note: See TracChangeset for help on using the changeset viewer.