[Summary view] [Print] [Text view]

   1  /*!
   2   * jQuery UI Droppable 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/droppable/
  10   *
  11   * Depends:
  12   *    jquery.ui.core.js
  13   *    jquery.ui.widget.js
  14   *    jquery.ui.mouse.js
  15   *    jquery.ui.draggable.js
  16   */
  17  (function( $, undefined ) {
  18  
  19  $.widget("ui.droppable", {
  20      version: "1.9.2",
  21      widgetEventPrefix: "drop",
  22      options: {
  23          accept: '*',
  24          activeClass: false,
  25          addClasses: true,
  26          greedy: false,
  27          hoverClass: false,
  28          scope: 'default',
  29          tolerance: 'intersect'
  30      },
  31      _create: function() {
  32  
  33          var o = this.options, accept = o.accept;
  34          this.isover = 0; this.isout = 1;
  35  
  36          this.accept = $.isFunction(accept) ? accept : function(d) {
  37              return d.is(accept);
  38          };
  39  
  40          //Store the droppable's proportions
  41          this.proportions = { width: this.element[0].offsetWidth, height: this.element[0].offsetHeight };
  42  
  43          // Add the reference and positions to the manager
  44          $.ui.ddmanager.droppables[o.scope] = $.ui.ddmanager.droppables[o.scope] || [];
  45          $.ui.ddmanager.droppables[o.scope].push(this);
  46  
  47          (o.addClasses && this.element.addClass("ui-droppable"));
  48  
  49      },
  50  
  51      _destroy: function() {
  52          var drop = $.ui.ddmanager.droppables[this.options.scope];
  53          for ( var i = 0; i < drop.length; i++ )
  54              if ( drop[i] == this )
  55                  drop.splice(i, 1);
  56  
  57          this.element.removeClass("ui-droppable ui-droppable-disabled");
  58      },
  59  
  60      _setOption: function(key, value) {
  61  
  62          if(key == 'accept') {
  63              this.accept = $.isFunction(value) ? value : function(d) {
  64                  return d.is(value);
  65              };
  66          }
  67          $.Widget.prototype._setOption.apply(this, arguments);
  68      },
  69  
  70      _activate: function(event) {
  71          var draggable = $.ui.ddmanager.current;
  72          if(this.options.activeClass) this.element.addClass(this.options.activeClass);
  73          (draggable && this._trigger('activate', event, this.ui(draggable)));
  74      },
  75  
  76      _deactivate: function(event) {
  77          var draggable = $.ui.ddmanager.current;
  78          if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
  79          (draggable && this._trigger('deactivate', event, this.ui(draggable)));
  80      },
  81  
  82      _over: function(event) {
  83  
  84          var draggable = $.ui.ddmanager.current;
  85          if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
  86  
  87          if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
  88              if(this.options.hoverClass) this.element.addClass(this.options.hoverClass);
  89              this._trigger('over', event, this.ui(draggable));
  90          }
  91  
  92      },
  93  
  94      _out: function(event) {
  95  
  96          var draggable = $.ui.ddmanager.current;
  97          if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return; // Bail if draggable and droppable are same element
  98  
  99          if (this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
 100              if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
 101              this._trigger('out', event, this.ui(draggable));
 102          }
 103  
 104      },
 105  
 106      _drop: function(event,custom) {
 107  
 108          var draggable = custom || $.ui.ddmanager.current;
 109          if (!draggable || (draggable.currentItem || draggable.element)[0] == this.element[0]) return false; // Bail if draggable and droppable are same element
 110  
 111          var childrenIntersection = false;
 112          this.element.find(":data(droppable)").not(".ui-draggable-dragging").each(function() {
 113              var inst = $.data(this, 'droppable');
 114              if(
 115                  inst.options.greedy
 116                  && !inst.options.disabled
 117                  && inst.options.scope == draggable.options.scope
 118                  && inst.accept.call(inst.element[0], (draggable.currentItem || draggable.element))
 119                  && $.ui.intersect(draggable, $.extend(inst, { offset: inst.element.offset() }), inst.options.tolerance)
 120              ) { childrenIntersection = true; return false; }
 121          });
 122          if(childrenIntersection) return false;
 123  
 124          if(this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
 125              if(this.options.activeClass) this.element.removeClass(this.options.activeClass);
 126              if(this.options.hoverClass) this.element.removeClass(this.options.hoverClass);
 127              this._trigger('drop', event, this.ui(draggable));
 128              return this.element;
 129          }
 130  
 131          return false;
 132  
 133      },
 134  
 135      ui: function(c) {
 136          return {
 137              draggable: (c.currentItem || c.element),
 138              helper: c.helper,
 139              position: c.position,
 140              offset: c.positionAbs
 141          };
 142      }
 143  
 144  });
 145  
 146  $.ui.intersect = function(draggable, droppable, toleranceMode) {
 147  
 148      if (!droppable.offset) return false;
 149  
 150      var x1 = (draggable.positionAbs || draggable.position.absolute).left, x2 = x1 + draggable.helperProportions.width,
 151          y1 = (draggable.positionAbs || draggable.position.absolute).top, y2 = y1 + draggable.helperProportions.height;
 152      var l = droppable.offset.left, r = l + droppable.proportions.width,
 153          t = droppable.offset.top, b = t + droppable.proportions.height;
 154  
 155      switch (toleranceMode) {
 156          case 'fit':
 157              return (l <= x1 && x2 <= r
 158                  && t <= y1 && y2 <= b);
 159              break;
 160          case 'intersect':
 161              return (l < x1 + (draggable.helperProportions.width / 2) // Right Half
 162                  && x2 - (draggable.helperProportions.width / 2) < r // Left Half
 163                  && t < y1 + (draggable.helperProportions.height / 2) // Bottom Half
 164                  && y2 - (draggable.helperProportions.height / 2) < b ); // Top Half
 165              break;
 166          case 'pointer':
 167              var draggableLeft = ((draggable.positionAbs || draggable.position.absolute).left + (draggable.clickOffset || draggable.offset.click).left),
 168                  draggableTop = ((draggable.positionAbs || draggable.position.absolute).top + (draggable.clickOffset || draggable.offset.click).top),
 169                  isOver = $.ui.isOver(draggableTop, draggableLeft, t, l, droppable.proportions.height, droppable.proportions.width);
 170              return isOver;
 171              break;
 172          case 'touch':
 173              return (
 174                      (y1 >= t && y1 <= b) ||    // Top edge touching
 175                      (y2 >= t && y2 <= b) ||    // Bottom edge touching
 176                      (y1 < t && y2 > b)        // Surrounded vertically
 177                  ) && (
 178                      (x1 >= l && x1 <= r) ||    // Left edge touching
 179                      (x2 >= l && x2 <= r) ||    // Right edge touching
 180                      (x1 < l && x2 > r)        // Surrounded horizontally
 181                  );
 182              break;
 183          default:
 184              return false;
 185              break;
 186          }
 187  
 188  };
 189  
 190  /*
 191      This manager tracks offsets of draggables and droppables
 192  */
 193  $.ui.ddmanager = {
 194      current: null,
 195      droppables: { 'default': [] },
 196      prepareOffsets: function(t, event) {
 197  
 198          var m = $.ui.ddmanager.droppables[t.options.scope] || [];
 199          var type = event ? event.type : null; // workaround for #2317
 200          var list = (t.currentItem || t.element).find(":data(droppable)").andSelf();
 201  
 202          droppablesLoop: for (var i = 0; i < m.length; i++) {
 203  
 204              if(m[i].options.disabled || (t && !m[i].accept.call(m[i].element[0],(t.currentItem || t.element)))) continue;    //No disabled and non-accepted
 205              for (var j=0; j < list.length; j++) { if(list[j] == m[i].element[0]) { m[i].proportions.height = 0; continue droppablesLoop; } }; //Filter out elements in the current dragged item
 206              m[i].visible = m[i].element.css("display") != "none"; if(!m[i].visible) continue;                                     //If the element is not visible, continue
 207  
 208              if(type == "mousedown") m[i]._activate.call(m[i], event); //Activate the droppable if used directly from draggables
 209  
 210              m[i].offset = m[i].element.offset();
 211              m[i].proportions = { width: m[i].element[0].offsetWidth, height: m[i].element[0].offsetHeight };
 212  
 213          }
 214  
 215      },
 216      drop: function(draggable, event) {
 217  
 218          var dropped = false;
 219          $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
 220  
 221              if(!this.options) return;
 222              if (!this.options.disabled && this.visible && $.ui.intersect(draggable, this, this.options.tolerance))
 223                  dropped = this._drop.call(this, event) || dropped;
 224  
 225              if (!this.options.disabled && this.visible && this.accept.call(this.element[0],(draggable.currentItem || draggable.element))) {
 226                  this.isout = 1; this.isover = 0;
 227                  this._deactivate.call(this, event);
 228              }
 229  
 230          });
 231          return dropped;
 232  
 233      },
 234      dragStart: function( draggable, event ) {
 235          //Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
 236          draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
 237              if( !draggable.options.refreshPositions ) $.ui.ddmanager.prepareOffsets( draggable, event );
 238          });
 239      },
 240      drag: function(draggable, event) {
 241  
 242          //If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
 243          if(draggable.options.refreshPositions) $.ui.ddmanager.prepareOffsets(draggable, event);
 244  
 245          //Run through all droppables and check their positions based on specific tolerance options
 246          $.each($.ui.ddmanager.droppables[draggable.options.scope] || [], function() {
 247  
 248              if(this.options.disabled || this.greedyChild || !this.visible) return;
 249              var intersects = $.ui.intersect(draggable, this, this.options.tolerance);
 250  
 251              var c = !intersects && this.isover == 1 ? 'isout' : (intersects && this.isover == 0 ? 'isover' : null);
 252              if(!c) return;
 253  
 254              var parentInstance;
 255              if (this.options.greedy) {
 256                  // find droppable parents with same scope
 257                  var scope = this.options.scope;
 258                  var parent = this.element.parents(':data(droppable)').filter(function () {
 259                      return $.data(this, 'droppable').options.scope === scope;
 260                  });
 261  
 262                  if (parent.length) {
 263                      parentInstance = $.data(parent[0], 'droppable');
 264                      parentInstance.greedyChild = (c == 'isover' ? 1 : 0);
 265                  }
 266              }
 267  
 268              // we just moved into a greedy child
 269              if (parentInstance && c == 'isover') {
 270                  parentInstance['isover'] = 0;
 271                  parentInstance['isout'] = 1;
 272                  parentInstance._out.call(parentInstance, event);
 273              }
 274  
 275              this[c] = 1; this[c == 'isout' ? 'isover' : 'isout'] = 0;
 276              this[c == "isover" ? "_over" : "_out"].call(this, event);
 277  
 278              // we just moved out of a greedy child
 279              if (parentInstance && c == 'isout') {
 280                  parentInstance['isout'] = 0;
 281                  parentInstance['isover'] = 1;
 282                  parentInstance._over.call(parentInstance, event);
 283              }
 284          });
 285  
 286      },
 287      dragStop: function( draggable, event ) {
 288          draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
 289          //Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
 290          if( !draggable.options.refreshPositions ) $.ui.ddmanager.prepareOffsets( draggable, event );
 291      }
 292  };
 293  
 294  })(jQuery);