[Summary view] [Print] [Text view]

   1  /*!
   2   * jQuery UI Sortable 1.14.2
   3   * https://jqueryui.com
   4   *
   5   * Copyright OpenJS Foundation and other contributors
   6   * Released under the MIT license.
   7   * https://jquery.org/license
   8   */
   9  
  10  //>>label: Sortable
  11  //>>group: Interactions
  12  //>>description: Enables items in a list to be sorted using the mouse.
  13  //>>docs: https://api.jqueryui.com/sortable/
  14  //>>demos: https://jqueryui.com/sortable/
  15  //>>css.structure: ../../themes/base/sortable.css
  16  
  17  ( function( factory ) {
  18      "use strict";
  19  
  20      if ( typeof define === "function" && define.amd ) {
  21  
  22          // AMD. Register as an anonymous module.
  23          define( [
  24              "jquery",
  25              "./mouse",
  26              "../data",
  27              "../scroll-parent",
  28              "../version",
  29              "../widget"
  30          ], factory );
  31      } else {
  32  
  33          // Browser globals
  34          factory( jQuery );
  35      }
  36  } )( function( $ ) {
  37  "use strict";
  38  
  39  return $.widget( "ui.sortable", $.ui.mouse, {
  40      version: "1.14.2",
  41      widgetEventPrefix: "sort",
  42      ready: false,
  43      options: {
  44          appendTo: "parent",
  45          axis: false,
  46          connectWith: false,
  47          containment: false,
  48          cursor: "auto",
  49          cursorAt: false,
  50          dropOnEmpty: true,
  51          forcePlaceholderSize: false,
  52          forceHelperSize: false,
  53          grid: false,
  54          handle: false,
  55          helper: "original",
  56          items: "> *",
  57          opacity: false,
  58          placeholder: false,
  59          revert: false,
  60          scroll: true,
  61          scrollSensitivity: 20,
  62          scrollSpeed: 20,
  63          scope: "default",
  64          tolerance: "intersect",
  65          zIndex: 1000,
  66  
  67          // Callbacks
  68          activate: null,
  69          beforeStop: null,
  70          change: null,
  71          deactivate: null,
  72          out: null,
  73          over: null,
  74          receive: null,
  75          remove: null,
  76          sort: null,
  77          start: null,
  78          stop: null,
  79          update: null
  80      },
  81  
  82      _isOverAxis: function( x, reference, size ) {
  83          return ( x >= reference ) && ( x < ( reference + size ) );
  84      },
  85  
  86      _isFloating: function( item ) {
  87          return ( /left|right/ ).test( item.css( "float" ) ) ||
  88              ( /inline|table-cell/ ).test( item.css( "display" ) );
  89      },
  90  
  91      _create: function() {
  92          this.containerCache = {};
  93          this._addClass( "ui-sortable" );
  94  
  95          //Get the items
  96          this.refresh();
  97  
  98          //Let's determine the parent's offset
  99          this.offset = this.element.offset();
 100  
 101          //Initialize mouse events for interaction
 102          this._mouseInit();
 103  
 104          this._setHandleClassName();
 105  
 106          //We're ready to go
 107          this.ready = true;
 108  
 109      },
 110  
 111      _setOption: function( key, value ) {
 112          this._super( key, value );
 113  
 114          if ( key === "handle" ) {
 115              this._setHandleClassName();
 116          }
 117      },
 118  
 119      _setHandleClassName: function() {
 120          var that = this;
 121          this._removeClass( this.element.find( ".ui-sortable-handle" ), "ui-sortable-handle" );
 122          $.each( this.items, function() {
 123              that._addClass(
 124                  this.instance.options.handle ?
 125                      this.item.find( this.instance.options.handle ) :
 126                      this.item,
 127                  "ui-sortable-handle"
 128              );
 129          } );
 130      },
 131  
 132      _destroy: function() {
 133          this._mouseDestroy();
 134  
 135          for ( var i = this.items.length - 1; i >= 0; i-- ) {
 136              this.items[ i ].item.removeData( this.widgetName + "-item" );
 137          }
 138  
 139          return this;
 140      },
 141  
 142      _mouseCapture: function( event, overrideHandle ) {
 143          var currentItem = null,
 144              validHandle = false,
 145              that = this;
 146  
 147          if ( this.reverting ) {
 148              return false;
 149          }
 150  
 151          if ( this.options.disabled || this.options.type === "static" ) {
 152              return false;
 153          }
 154  
 155          //We have to refresh the items data once first
 156          this._refreshItems( event );
 157  
 158          //Find out if the clicked node (or one of its parents) is a actual item in this.items
 159          $( event.target ).parents().each( function() {
 160              if ( $.data( this, that.widgetName + "-item" ) === that ) {
 161                  currentItem = $( this );
 162                  return false;
 163              }
 164          } );
 165          if ( $.data( event.target, that.widgetName + "-item" ) === that ) {
 166              currentItem = $( event.target );
 167          }
 168  
 169          if ( !currentItem ) {
 170              return false;
 171          }
 172          if ( this.options.handle && !overrideHandle ) {
 173              $( this.options.handle, currentItem ).find( "*" ).addBack().each( function() {
 174                  if ( this === event.target ) {
 175                      validHandle = true;
 176                  }
 177              } );
 178              if ( !validHandle ) {
 179                  return false;
 180              }
 181          }
 182  
 183          this.currentItem = currentItem;
 184          this._removeCurrentsFromItems();
 185          return true;
 186  
 187      },
 188  
 189      _mouseStart: function( event, overrideHandle, noActivation ) {
 190  
 191          var i, body,
 192              o = this.options;
 193  
 194          this.currentContainer = this;
 195  
 196          //We only need to call refreshPositions, because the refreshItems call has been moved to
 197          // mouseCapture
 198          this.refreshPositions();
 199  
 200          //Prepare the dragged items parent
 201          this.appendTo = $( o.appendTo !== "parent" ?
 202                  o.appendTo :
 203                  this.currentItem.parent() );
 204  
 205          //Create and append the visible helper
 206          this.helper = this._createHelper( event );
 207  
 208          //Cache the helper size
 209          this._cacheHelperProportions();
 210  
 211          /*
 212           * - Position generation -
 213           * This block generates everything position related - it's the core of draggables.
 214           */
 215  
 216          //Cache the margins of the original element
 217          this._cacheMargins();
 218  
 219          //The element's absolute position on the page minus margins
 220          this.offset = this.currentItem.offset();
 221          this.offset = {
 222              top: this.offset.top - this.margins.top,
 223              left: this.offset.left - this.margins.left
 224          };
 225  
 226          $.extend( this.offset, {
 227              click: { //Where the click happened, relative to the element
 228                  left: event.pageX - this.offset.left,
 229                  top: event.pageY - this.offset.top
 230              },
 231  
 232              // This is a relative to absolute position minus the actual position calculation -
 233              // only used for relative positioned helper
 234              relative: this._getRelativeOffset()
 235          } );
 236  
 237          // After we get the helper offset, but before we get the parent offset we can
 238          // change the helper's position to absolute
 239          // TODO: Still need to figure out a way to make relative sorting possible
 240          this.helper.css( "position", "absolute" );
 241          this.cssPosition = this.helper.css( "position" );
 242  
 243          //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
 244          if ( o.cursorAt ) {
 245              this._adjustOffsetFromHelper( o.cursorAt );
 246          }
 247  
 248          //Cache the former DOM position
 249          this.domPosition = {
 250              prev: this.currentItem.prev()[ 0 ],
 251              parent: this.currentItem.parent()[ 0 ]
 252          };
 253  
 254          // If the helper is not the original, hide the original so it's not playing any role during
 255          // the drag, won't cause anything bad this way
 256          if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
 257              this.currentItem.hide();
 258          }
 259  
 260          //Create the placeholder
 261          this._createPlaceholder();
 262  
 263          //Get the next scrolling parent
 264          this.scrollParent = this.placeholder.scrollParent();
 265  
 266          $.extend( this.offset, {
 267              parent: this._getParentOffset()
 268          } );
 269  
 270          //Set a containment if given in the options
 271          if ( o.containment ) {
 272              this._setContainment();
 273          }
 274  
 275          if ( o.cursor && o.cursor !== "auto" ) { // cursor option
 276              body = this.document.find( "body" );
 277  
 278              this._storedStylesheet =
 279                  $( "<style>*{ cursor: " + o.cursor + " !important; }</style>" ).appendTo( body );
 280          }
 281  
 282          // We need to make sure to grab the zIndex before setting the
 283          // opacity, because setting the opacity to anything lower than 1
 284          // causes the zIndex to change from "auto" to 0.
 285          if ( o.zIndex ) { // zIndex option
 286              if ( this.helper.css( "zIndex" ) ) {
 287                  this._storedZIndex = this.helper.css( "zIndex" );
 288              }
 289              this.helper.css( "zIndex", o.zIndex );
 290          }
 291  
 292          if ( o.opacity ) { // opacity option
 293              if ( this.helper.css( "opacity" ) ) {
 294                  this._storedOpacity = this.helper.css( "opacity" );
 295              }
 296              this.helper.css( "opacity", o.opacity );
 297          }
 298  
 299          //Prepare scrolling
 300          if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
 301                  this.scrollParent[ 0 ].tagName !== "HTML" ) {
 302              this.overflowOffset = this.scrollParent.offset();
 303          }
 304  
 305          //Call callbacks
 306          this._trigger( "start", event, this._uiHash() );
 307  
 308          //Recache the helper size
 309          if ( !this._preserveHelperProportions ) {
 310              this._cacheHelperProportions();
 311          }
 312  
 313          //Post "activate" events to possible containers
 314          if ( !noActivation ) {
 315              for ( i = this.containers.length - 1; i >= 0; i-- ) {
 316                  this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
 317              }
 318          }
 319  
 320          //Prepare possible droppables
 321          if ( $.ui.ddmanager ) {
 322              $.ui.ddmanager.current = this;
 323          }
 324  
 325          if ( $.ui.ddmanager && !o.dropBehaviour ) {
 326              $.ui.ddmanager.prepareOffsets( this, event );
 327          }
 328  
 329          this.dragging = true;
 330  
 331          this._addClass( this.helper, "ui-sortable-helper" );
 332  
 333          //Move the helper, if needed
 334          if ( !this.helper.parent().is( this.appendTo ) ) {
 335              this.helper.detach().appendTo( this.appendTo );
 336  
 337              //Update position
 338              this.offset.parent = this._getParentOffset();
 339          }
 340  
 341          //Generate the original position
 342          this.position = this.originalPosition = this._generatePosition( event );
 343          this.originalPageX = event.pageX;
 344          this.originalPageY = event.pageY;
 345          this.lastPositionAbs = this.positionAbs = this._convertPositionTo( "absolute" );
 346  
 347          this._mouseDrag( event );
 348  
 349          return true;
 350  
 351      },
 352  
 353      _scroll: function( event ) {
 354          var o = this.options,
 355              scrolled = false;
 356  
 357          if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
 358                  this.scrollParent[ 0 ].tagName !== "HTML" ) {
 359  
 360              if ( ( this.overflowOffset.top + this.scrollParent[ 0 ].offsetHeight ) -
 361                      event.pageY < o.scrollSensitivity ) {
 362                  this.scrollParent[ 0 ].scrollTop =
 363                      scrolled = this.scrollParent[ 0 ].scrollTop + o.scrollSpeed;
 364              } else if ( event.pageY - this.overflowOffset.top < o.scrollSensitivity ) {
 365                  this.scrollParent[ 0 ].scrollTop =
 366                      scrolled = this.scrollParent[ 0 ].scrollTop - o.scrollSpeed;
 367              }
 368  
 369              if ( ( this.overflowOffset.left + this.scrollParent[ 0 ].offsetWidth ) -
 370                      event.pageX < o.scrollSensitivity ) {
 371                  this.scrollParent[ 0 ].scrollLeft = scrolled =
 372                      this.scrollParent[ 0 ].scrollLeft + o.scrollSpeed;
 373              } else if ( event.pageX - this.overflowOffset.left < o.scrollSensitivity ) {
 374                  this.scrollParent[ 0 ].scrollLeft = scrolled =
 375                      this.scrollParent[ 0 ].scrollLeft - o.scrollSpeed;
 376              }
 377  
 378          } else {
 379  
 380              if ( event.pageY - this.document.scrollTop() < o.scrollSensitivity ) {
 381                  scrolled = this.document.scrollTop( this.document.scrollTop() - o.scrollSpeed );
 382              } else if ( this.window.height() - ( event.pageY - this.document.scrollTop() ) <
 383                      o.scrollSensitivity ) {
 384                  scrolled = this.document.scrollTop( this.document.scrollTop() + o.scrollSpeed );
 385              }
 386  
 387              if ( event.pageX - this.document.scrollLeft() < o.scrollSensitivity ) {
 388                  scrolled = this.document.scrollLeft(
 389                      this.document.scrollLeft() - o.scrollSpeed
 390                  );
 391              } else if ( this.window.width() - ( event.pageX - this.document.scrollLeft() ) <
 392                      o.scrollSensitivity ) {
 393                  scrolled = this.document.scrollLeft(
 394                      this.document.scrollLeft() + o.scrollSpeed
 395                  );
 396              }
 397  
 398          }
 399  
 400          return scrolled;
 401      },
 402  
 403      _mouseDrag: function( event ) {
 404          var i, item, itemElement, intersection,
 405              o = this.options;
 406  
 407          //Compute the helpers position
 408          this.position = this._generatePosition( event );
 409          this.positionAbs = this._convertPositionTo( "absolute" );
 410  
 411          //Set the helper position
 412          if ( !this.options.axis || this.options.axis !== "y" ) {
 413              this.helper[ 0 ].style.left = this.position.left + "px";
 414          }
 415          if ( !this.options.axis || this.options.axis !== "x" ) {
 416              this.helper[ 0 ].style.top = this.position.top + "px";
 417          }
 418  
 419          //Do scrolling
 420          if ( o.scroll ) {
 421              if ( this._scroll( event ) !== false ) {
 422  
 423                  //Update item positions used in position checks
 424                  this._refreshItemPositions( true );
 425  
 426                  if ( $.ui.ddmanager && !o.dropBehaviour ) {
 427                      $.ui.ddmanager.prepareOffsets( this, event );
 428                  }
 429              }
 430          }
 431  
 432          this.dragDirection = {
 433              vertical: this._getDragVerticalDirection(),
 434              horizontal: this._getDragHorizontalDirection()
 435          };
 436  
 437          //Rearrange
 438          for ( i = this.items.length - 1; i >= 0; i-- ) {
 439  
 440              //Cache variables and intersection, continue if no intersection
 441              item = this.items[ i ];
 442              itemElement = item.item[ 0 ];
 443              intersection = this._intersectsWithPointer( item );
 444              if ( !intersection ) {
 445                  continue;
 446              }
 447  
 448              // Only put the placeholder inside the current Container, skip all
 449              // items from other containers. This works because when moving
 450              // an item from one container to another the
 451              // currentContainer is switched before the placeholder is moved.
 452              //
 453              // Without this, moving items in "sub-sortables" can cause
 454              // the placeholder to jitter between the outer and inner container.
 455              if ( item.instance !== this.currentContainer ) {
 456                  continue;
 457              }
 458  
 459              // Cannot intersect with itself
 460              // no useless actions that have been done before
 461              // no action if the item moved is the parent of the item checked
 462              if ( itemElement !== this.currentItem[ 0 ] &&
 463                  this.placeholder[ intersection === 1 ?
 464                  "next" : "prev" ]()[ 0 ] !== itemElement &&
 465                  !$.contains( this.placeholder[ 0 ], itemElement ) &&
 466                  ( this.options.type === "semi-dynamic" ?
 467                      !$.contains( this.element[ 0 ], itemElement ) :
 468                      true
 469                  )
 470              ) {
 471  
 472                  this.direction = intersection === 1 ? "down" : "up";
 473  
 474                  if ( this.options.tolerance === "pointer" ||
 475                          this._intersectsWithSides( item ) ) {
 476                      this._rearrange( event, item );
 477                  } else {
 478                      break;
 479                  }
 480  
 481                  this._trigger( "change", event, this._uiHash() );
 482                  break;
 483              }
 484          }
 485  
 486          //Post events to containers
 487          this._contactContainers( event );
 488  
 489          //Interconnect with droppables
 490          if ( $.ui.ddmanager ) {
 491              $.ui.ddmanager.drag( this, event );
 492          }
 493  
 494          //Call callbacks
 495          this._trigger( "sort", event, this._uiHash() );
 496  
 497          this.lastPositionAbs = this.positionAbs;
 498          return false;
 499  
 500      },
 501  
 502      _mouseStop: function( event, noPropagation ) {
 503  
 504          if ( !event ) {
 505              return;
 506          }
 507  
 508          //If we are using droppables, inform the manager about the drop
 509          if ( $.ui.ddmanager && !this.options.dropBehaviour ) {
 510              $.ui.ddmanager.drop( this, event );
 511          }
 512  
 513          if ( this.options.revert ) {
 514              var that = this,
 515                  cur = this.placeholder.offset(),
 516                  axis = this.options.axis,
 517                  animation = {};
 518  
 519              if ( !axis || axis === "x" ) {
 520                  animation.left = cur.left - this.offset.parent.left - this.margins.left +
 521                      ( this.offsetParent[ 0 ] === this.document[ 0 ].body ?
 522                          0 :
 523                          this.offsetParent[ 0 ].scrollLeft
 524                      );
 525              }
 526              if ( !axis || axis === "y" ) {
 527                  animation.top = cur.top - this.offset.parent.top - this.margins.top +
 528                      ( this.offsetParent[ 0 ] === this.document[ 0 ].body ?
 529                          0 :
 530                          this.offsetParent[ 0 ].scrollTop
 531                      );
 532              }
 533              this.reverting = true;
 534              $( this.helper ).animate(
 535                  animation,
 536                  parseInt( this.options.revert, 10 ) || 500,
 537                  function() {
 538                      that._clear( event );
 539                  }
 540              );
 541          } else {
 542              this._clear( event, noPropagation );
 543          }
 544  
 545          return false;
 546  
 547      },
 548  
 549      cancel: function() {
 550  
 551          if ( this.dragging ) {
 552  
 553              this._mouseUp( new $.Event( "mouseup", { target: null } ) );
 554  
 555              if ( this.options.helper === "original" ) {
 556                  this.currentItem.css( this._storedCSS );
 557                  this._removeClass( this.currentItem, "ui-sortable-helper" );
 558              } else {
 559                  this.currentItem.show();
 560              }
 561  
 562              //Post deactivating events to containers
 563              for ( var i = this.containers.length - 1; i >= 0; i-- ) {
 564                  this.containers[ i ]._trigger( "deactivate", null, this._uiHash( this ) );
 565                  if ( this.containers[ i ].containerCache.over ) {
 566                      this.containers[ i ]._trigger( "out", null, this._uiHash( this ) );
 567                      this.containers[ i ].containerCache.over = 0;
 568                  }
 569              }
 570  
 571          }
 572  
 573          if ( this.placeholder ) {
 574  
 575              //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately,
 576              // it unbinds ALL events from the original node!
 577              if ( this.placeholder[ 0 ].parentNode ) {
 578                  this.placeholder[ 0 ].parentNode.removeChild( this.placeholder[ 0 ] );
 579              }
 580              if ( this.options.helper !== "original" && this.helper &&
 581                      this.helper[ 0 ].parentNode ) {
 582                  this.helper.remove();
 583              }
 584  
 585              $.extend( this, {
 586                  helper: null,
 587                  dragging: false,
 588                  reverting: false,
 589                  _noFinalSort: null
 590              } );
 591  
 592              if ( this.domPosition.prev ) {
 593                  $( this.domPosition.prev ).after( this.currentItem );
 594              } else {
 595                  $( this.domPosition.parent ).prepend( this.currentItem );
 596              }
 597          }
 598  
 599          return this;
 600  
 601      },
 602  
 603      serialize: function( o ) {
 604  
 605          var items = this._getItemsAsjQuery( o && o.connected ),
 606              str = [];
 607          o = o || {};
 608  
 609          $( items ).each( function() {
 610              var res = ( $( o.item || this ).attr( o.attribute || "id" ) || "" )
 611                  .match( o.expression || ( /(.+)[\-=_](.+)/ ) );
 612              if ( res ) {
 613                  str.push(
 614                      ( o.key || res[ 1 ] + "[]" ) +
 615                      "=" + ( o.key && o.expression ? res[ 1 ] : res[ 2 ] ) );
 616              }
 617          } );
 618  
 619          if ( !str.length && o.key ) {
 620              str.push( o.key + "=" );
 621          }
 622  
 623          return str.join( "&" );
 624  
 625      },
 626  
 627      toArray: function( o ) {
 628  
 629          var items = this._getItemsAsjQuery( o && o.connected ),
 630              ret = [];
 631  
 632          o = o || {};
 633  
 634          items.each( function() {
 635              ret.push( $( o.item || this ).attr( o.attribute || "id" ) || "" );
 636          } );
 637          return ret;
 638  
 639      },
 640  
 641      /* Be careful with the following core functions */
 642      _intersectsWith: function( item ) {
 643  
 644          var x1 = this.positionAbs.left,
 645              x2 = x1 + this.helperProportions.width,
 646              y1 = this.positionAbs.top,
 647              y2 = y1 + this.helperProportions.height,
 648              l = item.left,
 649              r = l + item.width,
 650              t = item.top,
 651              b = t + item.height,
 652              dyClick = this.offset.click.top,
 653              dxClick = this.offset.click.left,
 654              isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t &&
 655                  ( y1 + dyClick ) < b ),
 656              isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l &&
 657                  ( x1 + dxClick ) < r ),
 658              isOverElement = isOverElementHeight && isOverElementWidth;
 659  
 660          if ( this.options.tolerance === "pointer" ||
 661              this.options.forcePointerForContainers ||
 662              ( this.options.tolerance !== "pointer" &&
 663                  this.helperProportions[ this.floating ? "width" : "height" ] >
 664                  item[ this.floating ? "width" : "height" ] )
 665          ) {
 666              return isOverElement;
 667          } else {
 668  
 669              return ( l < x1 + ( this.helperProportions.width / 2 ) && // Right Half
 670                  x2 - ( this.helperProportions.width / 2 ) < r && // Left Half
 671                  t < y1 + ( this.helperProportions.height / 2 ) && // Bottom Half
 672                  y2 - ( this.helperProportions.height / 2 ) < b ); // Top Half
 673  
 674          }
 675      },
 676  
 677      _intersectsWithPointer: function( item ) {
 678          var verticalDirection, horizontalDirection,
 679              isOverElementHeight = ( this.options.axis === "x" ) ||
 680                  this._isOverAxis(
 681                      this.positionAbs.top + this.offset.click.top, item.top, item.height ),
 682              isOverElementWidth = ( this.options.axis === "y" ) ||
 683                  this._isOverAxis(
 684                      this.positionAbs.left + this.offset.click.left, item.left, item.width ),
 685              isOverElement = isOverElementHeight && isOverElementWidth;
 686  
 687          if ( !isOverElement ) {
 688              return false;
 689          }
 690  
 691          verticalDirection = this.dragDirection.vertical;
 692          horizontalDirection = this.dragDirection.horizontal;
 693  
 694          return this.floating ?
 695              ( ( horizontalDirection === "right" || verticalDirection === "down" ) ? 2 : 1 ) :
 696              ( verticalDirection && ( verticalDirection === "down" ? 2 : 1 ) );
 697  
 698      },
 699  
 700      _intersectsWithSides: function( item ) {
 701  
 702          var isOverBottomHalf = this._isOverAxis( this.positionAbs.top +
 703                  this.offset.click.top, item.top + ( item.height / 2 ), item.height ),
 704              isOverRightHalf = this._isOverAxis( this.positionAbs.left +
 705                  this.offset.click.left, item.left + ( item.width / 2 ), item.width ),
 706              verticalDirection = this.dragDirection.vertical,
 707              horizontalDirection = this.dragDirection.horizontal;
 708  
 709          if ( this.floating && horizontalDirection ) {
 710              return ( ( horizontalDirection === "right" && isOverRightHalf ) ||
 711                  ( horizontalDirection === "left" && !isOverRightHalf ) );
 712          } else {
 713              return verticalDirection && ( ( verticalDirection === "down" && isOverBottomHalf ) ||
 714                  ( verticalDirection === "up" && !isOverBottomHalf ) );
 715          }
 716  
 717      },
 718  
 719      _getDragVerticalDirection: function() {
 720          var delta = this.positionAbs.top - this.lastPositionAbs.top;
 721          return delta !== 0 && ( delta > 0 ? "down" : "up" );
 722      },
 723  
 724      _getDragHorizontalDirection: function() {
 725          var delta = this.positionAbs.left - this.lastPositionAbs.left;
 726          return delta !== 0 && ( delta > 0 ? "right" : "left" );
 727      },
 728  
 729      refresh: function( event ) {
 730          this._refreshItems( event );
 731          this._setHandleClassName();
 732          this.refreshPositions();
 733          return this;
 734      },
 735  
 736      _connectWith: function() {
 737          var options = this.options;
 738          return options.connectWith.constructor === String ?
 739              [ options.connectWith ] :
 740              options.connectWith;
 741      },
 742  
 743      _getItemsAsjQuery: function( connected ) {
 744  
 745          var i, j, cur, inst,
 746              items = [],
 747              queries = [],
 748              connectWith = this._connectWith();
 749  
 750          if ( connectWith && connected ) {
 751              for ( i = connectWith.length - 1; i >= 0; i-- ) {
 752                  cur = $( connectWith[ i ], this.document[ 0 ] );
 753                  for ( j = cur.length - 1; j >= 0; j-- ) {
 754                      inst = $.data( cur[ j ], this.widgetFullName );
 755                      if ( inst && inst !== this && !inst.options.disabled ) {
 756                          queries.push( [ typeof inst.options.items === "function" ?
 757                              inst.options.items.call( inst.element ) :
 758                              $( inst.options.items, inst.element )
 759                                  .not( ".ui-sortable-helper" )
 760                                  .not( ".ui-sortable-placeholder" ), inst ] );
 761                      }
 762                  }
 763              }
 764          }
 765  
 766          queries.push( [ typeof this.options.items === "function" ?
 767              this.options.items
 768                  .call( this.element, null, { options: this.options, item: this.currentItem } ) :
 769              $( this.options.items, this.element )
 770                  .not( ".ui-sortable-helper" )
 771                  .not( ".ui-sortable-placeholder" ), this ] );
 772  
 773  		function addItems() {
 774              items.push( this );
 775          }
 776          for ( i = queries.length - 1; i >= 0; i-- ) {
 777              queries[ i ][ 0 ].each( addItems );
 778          }
 779  
 780          return $( items );
 781  
 782      },
 783  
 784      _removeCurrentsFromItems: function() {
 785  
 786          var list = this.currentItem.find( ":data(" + this.widgetName + "-item)" );
 787  
 788          this.items = $.grep( this.items, function( item ) {
 789              for ( var j = 0; j < list.length; j++ ) {
 790                  if ( list[ j ] === item.item[ 0 ] ) {
 791                      return false;
 792                  }
 793              }
 794              return true;
 795          } );
 796  
 797      },
 798  
 799      _refreshItems: function( event ) {
 800  
 801          this.items = [];
 802          this.containers = [ this ];
 803  
 804          var i, j, cur, inst, targetData, _queries, item, queriesLength,
 805              items = this.items,
 806              queries = [ [ typeof this.options.items === "function" ?
 807                  this.options.items.call( this.element[ 0 ], event, { item: this.currentItem } ) :
 808                  $( this.options.items, this.element ), this ] ],
 809              connectWith = this._connectWith();
 810  
 811          //Shouldn't be run the first time through due to massive slow-down
 812          if ( connectWith && this.ready ) {
 813              for ( i = connectWith.length - 1; i >= 0; i-- ) {
 814                  cur = $( connectWith[ i ], this.document[ 0 ] );
 815                  for ( j = cur.length - 1; j >= 0; j-- ) {
 816                      inst = $.data( cur[ j ], this.widgetFullName );
 817                      if ( inst && inst !== this && !inst.options.disabled ) {
 818                          queries.push( [ typeof inst.options.items === "function" ?
 819                              inst.options.items
 820                                  .call( inst.element[ 0 ], event, { item: this.currentItem } ) :
 821                              $( inst.options.items, inst.element ), inst ] );
 822                          this.containers.push( inst );
 823                      }
 824                  }
 825              }
 826          }
 827  
 828          for ( i = queries.length - 1; i >= 0; i-- ) {
 829              targetData = queries[ i ][ 1 ];
 830              _queries = queries[ i ][ 0 ];
 831  
 832              for ( j = 0, queriesLength = _queries.length; j < queriesLength; j++ ) {
 833                  item = $( _queries[ j ] );
 834  
 835                  // Data for target checking (mouse manager)
 836                  item.data( this.widgetName + "-item", targetData );
 837  
 838                  items.push( {
 839                      item: item,
 840                      instance: targetData,
 841                      width: 0, height: 0,
 842                      left: 0, top: 0
 843                  } );
 844              }
 845          }
 846  
 847      },
 848  
 849      _refreshItemPositions: function( fast ) {
 850          var i, item, t, p;
 851  
 852          for ( i = this.items.length - 1; i >= 0; i-- ) {
 853              item = this.items[ i ];
 854  
 855              //We ignore calculating positions of all connected containers when we're not over them
 856              if ( this.currentContainer && item.instance !== this.currentContainer &&
 857                      item.item[ 0 ] !== this.currentItem[ 0 ] ) {
 858                  continue;
 859              }
 860  
 861              t = this.options.toleranceElement ?
 862                  $( this.options.toleranceElement, item.item ) :
 863                  item.item;
 864  
 865              if ( !fast ) {
 866                  item.width = t.outerWidth();
 867                  item.height = t.outerHeight();
 868              }
 869  
 870              p = t.offset();
 871              item.left = p.left;
 872              item.top = p.top;
 873          }
 874      },
 875  
 876      refreshPositions: function( fast ) {
 877  
 878          // Determine whether items are being displayed horizontally
 879          this.floating = this.items.length ?
 880              this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
 881              false;
 882  
 883          // This has to be redone because due to the item being moved out/into the offsetParent,
 884          // the offsetParent's position will change
 885          if ( this.offsetParent && this.helper ) {
 886              this.offset.parent = this._getParentOffset();
 887          }
 888  
 889          this._refreshItemPositions( fast );
 890  
 891          var i, p;
 892  
 893          if ( this.options.custom && this.options.custom.refreshContainers ) {
 894              this.options.custom.refreshContainers.call( this );
 895          } else {
 896              for ( i = this.containers.length - 1; i >= 0; i-- ) {
 897                  p = this.containers[ i ].element.offset();
 898                  this.containers[ i ].containerCache.left = p.left;
 899                  this.containers[ i ].containerCache.top = p.top;
 900                  this.containers[ i ].containerCache.width =
 901                      this.containers[ i ].element.outerWidth();
 902                  this.containers[ i ].containerCache.height =
 903                      this.containers[ i ].element.outerHeight();
 904              }
 905          }
 906  
 907          return this;
 908      },
 909  
 910      _createPlaceholder: function( that ) {
 911          that = that || this;
 912          var className, nodeName,
 913              o = that.options;
 914  
 915          if ( !o.placeholder || o.placeholder.constructor === String ) {
 916              className = o.placeholder;
 917              nodeName = that.currentItem[ 0 ].nodeName.toLowerCase();
 918              o.placeholder = {
 919                  element: function() {
 920  
 921                      var element = $( "<" + nodeName + ">", that.document[ 0 ] );
 922  
 923                      that._addClass( element, "ui-sortable-placeholder",
 924                              className || that.currentItem[ 0 ].className )
 925                          ._removeClass( element, "ui-sortable-helper" );
 926  
 927                      if ( nodeName === "tbody" ) {
 928                          that._createTrPlaceholder(
 929                              that.currentItem.find( "tr" ).eq( 0 ),
 930                              $( "<tr>", that.document[ 0 ] ).appendTo( element )
 931                          );
 932                      } else if ( nodeName === "tr" ) {
 933                          that._createTrPlaceholder( that.currentItem, element );
 934                      } else if ( nodeName === "img" ) {
 935                          element.attr( "src", that.currentItem.attr( "src" ) );
 936                      }
 937  
 938                      if ( !className ) {
 939                          element.css( "visibility", "hidden" );
 940                      }
 941  
 942                      return element;
 943                  },
 944                  update: function( container, p ) {
 945  
 946                      // 1. If a className is set as 'placeholder option, we don't force sizes -
 947                      // the class is responsible for that
 948                      // 2. The option 'forcePlaceholderSize can be enabled to force it even if a
 949                      // class name is specified
 950                      if ( className && !o.forcePlaceholderSize ) {
 951                          return;
 952                      }
 953  
 954                      // If the element doesn't have a actual height or width by itself (without
 955                      // styles coming from a stylesheet), it receives the inline height and width
 956                      // from the dragged item. Or, if it's a tbody or tr, it's going to have a height
 957                      // anyway since we're populating them with <td>s above, but they're unlikely to
 958                      // be the correct height on their own if the row heights are dynamic, so we'll
 959                      // always assign the height of the dragged item given forcePlaceholderSize
 960                      // is true.
 961                      if ( !p.height() || ( o.forcePlaceholderSize &&
 962                              ( nodeName === "tbody" || nodeName === "tr" ) ) ) {
 963                          p.height(
 964                              that.currentItem.innerHeight() -
 965                              parseInt( that.currentItem.css( "paddingTop" ) || 0, 10 ) -
 966                              parseInt( that.currentItem.css( "paddingBottom" ) || 0, 10 ) );
 967                      }
 968                      if ( !p.width() ) {
 969                          p.width(
 970                              that.currentItem.innerWidth() -
 971                              parseInt( that.currentItem.css( "paddingLeft" ) || 0, 10 ) -
 972                              parseInt( that.currentItem.css( "paddingRight" ) || 0, 10 ) );
 973                      }
 974                  }
 975              };
 976          }
 977  
 978          //Create the placeholder
 979          that.placeholder = $( o.placeholder.element.call( that.element, that.currentItem ) );
 980  
 981          //Append it after the actual current item
 982          that.currentItem.after( that.placeholder );
 983  
 984          //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
 985          o.placeholder.update( that, that.placeholder );
 986  
 987      },
 988  
 989      _createTrPlaceholder: function( sourceTr, targetTr ) {
 990          var that = this;
 991  
 992          sourceTr.children().each( function() {
 993              $( "<td>&#160;</td>", that.document[ 0 ] )
 994                  .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
 995                  .appendTo( targetTr );
 996          } );
 997      },
 998  
 999      _contactContainers: function( event ) {
1000          var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom,
1001              floating, axis,
1002              innermostContainer = null,
1003              innermostIndex = null;
1004  
1005          // Get innermost container that intersects with item
1006          for ( i = this.containers.length - 1; i >= 0; i-- ) {
1007  
1008              // Never consider a container that's located within the item itself
1009              if ( $.contains( this.currentItem[ 0 ], this.containers[ i ].element[ 0 ] ) ) {
1010                  continue;
1011              }
1012  
1013              if ( this._intersectsWith( this.containers[ i ].containerCache ) ) {
1014  
1015                  // If we've already found a container and it's more "inner" than this, then continue
1016                  if ( innermostContainer &&
1017                          $.contains(
1018                              this.containers[ i ].element[ 0 ],
1019                              innermostContainer.element[ 0 ] ) ) {
1020                      continue;
1021                  }
1022  
1023                  innermostContainer = this.containers[ i ];
1024                  innermostIndex = i;
1025  
1026              } else {
1027  
1028                  // container doesn't intersect. trigger "out" event if necessary
1029                  if ( this.containers[ i ].containerCache.over ) {
1030                      this.containers[ i ]._trigger( "out", event, this._uiHash( this ) );
1031                      this.containers[ i ].containerCache.over = 0;
1032                  }
1033              }
1034  
1035          }
1036  
1037          // If no intersecting containers found, return
1038          if ( !innermostContainer ) {
1039              return;
1040          }
1041  
1042          // Move the item into the container if it's not there already
1043          if ( this.containers.length === 1 ) {
1044              if ( !this.containers[ innermostIndex ].containerCache.over ) {
1045                  this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash( this ) );
1046                  this.containers[ innermostIndex ].containerCache.over = 1;
1047              }
1048          } else {
1049  
1050              // When entering a new container, we will find the item with the least distance and
1051              // append our item near it
1052              dist = 10000;
1053              itemWithLeastDistance = null;
1054              floating = innermostContainer.floating || this._isFloating( this.currentItem );
1055              posProperty = floating ? "left" : "top";
1056              sizeProperty = floating ? "width" : "height";
1057              axis = floating ? "pageX" : "pageY";
1058  
1059              for ( j = this.items.length - 1; j >= 0; j-- ) {
1060                  if ( !$.contains(
1061                          this.containers[ innermostIndex ].element[ 0 ], this.items[ j ].item[ 0 ] )
1062                  ) {
1063                      continue;
1064                  }
1065                  if ( this.items[ j ].item[ 0 ] === this.currentItem[ 0 ] ) {
1066                      continue;
1067                  }
1068  
1069                  cur = this.items[ j ].item.offset()[ posProperty ];
1070                  nearBottom = false;
1071                  if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
1072                      nearBottom = true;
1073                  }
1074  
1075                  if ( Math.abs( event[ axis ] - cur ) < dist ) {
1076                      dist = Math.abs( event[ axis ] - cur );
1077                      itemWithLeastDistance = this.items[ j ];
1078                      this.direction = nearBottom ? "up" : "down";
1079                  }
1080              }
1081  
1082              //Check if dropOnEmpty is enabled
1083              if ( !itemWithLeastDistance && !this.options.dropOnEmpty ) {
1084                  return;
1085              }
1086  
1087              if ( this.currentContainer === this.containers[ innermostIndex ] ) {
1088                  if ( !this.currentContainer.containerCache.over ) {
1089                      this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
1090                      this.currentContainer.containerCache.over = 1;
1091                  }
1092                  return;
1093              }
1094  
1095              if ( itemWithLeastDistance ) {
1096                  this._rearrange( event, itemWithLeastDistance, null, true );
1097              } else {
1098                  this._rearrange( event, null, this.containers[ innermostIndex ].element, true );
1099              }
1100              this._trigger( "change", event, this._uiHash() );
1101              this.containers[ innermostIndex ]._trigger( "change", event, this._uiHash( this ) );
1102              this.currentContainer = this.containers[ innermostIndex ];
1103  
1104              //Update the placeholder
1105              this.options.placeholder.update( this.currentContainer, this.placeholder );
1106  
1107              //Update scrollParent
1108              this.scrollParent = this.placeholder.scrollParent();
1109  
1110              //Update overflowOffset
1111              if ( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
1112                      this.scrollParent[ 0 ].tagName !== "HTML" ) {
1113                  this.overflowOffset = this.scrollParent.offset();
1114              }
1115  
1116              this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash( this ) );
1117              this.containers[ innermostIndex ].containerCache.over = 1;
1118          }
1119  
1120      },
1121  
1122      _createHelper: function( event ) {
1123  
1124          var o = this.options,
1125              helper = typeof o.helper === "function" ?
1126                  $( o.helper.apply( this.element[ 0 ], [ event, this.currentItem ] ) ) :
1127                  ( o.helper === "clone" ? this.currentItem.clone() : this.currentItem );
1128  
1129          //Add the helper to the DOM if that didn't happen already
1130          if ( !helper.parents( "body" ).length ) {
1131              this.appendTo[ 0 ].appendChild( helper[ 0 ] );
1132          }
1133  
1134          if ( helper[ 0 ] === this.currentItem[ 0 ] ) {
1135              this._storedCSS = {
1136                  width: this.currentItem[ 0 ].style.width,
1137                  height: this.currentItem[ 0 ].style.height,
1138                  position: this.currentItem.css( "position" ),
1139                  top: this.currentItem.css( "top" ),
1140                  left: this.currentItem.css( "left" )
1141              };
1142          }
1143  
1144          if ( !helper[ 0 ].style.width || o.forceHelperSize ) {
1145              helper.width( this.currentItem.width() );
1146          }
1147          if ( !helper[ 0 ].style.height || o.forceHelperSize ) {
1148              helper.height( this.currentItem.height() );
1149          }
1150  
1151          return helper;
1152  
1153      },
1154  
1155      _adjustOffsetFromHelper: function( obj ) {
1156          if ( typeof obj === "string" ) {
1157              obj = obj.split( " " );
1158          }
1159          if ( Array.isArray( obj ) ) {
1160              obj = { left: +obj[ 0 ], top: +obj[ 1 ] || 0 };
1161          }
1162          if ( "left" in obj ) {
1163              this.offset.click.left = obj.left + this.margins.left;
1164          }
1165          if ( "right" in obj ) {
1166              this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
1167          }
1168          if ( "top" in obj ) {
1169              this.offset.click.top = obj.top + this.margins.top;
1170          }
1171          if ( "bottom" in obj ) {
1172              this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
1173          }
1174      },
1175  
1176      _getParentOffset: function() {
1177  
1178          //Get the offsetParent and cache its position
1179          this.offsetParent = this.helper.offsetParent();
1180          var po = this.offsetParent.offset();
1181  
1182          // This is a special case where we need to modify a offset calculated on start, since the
1183          // following happened:
1184          // 1. The position of the helper is absolute, so it's position is calculated based on the
1185          // next positioned parent
1186          // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't
1187          // the document, which means that the scroll is included in the initial calculation of the
1188          // offset of the parent, and never recalculated upon drag
1189          if ( this.cssPosition === "absolute" && this.scrollParent[ 0 ] !== this.document[ 0 ] &&
1190                  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) {
1191              po.left += this.scrollParent.scrollLeft();
1192              po.top += this.scrollParent.scrollTop();
1193          }
1194  
1195          // This needs to be actually done for all browsers, since pageX/pageY includes
1196          // this information.
1197          if ( this.offsetParent[ 0 ] === this.document[ 0 ].body ) {
1198              po = { top: 0, left: 0 };
1199          }
1200  
1201          return {
1202              top: po.top + ( parseInt( this.offsetParent.css( "borderTopWidth" ), 10 ) || 0 ),
1203              left: po.left + ( parseInt( this.offsetParent.css( "borderLeftWidth" ), 10 ) || 0 )
1204          };
1205  
1206      },
1207  
1208      _getRelativeOffset: function() {
1209  
1210          if ( this.cssPosition === "relative" ) {
1211              var p = this.currentItem.position();
1212              return {
1213                  top: p.top - ( parseInt( this.helper.css( "top" ), 10 ) || 0 ) +
1214                      this.scrollParent.scrollTop(),
1215                  left: p.left - ( parseInt( this.helper.css( "left" ), 10 ) || 0 ) +
1216                      this.scrollParent.scrollLeft()
1217              };
1218          } else {
1219              return { top: 0, left: 0 };
1220          }
1221  
1222      },
1223  
1224      _cacheMargins: function() {
1225          this.margins = {
1226              left: ( parseInt( this.currentItem.css( "marginLeft" ), 10 ) || 0 ),
1227              top: ( parseInt( this.currentItem.css( "marginTop" ), 10 ) || 0 )
1228          };
1229      },
1230  
1231      _cacheHelperProportions: function() {
1232          this.helperProportions = {
1233              width: this.helper.outerWidth(),
1234              height: this.helper.outerHeight()
1235          };
1236      },
1237  
1238      _setContainment: function() {
1239  
1240          var ce, co, over,
1241              o = this.options;
1242          if ( o.containment === "parent" ) {
1243              o.containment = this.helper[ 0 ].parentNode;
1244          }
1245          if ( o.containment === "document" || o.containment === "window" ) {
1246              this.containment = [
1247                  0 - this.offset.relative.left - this.offset.parent.left,
1248                  0 - this.offset.relative.top - this.offset.parent.top,
1249                  o.containment === "document" ?
1250                      this.document.width() :
1251                      this.window.width() - this.helperProportions.width - this.margins.left,
1252                  ( o.containment === "document" ?
1253                      ( this.document.height() || document.body.parentNode.scrollHeight ) :
1254                      this.window.height() || this.document[ 0 ].body.parentNode.scrollHeight
1255                  ) - this.helperProportions.height - this.margins.top
1256              ];
1257          }
1258  
1259          if ( !( /^(document|window|parent)$/ ).test( o.containment ) ) {
1260              ce = $( o.containment )[ 0 ];
1261              co = $( o.containment ).offset();
1262              over = ( $( ce ).css( "overflow" ) !== "hidden" );
1263  
1264              this.containment = [
1265                  co.left + ( parseInt( $( ce ).css( "borderLeftWidth" ), 10 ) || 0 ) +
1266                      ( parseInt( $( ce ).css( "paddingLeft" ), 10 ) || 0 ) - this.margins.left,
1267                  co.top + ( parseInt( $( ce ).css( "borderTopWidth" ), 10 ) || 0 ) +
1268                      ( parseInt( $( ce ).css( "paddingTop" ), 10 ) || 0 ) - this.margins.top,
1269                  co.left + ( over ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
1270                      ( parseInt( $( ce ).css( "borderLeftWidth" ), 10 ) || 0 ) -
1271                      ( parseInt( $( ce ).css( "paddingRight" ), 10 ) || 0 ) -
1272                      this.helperProportions.width - this.margins.left,
1273                  co.top + ( over ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
1274                      ( parseInt( $( ce ).css( "borderTopWidth" ), 10 ) || 0 ) -
1275                      ( parseInt( $( ce ).css( "paddingBottom" ), 10 ) || 0 ) -
1276                      this.helperProportions.height - this.margins.top
1277              ];
1278          }
1279  
1280      },
1281  
1282      _convertPositionTo: function( d, pos ) {
1283  
1284          if ( !pos ) {
1285              pos = this.position;
1286          }
1287          var mod = d === "absolute" ? 1 : -1,
1288              scroll = this.cssPosition === "absolute" &&
1289                  !( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
1290                  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ?
1291                      this.offsetParent :
1292                      this.scrollParent,
1293              scrollIsRootNode = ( /(html|body)/i ).test( scroll[ 0 ].tagName );
1294  
1295          return {
1296              top: (
1297  
1298                  // The absolute mouse position
1299                  pos.top    +
1300  
1301                  // Only for relative positioned nodes: Relative offset from element to offset parent
1302                  this.offset.relative.top * mod +
1303  
1304                  // The offsetParent's offset without borders (offset + border)
1305                  this.offset.parent.top * mod -
1306                  ( ( this.cssPosition === "fixed" ?
1307                      -this.scrollParent.scrollTop() :
1308                      ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod )
1309              ),
1310              left: (
1311  
1312                  // The absolute mouse position
1313                  pos.left +
1314  
1315                  // Only for relative positioned nodes: Relative offset from element to offset parent
1316                  this.offset.relative.left * mod +
1317  
1318                  // The offsetParent's offset without borders (offset + border)
1319                  this.offset.parent.left * mod    -
1320                  ( ( this.cssPosition === "fixed" ?
1321                      -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 :
1322                      scroll.scrollLeft() ) * mod )
1323              )
1324          };
1325  
1326      },
1327  
1328      _generatePosition: function( event ) {
1329  
1330          var top, left,
1331              o = this.options,
1332              pageX = event.pageX,
1333              pageY = event.pageY,
1334              scroll = this.cssPosition === "absolute" &&
1335                  !( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
1336                  $.contains( this.scrollParent[ 0 ], this.offsetParent[ 0 ] ) ) ?
1337                      this.offsetParent :
1338                      this.scrollParent,
1339                  scrollIsRootNode = ( /(html|body)/i ).test( scroll[ 0 ].tagName );
1340  
1341          // This is another very weird special case that only happens for relative elements:
1342          // 1. If the css position is relative
1343          // 2. and the scroll parent is the document or similar to the offset parent
1344          // we have to refresh the relative offset during the scroll so there are no jumps
1345          if ( this.cssPosition === "relative" && !( this.scrollParent[ 0 ] !== this.document[ 0 ] &&
1346                  this.scrollParent[ 0 ] !== this.offsetParent[ 0 ] ) ) {
1347              this.offset.relative = this._getRelativeOffset();
1348          }
1349  
1350          /*
1351           * - Position constraining -
1352           * Constrain the position to a mix of grid, containment.
1353           */
1354  
1355          if ( this.originalPosition ) { //If we are not dragging yet, we won't check for options
1356  
1357              if ( this.containment ) {
1358                  if ( event.pageX - this.offset.click.left < this.containment[ 0 ] ) {
1359                      pageX = this.containment[ 0 ] + this.offset.click.left;
1360                  }
1361                  if ( event.pageY - this.offset.click.top < this.containment[ 1 ] ) {
1362                      pageY = this.containment[ 1 ] + this.offset.click.top;
1363                  }
1364                  if ( event.pageX - this.offset.click.left > this.containment[ 2 ] ) {
1365                      pageX = this.containment[ 2 ] + this.offset.click.left;
1366                  }
1367                  if ( event.pageY - this.offset.click.top > this.containment[ 3 ] ) {
1368                      pageY = this.containment[ 3 ] + this.offset.click.top;
1369                  }
1370              }
1371  
1372              if ( o.grid ) {
1373                  top = this.originalPageY + Math.round( ( pageY - this.originalPageY ) /
1374                      o.grid[ 1 ] ) * o.grid[ 1 ];
1375                  pageY = this.containment ?
1376                      ( ( top - this.offset.click.top >= this.containment[ 1 ] &&
1377                          top - this.offset.click.top <= this.containment[ 3 ] ) ?
1378                              top :
1379                              ( ( top - this.offset.click.top >= this.containment[ 1 ] ) ?
1380                                  top - o.grid[ 1 ] : top + o.grid[ 1 ] ) ) :
1381                                  top;
1382  
1383                  left = this.originalPageX + Math.round( ( pageX - this.originalPageX ) /
1384                      o.grid[ 0 ] ) * o.grid[ 0 ];
1385                  pageX = this.containment ?
1386                      ( ( left - this.offset.click.left >= this.containment[ 0 ] &&
1387                          left - this.offset.click.left <= this.containment[ 2 ] ) ?
1388                              left :
1389                              ( ( left - this.offset.click.left >= this.containment[ 0 ] ) ?
1390                                  left - o.grid[ 0 ] : left + o.grid[ 0 ] ) ) :
1391                                  left;
1392              }
1393  
1394          }
1395  
1396          return {
1397              top: (
1398  
1399                  // The absolute mouse position
1400                  pageY -
1401  
1402                  // Click offset (relative to the element)
1403                  this.offset.click.top -
1404  
1405                  // Only for relative positioned nodes: Relative offset from element to offset parent
1406                  this.offset.relative.top -
1407  
1408                  // The offsetParent's offset without borders (offset + border)
1409                  this.offset.parent.top +
1410                  ( ( this.cssPosition === "fixed" ?
1411                      -this.scrollParent.scrollTop() :
1412                      ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) )
1413              ),
1414              left: (
1415  
1416                  // The absolute mouse position
1417                  pageX -
1418  
1419                  // Click offset (relative to the element)
1420                  this.offset.click.left -
1421  
1422                  // Only for relative positioned nodes: Relative offset from element to offset parent
1423                  this.offset.relative.left -
1424  
1425                  // The offsetParent's offset without borders (offset + border)
1426                  this.offset.parent.left +
1427                  ( ( this.cssPosition === "fixed" ?
1428                      -this.scrollParent.scrollLeft() :
1429                      scrollIsRootNode ? 0 : scroll.scrollLeft() ) )
1430              )
1431          };
1432  
1433      },
1434  
1435      _rearrange: function( event, i, a, hardRefresh ) {
1436  
1437          if ( a ) {
1438              a[ 0 ].appendChild( this.placeholder[ 0 ] );
1439          } else {
1440              i.item[ 0 ].parentNode.insertBefore( this.placeholder[ 0 ],
1441                  ( this.direction === "down" ? i.item[ 0 ] : i.item[ 0 ].nextSibling ) );
1442          }
1443  
1444          //Various things done here to improve the performance:
1445          // 1. we create a setTimeout, that calls refreshPositions
1446          // 2. on the instance, we have a counter variable, that get's higher after every append
1447          // 3. on the local scope, we copy the counter variable, and check in the timeout,
1448          // if it's still the same
1449          // 4. this lets only the last addition to the timeout stack through
1450          this.counter = this.counter ? ++this.counter : 1;
1451          var counter = this.counter;
1452  
1453          this._delay( function() {
1454              if ( counter === this.counter ) {
1455  
1456                  //Precompute after each DOM insertion, NOT on mousemove
1457                  this.refreshPositions( !hardRefresh );
1458              }
1459          } );
1460  
1461      },
1462  
1463      _clear: function( event, noPropagation ) {
1464  
1465          this.reverting = false;
1466  
1467          // We delay all events that have to be triggered to after the point where the placeholder
1468          // has been removed and everything else normalized again
1469          var i,
1470              delayedTriggers = [];
1471  
1472          // We first have to update the dom position of the actual currentItem
1473          // Note: don't do it if the current item is already removed (by a user), or it gets
1474          // reappended (see #4088)
1475          if ( !this._noFinalSort && this.currentItem.parent().length ) {
1476              this.placeholder.before( this.currentItem );
1477          }
1478          this._noFinalSort = null;
1479  
1480          if ( this.helper[ 0 ] === this.currentItem[ 0 ] ) {
1481              for ( i in this._storedCSS ) {
1482                  if ( this._storedCSS[ i ] === "auto" || this._storedCSS[ i ] === "static" ) {
1483                      this._storedCSS[ i ] = "";
1484                  }
1485              }
1486              this.currentItem.css( this._storedCSS );
1487              this._removeClass( this.currentItem, "ui-sortable-helper" );
1488          } else {
1489              this.currentItem.show();
1490          }
1491  
1492          if ( this.fromOutside && !noPropagation ) {
1493              delayedTriggers.push( function( event ) {
1494                  this._trigger( "receive", event, this._uiHash( this.fromOutside ) );
1495              } );
1496          }
1497          if ( ( this.fromOutside ||
1498                  this.domPosition.prev !==
1499                  this.currentItem.prev().not( ".ui-sortable-helper" )[ 0 ] ||
1500                  this.domPosition.parent !== this.currentItem.parent()[ 0 ] ) && !noPropagation ) {
1501  
1502              // Trigger update callback if the DOM position has changed
1503              delayedTriggers.push( function( event ) {
1504                  this._trigger( "update", event, this._uiHash() );
1505              } );
1506          }
1507  
1508          // Check if the items Container has Changed and trigger appropriate
1509          // events.
1510          if ( this !== this.currentContainer ) {
1511              if ( !noPropagation ) {
1512                  delayedTriggers.push( function( event ) {
1513                      this._trigger( "remove", event, this._uiHash() );
1514                  } );
1515                  delayedTriggers.push( ( function( c ) {
1516                      return function( event ) {
1517                          c._trigger( "receive", event, this._uiHash( this ) );
1518                      };
1519                  } ).call( this, this.currentContainer ) );
1520                  delayedTriggers.push( ( function( c ) {
1521                      return function( event ) {
1522                          c._trigger( "update", event, this._uiHash( this ) );
1523                      };
1524                  } ).call( this, this.currentContainer ) );
1525              }
1526          }
1527  
1528          //Post events to containers
1529  		function delayEvent( type, instance, container ) {
1530              return function( event ) {
1531                  container._trigger( type, event, instance._uiHash( instance ) );
1532              };
1533          }
1534          for ( i = this.containers.length - 1; i >= 0; i-- ) {
1535              if ( !noPropagation ) {
1536                  delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
1537              }
1538              if ( this.containers[ i ].containerCache.over ) {
1539                  delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
1540                  this.containers[ i ].containerCache.over = 0;
1541              }
1542          }
1543  
1544          //Do what was originally in plugins
1545          if ( this._storedStylesheet ) {
1546              this._storedStylesheet.remove();
1547              this._storedStylesheet = null;
1548          }
1549          if ( this._storedOpacity ) {
1550              this.helper.css( "opacity", this._storedOpacity );
1551          }
1552          if ( this._storedZIndex ) {
1553              this.helper.css( "zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex );
1554          }
1555  
1556          this.dragging = false;
1557  
1558          if ( !noPropagation ) {
1559              this._trigger( "beforeStop", event, this._uiHash() );
1560          }
1561  
1562          //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately,
1563          // it unbinds ALL events from the original node!
1564          this.placeholder[ 0 ].parentNode.removeChild( this.placeholder[ 0 ] );
1565  
1566          if ( !this.cancelHelperRemoval ) {
1567              if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
1568                  this.helper.remove();
1569              }
1570              this.helper = null;
1571          }
1572  
1573          if ( !noPropagation ) {
1574              for ( i = 0; i < delayedTriggers.length; i++ ) {
1575  
1576                  // Trigger all delayed events
1577                  delayedTriggers[ i ].call( this, event );
1578              }
1579              this._trigger( "stop", event, this._uiHash() );
1580          }
1581  
1582          this.fromOutside = false;
1583          return !this.cancelHelperRemoval;
1584  
1585      },
1586  
1587      _trigger: function() {
1588          if ( $.Widget.prototype._trigger.apply( this, arguments ) === false ) {
1589              this.cancel();
1590          }
1591      },
1592  
1593      _uiHash: function( _inst ) {
1594          var inst = _inst || this;
1595          return {
1596              helper: inst.helper,
1597              placeholder: inst.placeholder || $( [] ),
1598              position: inst.position,
1599              originalPosition: inst.originalPosition,
1600              offset: inst.positionAbs,
1601              item: inst.currentItem,
1602              sender: _inst ? _inst.element : null
1603          };
1604      }
1605  
1606  } );
1607  
1608  } );