[Summary view] [Print] [Text view]

   1  /*!
   2   * jQuery UI Position 1.9.2
   3   * http://jqueryui.com
   4   *
   5   * Copyright 2012 jQuery Foundation and other contributors
   6   * Released under the MIT license.
   7   * http://jquery.org/license
   8   *
   9   * http://api.jqueryui.com/position/
  10   */
  11  (function( $, undefined ) {
  12  
  13  $.ui = $.ui || {};
  14  
  15  var cachedScrollbarWidth,
  16      max = Math.max,
  17      abs = Math.abs,
  18      round = Math.round,
  19      rhorizontal = /left|center|right/,
  20      rvertical = /top|center|bottom/,
  21      roffset = /[\+\-]\d+%?/,
  22      rposition = /^\w+/,
  23      rpercent = /%$/,
  24      _position = $.fn.position;
  25  
  26  function getOffsets( offsets, width, height ) {
  27      return [
  28          parseInt( offsets[ 0 ], 10 ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
  29          parseInt( offsets[ 1 ], 10 ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
  30      ];
  31  }
  32  function parseCss( element, property ) {
  33      return parseInt( $.css( element, property ), 10 ) || 0;
  34  }
  35  
  36  $.position = {
  37      scrollbarWidth: function() {
  38          if ( cachedScrollbarWidth !== undefined ) {
  39              return cachedScrollbarWidth;
  40          }
  41          var w1, w2,
  42              div = $( "<div style='display:block;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
  43              innerDiv = div.children()[0];
  44  
  45          $( "body" ).append( div );
  46          w1 = innerDiv.offsetWidth;
  47          div.css( "overflow", "scroll" );
  48  
  49          w2 = innerDiv.offsetWidth;
  50  
  51          if ( w1 === w2 ) {
  52              w2 = div[0].clientWidth;
  53          }
  54  
  55          div.remove();
  56  
  57          return (cachedScrollbarWidth = w1 - w2);
  58      },
  59      getScrollInfo: function( within ) {
  60          var overflowX = within.isWindow ? "" : within.element.css( "overflow-x" ),
  61              overflowY = within.isWindow ? "" : within.element.css( "overflow-y" ),
  62              hasOverflowX = overflowX === "scroll" ||
  63                  ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
  64              hasOverflowY = overflowY === "scroll" ||
  65                  ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
  66          return {
  67              width: hasOverflowX ? $.position.scrollbarWidth() : 0,
  68              height: hasOverflowY ? $.position.scrollbarWidth() : 0
  69          };
  70      },
  71      getWithinInfo: function( element ) {
  72          var withinElement = $( element || window ),
  73              isWindow = $.isWindow( withinElement[0] );
  74          return {
  75              element: withinElement,
  76              isWindow: isWindow,
  77              offset: withinElement.offset() || { left: 0, top: 0 },
  78              scrollLeft: withinElement.scrollLeft(),
  79              scrollTop: withinElement.scrollTop(),
  80              width: isWindow ? withinElement.width() : withinElement.outerWidth(),
  81              height: isWindow ? withinElement.height() : withinElement.outerHeight()
  82          };
  83      }
  84  };
  85  
  86  $.fn.position = function( options ) {
  87      if ( !options || !options.of ) {
  88          return _position.apply( this, arguments );
  89      }
  90  
  91      // make a copy, we don't want to modify arguments
  92      options = $.extend( {}, options );
  93  
  94      var atOffset, targetWidth, targetHeight, targetOffset, basePosition,
  95          target = $( options.of ),
  96          within = $.position.getWithinInfo( options.within ),
  97          scrollInfo = $.position.getScrollInfo( within ),
  98          targetElem = target[0],
  99          collision = ( options.collision || "flip" ).split( " " ),
 100          offsets = {};
 101  
 102      if ( targetElem.nodeType === 9 ) {
 103          targetWidth = target.width();
 104          targetHeight = target.height();
 105          targetOffset = { top: 0, left: 0 };
 106      } else if ( $.isWindow( targetElem ) ) {
 107          targetWidth = target.width();
 108          targetHeight = target.height();
 109          targetOffset = { top: target.scrollTop(), left: target.scrollLeft() };
 110      } else if ( targetElem.preventDefault ) {
 111          // force left top to allow flipping
 112          options.at = "left top";
 113          targetWidth = targetHeight = 0;
 114          targetOffset = { top: targetElem.pageY, left: targetElem.pageX };
 115      } else {
 116          targetWidth = target.outerWidth();
 117          targetHeight = target.outerHeight();
 118          targetOffset = target.offset();
 119      }
 120      // clone to reuse original targetOffset later
 121      basePosition = $.extend( {}, targetOffset );
 122  
 123      // force my and at to have valid horizontal and vertical positions
 124      // if a value is missing or invalid, it will be converted to center
 125      $.each( [ "my", "at" ], function() {
 126          var pos = ( options[ this ] || "" ).split( " " ),
 127              horizontalOffset,
 128              verticalOffset;
 129  
 130          if ( pos.length === 1) {
 131              pos = rhorizontal.test( pos[ 0 ] ) ?
 132                  pos.concat( [ "center" ] ) :
 133                  rvertical.test( pos[ 0 ] ) ?
 134                      [ "center" ].concat( pos ) :
 135                      [ "center", "center" ];
 136          }
 137          pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
 138          pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
 139  
 140          // calculate offsets
 141          horizontalOffset = roffset.exec( pos[ 0 ] );
 142          verticalOffset = roffset.exec( pos[ 1 ] );
 143          offsets[ this ] = [
 144              horizontalOffset ? horizontalOffset[ 0 ] : 0,
 145              verticalOffset ? verticalOffset[ 0 ] : 0
 146          ];
 147  
 148          // reduce to just the positions without the offsets
 149          options[ this ] = [
 150              rposition.exec( pos[ 0 ] )[ 0 ],
 151              rposition.exec( pos[ 1 ] )[ 0 ]
 152          ];
 153      });
 154  
 155      // normalize collision option
 156      if ( collision.length === 1 ) {
 157          collision[ 1 ] = collision[ 0 ];
 158      }
 159  
 160      if ( options.at[ 0 ] === "right" ) {
 161          basePosition.left += targetWidth;
 162      } else if ( options.at[ 0 ] === "center" ) {
 163          basePosition.left += targetWidth / 2;
 164      }
 165  
 166      if ( options.at[ 1 ] === "bottom" ) {
 167          basePosition.top += targetHeight;
 168      } else if ( options.at[ 1 ] === "center" ) {
 169          basePosition.top += targetHeight / 2;
 170      }
 171  
 172      atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
 173      basePosition.left += atOffset[ 0 ];
 174      basePosition.top += atOffset[ 1 ];
 175  
 176      return this.each(function() {
 177          var collisionPosition, using,
 178              elem = $( this ),
 179              elemWidth = elem.outerWidth(),
 180              elemHeight = elem.outerHeight(),
 181              marginLeft = parseCss( this, "marginLeft" ),
 182              marginTop = parseCss( this, "marginTop" ),
 183              collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
 184              collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
 185              position = $.extend( {}, basePosition ),
 186              myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
 187  
 188          if ( options.my[ 0 ] === "right" ) {
 189              position.left -= elemWidth;
 190          } else if ( options.my[ 0 ] === "center" ) {
 191              position.left -= elemWidth / 2;
 192          }
 193  
 194          if ( options.my[ 1 ] === "bottom" ) {
 195              position.top -= elemHeight;
 196          } else if ( options.my[ 1 ] === "center" ) {
 197              position.top -= elemHeight / 2;
 198          }
 199  
 200          position.left += myOffset[ 0 ];
 201          position.top += myOffset[ 1 ];
 202  
 203          // if the browser doesn't support fractions, then round for consistent results
 204          if ( !$.support.offsetFractions ) {
 205              position.left = round( position.left );
 206              position.top = round( position.top );
 207          }
 208  
 209          collisionPosition = {
 210              marginLeft: marginLeft,
 211              marginTop: marginTop
 212          };
 213  
 214          $.each( [ "left", "top" ], function( i, dir ) {
 215              if ( $.ui.position[ collision[ i ] ] ) {
 216                  $.ui.position[ collision[ i ] ][ dir ]( position, {
 217                      targetWidth: targetWidth,
 218                      targetHeight: targetHeight,
 219                      elemWidth: elemWidth,
 220                      elemHeight: elemHeight,
 221                      collisionPosition: collisionPosition,
 222                      collisionWidth: collisionWidth,
 223                      collisionHeight: collisionHeight,
 224                      offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
 225                      my: options.my,
 226                      at: options.at,
 227                      within: within,
 228                      elem : elem
 229                  });
 230              }
 231          });
 232  
 233          if ( $.fn.bgiframe ) {
 234              elem.bgiframe();
 235          }
 236  
 237          if ( options.using ) {
 238              // adds feedback as second argument to using callback, if present
 239              using = function( props ) {
 240                  var left = targetOffset.left - position.left,
 241                      right = left + targetWidth - elemWidth,
 242                      top = targetOffset.top - position.top,
 243                      bottom = top + targetHeight - elemHeight,
 244                      feedback = {
 245                          target: {
 246                              element: target,
 247                              left: targetOffset.left,
 248                              top: targetOffset.top,
 249                              width: targetWidth,
 250                              height: targetHeight
 251                          },
 252                          element: {
 253                              element: elem,
 254                              left: position.left,
 255                              top: position.top,
 256                              width: elemWidth,
 257                              height: elemHeight
 258                          },
 259                          horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
 260                          vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
 261                      };
 262                  if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
 263                      feedback.horizontal = "center";
 264                  }
 265                  if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
 266                      feedback.vertical = "middle";
 267                  }
 268                  if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
 269                      feedback.important = "horizontal";
 270                  } else {
 271                      feedback.important = "vertical";
 272                  }
 273                  options.using.call( this, props, feedback );
 274              };
 275          }
 276  
 277          elem.offset( $.extend( position, { using: using } ) );
 278      });
 279  };
 280  
 281  $.ui.position = {
 282      fit: {
 283          left: function( position, data ) {
 284              var within = data.within,
 285                  withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
 286                  outerWidth = within.width,
 287                  collisionPosLeft = position.left - data.collisionPosition.marginLeft,
 288                  overLeft = withinOffset - collisionPosLeft,
 289                  overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
 290                  newOverRight;
 291  
 292              // element is wider than within
 293              if ( data.collisionWidth > outerWidth ) {
 294                  // element is initially over the left side of within
 295                  if ( overLeft > 0 && overRight <= 0 ) {
 296                      newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
 297                      position.left += overLeft - newOverRight;
 298                  // element is initially over right side of within
 299                  } else if ( overRight > 0 && overLeft <= 0 ) {
 300                      position.left = withinOffset;
 301                  // element is initially over both left and right sides of within
 302                  } else {
 303                      if ( overLeft > overRight ) {
 304                          position.left = withinOffset + outerWidth - data.collisionWidth;
 305                      } else {
 306                          position.left = withinOffset;
 307                      }
 308                  }
 309              // too far left -> align with left edge
 310              } else if ( overLeft > 0 ) {
 311                  position.left += overLeft;
 312              // too far right -> align with right edge
 313              } else if ( overRight > 0 ) {
 314                  position.left -= overRight;
 315              // adjust based on position and margin
 316              } else {
 317                  position.left = max( position.left - collisionPosLeft, position.left );
 318              }
 319          },
 320          top: function( position, data ) {
 321              var within = data.within,
 322                  withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
 323                  outerHeight = data.within.height,
 324                  collisionPosTop = position.top - data.collisionPosition.marginTop,
 325                  overTop = withinOffset - collisionPosTop,
 326                  overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
 327                  newOverBottom;
 328  
 329              // element is taller than within
 330              if ( data.collisionHeight > outerHeight ) {
 331                  // element is initially over the top of within
 332                  if ( overTop > 0 && overBottom <= 0 ) {
 333                      newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
 334                      position.top += overTop - newOverBottom;
 335                  // element is initially over bottom of within
 336                  } else if ( overBottom > 0 && overTop <= 0 ) {
 337                      position.top = withinOffset;
 338                  // element is initially over both top and bottom of within
 339                  } else {
 340                      if ( overTop > overBottom ) {
 341                          position.top = withinOffset + outerHeight - data.collisionHeight;
 342                      } else {
 343                          position.top = withinOffset;
 344                      }
 345                  }
 346              // too far up -> align with top
 347              } else if ( overTop > 0 ) {
 348                  position.top += overTop;
 349              // too far down -> align with bottom edge
 350              } else if ( overBottom > 0 ) {
 351                  position.top -= overBottom;
 352              // adjust based on position and margin
 353              } else {
 354                  position.top = max( position.top - collisionPosTop, position.top );
 355              }
 356          }
 357      },
 358      flip: {
 359          left: function( position, data ) {
 360              var within = data.within,
 361                  withinOffset = within.offset.left + within.scrollLeft,
 362                  outerWidth = within.width,
 363                  offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
 364                  collisionPosLeft = position.left - data.collisionPosition.marginLeft,
 365                  overLeft = collisionPosLeft - offsetLeft,
 366                  overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
 367                  myOffset = data.my[ 0 ] === "left" ?
 368                      -data.elemWidth :
 369                      data.my[ 0 ] === "right" ?
 370                          data.elemWidth :
 371                          0,
 372                  atOffset = data.at[ 0 ] === "left" ?
 373                      data.targetWidth :
 374                      data.at[ 0 ] === "right" ?
 375                          -data.targetWidth :
 376                          0,
 377                  offset = -2 * data.offset[ 0 ],
 378                  newOverRight,
 379                  newOverLeft;
 380  
 381              if ( overLeft < 0 ) {
 382                  newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
 383                  if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
 384                      position.left += myOffset + atOffset + offset;
 385                  }
 386              }
 387              else if ( overRight > 0 ) {
 388                  newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
 389                  if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
 390                      position.left += myOffset + atOffset + offset;
 391                  }
 392              }
 393          },
 394          top: function( position, data ) {
 395              var within = data.within,
 396                  withinOffset = within.offset.top + within.scrollTop,
 397                  outerHeight = within.height,
 398                  offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
 399                  collisionPosTop = position.top - data.collisionPosition.marginTop,
 400                  overTop = collisionPosTop - offsetTop,
 401                  overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
 402                  top = data.my[ 1 ] === "top",
 403                  myOffset = top ?
 404                      -data.elemHeight :
 405                      data.my[ 1 ] === "bottom" ?
 406                          data.elemHeight :
 407                          0,
 408                  atOffset = data.at[ 1 ] === "top" ?
 409                      data.targetHeight :
 410                      data.at[ 1 ] === "bottom" ?
 411                          -data.targetHeight :
 412                          0,
 413                  offset = -2 * data.offset[ 1 ],
 414                  newOverTop,
 415                  newOverBottom;
 416              if ( overTop < 0 ) {
 417                  newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
 418                  if ( ( position.top + myOffset + atOffset + offset) > overTop && ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) ) {
 419                      position.top += myOffset + atOffset + offset;
 420                  }
 421              }
 422              else if ( overBottom > 0 ) {
 423                  newOverTop = position.top -  data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
 424                  if ( ( position.top + myOffset + atOffset + offset) > overBottom && ( newOverTop > 0 || abs( newOverTop ) < overBottom ) ) {
 425                      position.top += myOffset + atOffset + offset;
 426                  }
 427              }
 428          }
 429      },
 430      flipfit: {
 431          left: function() {
 432              $.ui.position.flip.left.apply( this, arguments );
 433              $.ui.position.fit.left.apply( this, arguments );
 434          },
 435          top: function() {
 436              $.ui.position.flip.top.apply( this, arguments );
 437              $.ui.position.fit.top.apply( this, arguments );
 438          }
 439      }
 440  };
 441  
 442  // fraction support test
 443  (function () {
 444      var testElement, testElementParent, testElementStyle, offsetLeft, i,
 445          body = document.getElementsByTagName( "body" )[ 0 ],
 446          div = document.createElement( "div" );
 447  
 448      //Create a "fake body" for testing based on method used in jQuery.support
 449      testElement = document.createElement( body ? "div" : "body" );
 450      testElementStyle = {
 451          visibility: "hidden",
 452          width: 0,
 453          height: 0,
 454          border: 0,
 455          margin: 0,
 456          background: "none"
 457      };
 458      if ( body ) {
 459          $.extend( testElementStyle, {
 460              position: "absolute",
 461              left: "-1000px",
 462              top: "-1000px"
 463          });
 464      }
 465      for ( i in testElementStyle ) {
 466          testElement.style[ i ] = testElementStyle[ i ];
 467      }
 468      testElement.appendChild( div );
 469      testElementParent = body || document.documentElement;
 470      testElementParent.insertBefore( testElement, testElementParent.firstChild );
 471  
 472      div.style.cssText = "position: absolute; left: 10.7432222px;";
 473  
 474      offsetLeft = $( div ).offset().left;
 475      $.support.offsetFractions = offsetLeft > 10 && offsetLeft < 11;
 476  
 477      testElement.innerHTML = "";
 478      testElementParent.removeChild( testElement );
 479  })();
 480  
 481  // DEPRECATED
 482  if ( $.uiBackCompat !== false ) {
 483      // offset option
 484      (function( $ ) {
 485          var _position = $.fn.position;
 486          $.fn.position = function( options ) {
 487              if ( !options || !options.offset ) {
 488                  return _position.call( this, options );
 489              }
 490              var offset = options.offset.split( " " ),
 491                  at = options.at.split( " " );
 492              if ( offset.length === 1 ) {
 493                  offset[ 1 ] = offset[ 0 ];
 494              }
 495              if ( /^\d/.test( offset[ 0 ] ) ) {
 496                  offset[ 0 ] = "+" + offset[ 0 ];
 497              }
 498              if ( /^\d/.test( offset[ 1 ] ) ) {
 499                  offset[ 1 ] = "+" + offset[ 1 ];
 500              }
 501              if ( at.length === 1 ) {
 502                  if ( /left|center|right/.test( at[ 0 ] ) ) {
 503                      at[ 1 ] = "center";
 504                  } else {
 505                      at[ 1 ] = at[ 0 ];
 506                      at[ 0 ] = "center";
 507                  }
 508              }
 509              return _position.call( this, $.extend( options, {
 510                  at: at[ 0 ] + offset[ 0 ] + " " + at[ 1 ] + offset[ 1 ],
 511                  offset: undefined
 512              } ) );
 513          };
 514      }( jQuery ) );
 515  }
 516  
 517  }( jQuery ) );