webcit/static/dragdrop.js

   1 // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
   2 //
   3 // Element.Class part Copyright (c) 2005 by Rick Olson
   4 //
   5 // Permission is hereby granted, free of charge, to any person obtaining
   6 // a copy of this software and associated documentation files (the
   7 // "Software"), to deal in the Software without restriction, including
   8 // without limitation the rights to use, copy, modify, merge, publish,
   9 // distribute, sublicense, and/or sell copies of the Software, and to
  10 // permit persons to whom the Software is furnished to do so, subject to
  11 // the following conditions:
  12 //
  13 // The above copyright notice and this permission notice shall be
  14 // included in all copies or substantial portions of the Software.
  15 //
  16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24
  25 /*--------------------------------------------------------------------------*/
  26
  27 var Droppables = {
  28   drops: false,
  29
  30   remove: function(element) {
  31     for(var i = 0; i < this.drops.length; i++)
  32       if(this.drops[i].element == element)
  33         this.drops.splice(i,1);
  34   },
  35
  36   add: function(element) {
  37     element = $(element);
  38     var options = Object.extend({
  39       greedy:     true,
  40       hoverclass: null
  41     }, arguments[1] || {});
  42
  43     // cache containers
  44     if(options.containment) {
  45       options._containers = new Array();
  46       var containment = options.containment;
  47       if((typeof containment == 'object') &&
  48         (containment.constructor == Array)) {
  49         for(var i=0; i<containment.length; i++)
  50           options._containers.push($(containment[i]));
  51       } else {
  52         options._containers.push($(containment));
  53       }
  54       options._containers_length =
  55         options._containers.length-1;
  56     }
  57
  58     Element.makePositioned(element); // fix IE
  59
  60     options.element = element;
  61
  62     // activate the droppable
  63     if(!this.drops) this.drops = [];
  64     this.drops.push(options);
  65   },
  66
  67   isContained: function(element, drop) {
  68     var containers = drop._containers;
  69     var parentNode = element.parentNode;
  70     var i = drop._containers_length;
  71     do { if(parentNode==containers[i]) return true; } while (i--);
  72     return false;
  73   },
  74
  75   isAffected: function(pX, pY, element, drop) {
  76     return (
  77       (drop.element!=element) &&
  78       ((!drop._containers) ||
  79         this.isContained(element, drop)) &&
  80       ((!drop.accept) ||
  81         (Element.Class.has_any(element, drop.accept))) &&
  82       Position.within(drop.element, pX, pY) );
  83   },
  84
  85   deactivate: function(drop) {
  86     Element.Class.remove(drop.element, drop.hoverclass);
  87     this.last_active = null;
  88   },
  89
  90   activate: function(drop) {
  91     if(this.last_active) this.deactivate(this.last_active);
  92     if(drop.hoverclass)
  93       Element.Class.add(drop.element, drop.hoverclass);
  94     this.last_active = drop;
  95   },
  96
  97   show: function(event, element) {
  98     if(!this.drops) return;
  99     var pX = Event.pointerX(event);
 100     var pY = Event.pointerY(event);
 101     Position.prepare();
 102
 103     var i = this.drops.length-1; do {
 104       var drop = this.drops[i];
 105       if(this.isAffected(pX, pY, element, drop)) {
 106         if(drop.onHover)
 107            drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
 108         if(drop.greedy) {
 109           this.activate(drop);
 110           return;
 111         }
 112       }
 113     } while (i--);
 114   },
 115
 116   fire: function(event, element) {
 117     if(!this.last_active) return;
 118     Position.prepare();
 119
 120     if (this.isAffected(Event.pointerX(event), Event.pointerY(event), element, this.last_active))
 121       if (this.last_active.onDrop)
 122         this.last_active.onDrop(element, this.last_active.element);
 123
 124   },
 125
 126   reset: function() {
 127     if(this.last_active)
 128       this.deactivate(this.last_active);
 129   }
 130 }
 131
 132 var Draggables = {
 133   observers: new Array(),
 134   addObserver: function(observer) {
 135     this.observers.push(observer);
 136   },
 137   removeObserver: function(element) {  // element instead of obsever fixes mem leaks
 138     for(var i = 0; i < this.observers.length; i++)
 139       if(this.observers[i].element && (this.observers[i].element == element))
 140         this.observers.splice(i,1);
 141   },
 142   notify: function(eventName, draggable) {  // 'onStart', 'onEnd'
 143     for(var i = 0; i < this.observers.length; i++)
 144       this.observers[i][eventName](draggable);
 145   }
 146 }
 147
 148 /*--------------------------------------------------------------------------*/
 149
 150 var Draggable = Class.create();
 151 Draggable.prototype = {
 152   initialize: function(element) {
 153     var options = Object.extend({
 154       handle: false,
 155       starteffect: function(element) {
 156         new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7});
 157       },
 158       reverteffect: function(element, top_offset, left_offset) {
 159         var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
 160         new Effect.MoveBy(element, -top_offset, -left_offset, {duration:dur});
 161       },
 162       endeffect: function(element) {
 163          new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0});
 164       },
 165       zindex: 1000,
 166       revert: false
 167     }, arguments[1] || {});
 168
 169     this.element      = $(element);
 170     this.handle       = options.handle ? $(options.handle) : this.element;
 171
 172     Element.makePositioned(this.element); // fix IE
 173
 174     this.offsetX      = 0;
 175     this.offsetY      = 0;
 176     this.originalLeft = this.currentLeft();
 177     this.originalTop  = this.currentTop();
 178     this.originalX    = this.element.offsetLeft;
 179     this.originalY    = this.element.offsetTop;
 180     this.originalZ    = parseInt(this.element.style.zIndex || "0");
 181
 182     this.options      = options;
 183
 184     this.active       = false;
 185     this.dragging     = false;
 186
 187     this.eventMouseDown = this.startDrag.bindAsEventListener(this);
 188     this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
 189     this.eventMouseMove = this.update.bindAsEventListener(this);
 190     this.eventKeypress  = this.keyPress.bindAsEventListener(this);
 191
 192     Event.observe(this.handle, "mousedown", this.eventMouseDown);
 193   },
 194   destroy: function() {
 195     Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
 196     this.unregisterEvents();
 197   },
 198   registerEvents: function() {
 199     if(this.active) return;
 200     Event.observe(document, "mouseup", this.eventMouseUp);
 201     Event.observe(document, "mousemove", this.eventMouseMove);
 202     Event.observe(document, "keypress", this.eventKeypress);
 203   },
 204   unregisterEvents: function() {
 205     if(!this.active) return;
 206     Event.stopObserving(document, "mouseup", this.eventMouseUp);
 207     Event.stopObserving(document, "mousemove", this.eventMouseMove);
 208     Event.stopObserving(document, "keypress", this.eventKeypress);
 209   },
 210   currentLeft: function() {
 211     return parseInt(this.element.style.left || '0');
 212   },
 213   currentTop: function() {
 214     return parseInt(this.element.style.top || '0')
 215   },
 216   startDrag: function(event) {
 217     if(Event.isLeftClick(event)) {
 218       this.registerEvents();
 219       this.active = true;
 220       var pointer = [Event.pointerX(event), Event.pointerY(event)];
 221       var offsets = Position.cumulativeOffset(this.element);
 222       this.offsetX =  (pointer[0] - offsets[0]);
 223       this.offsetY =  (pointer[1] - offsets[1]);
 224       Event.stop(event);
 225     }
 226   },
 227   finishDrag: function(event, success) {
 228     this.unregisterEvents();
 229
 230     this.active = false;
 231     this.dragging = false;
 232
 233     if(this.options.ghosting) {
 234       Position.relativize(this.element);
 235       Element.remove(this._clone);
 236       this._clone = null;
 237     }
 238
 239     if(success) Droppables.fire(event, this.element);
 240     Draggables.notify('onEnd', this);
 241
 242     var revert = this.options.revert;
 243     if(revert && typeof revert == 'function') revert = revert(this.element);
 244
 245     if(revert && this.options.reverteffect) {
 246       this.options.reverteffect(this.element,
 247       this.currentTop()-this.originalTop,
 248       this.currentLeft()-this.originalLeft);
 249     } else {
 250       this.originalLeft = this.currentLeft();
 251       this.originalTop  = this.currentTop();
 252     }
 253
 254     this.element.style.zIndex = this.originalZ;
 255
 256     if(this.options.endeffect)
 257       this.options.endeffect(this.element);
 258
 259
 260     Droppables.reset();
 261   },
 262   keyPress: function(event) {
 263     if(this.active) {
 264       if(event.keyCode==Event.KEY_ESC) {
 265         this.finishDrag(event, false);
 266         Event.stop(event);
 267       }
 268     }
 269   },
 270   endDrag: function(event) {
 271     if(this.active && this.dragging) {
 272       this.finishDrag(event, true);
 273       Event.stop(event);
 274     }
 275     this.active = false;
 276     this.dragging = false;
 277   },
 278   draw: function(event) {
 279     var pointer = [Event.pointerX(event), Event.pointerY(event)];
 280     var offsets = Position.cumulativeOffset(this.element);
 281     offsets[0] -= this.currentLeft();
 282     offsets[1] -= this.currentTop();
 283     var style = this.element.style;
 284     if((!this.options.constraint) || (this.options.constraint=='horizontal'))
 285       style.left = (pointer[0] - offsets[0] - this.offsetX) + "px";
 286     if((!this.options.constraint) || (this.options.constraint=='vertical'))
 287       style.top  = (pointer[1] - offsets[1] - this.offsetY) + "px";
 288     if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering
 289   },
 290   update: function(event) {
 291    if(this.active) {
 292       if(!this.dragging) {
 293         var style = this.element.style;
 294         this.dragging = true;
 295         if(style.position=="") style.position = "relative";
 296         style.zIndex = this.options.zindex;
 297
 298         if(this.options.ghosting) {
 299           this._clone = this.element.cloneNode(true);
 300           Position.absolutize(this.element);
 301           this.element.parentNode.insertBefore(this._clone, this.element);
 302         }
 303
 304         Draggables.notify('onStart', this);
 305         if(this.options.starteffect) this.options.starteffect(this.element);
 306       }
 307
 308       Droppables.show(event, this.element);
 309       this.draw(event);
 310       if(this.options.change) this.options.change(this);
 311
 312       // fix AppleWebKit rendering
 313       if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
 314
 315       Event.stop(event);
 316    }
 317   }
 318 }
 319
 320 /*--------------------------------------------------------------------------*/
 321
 322 var SortableObserver = Class.create();
 323 SortableObserver.prototype = {
 324   initialize: function(element, observer) {
 325     this.element   = $(element);
 326     this.observer  = observer;
 327     this.lastValue = Sortable.serialize(this.element);
 328   },
 329   onStart: function() {
 330     this.lastValue = Sortable.serialize(this.element);
 331   },
 332   onEnd: function() {
 333     Sortable.unmark();
 334     if(this.lastValue != Sortable.serialize(this.element))
 335       this.observer(this.element)
 336   }
 337 }
 338
 339 var Sortable = {
 340   sortables: new Array(),
 341   options: function(element){
 342     element = $(element);
 343     for(var i=0;i<this.sortables.length;i++)
 344       if(this.sortables[i].element == element)
 345         return this.sortables[i];
 346     return null;
 347   },
 348   destroy: function(element){
 349     element = $(element);
 350     for(var i=0;i<this.sortables.length;i++) {
 351       if(this.sortables[i].element == element) {
 352         var s = this.sortables[i];
 353         Draggables.removeObserver(s.element);
 354         for(var j=0;j<s.droppables.length;j++)
 355           Droppables.remove(s.droppables[j]);
 356         for(j=0;j<s.draggables.length;j++)
 357           s.draggables[j].destroy();
 358         this.sortables.splice(i,1);
 359       }
 360     }
 361   },
 362   create: function(element) {
 363     element = $(element);
 364     var options = Object.extend({
 365       element:     element,
 366       tag:         'li',       // assumes li children, override with tag: 'tagname'
 367       dropOnEmpty: false,
 368       tree:        false,      // fixme: unimplemented
 369       overlap:     'vertical', // one of 'vertical', 'horizontal'
 370       constraint:  'vertical', // one of 'vertical', 'horizontal', false
 371       containment: element,    // also takes array of elements (or id's); or false
 372       handle:      false,      // or a CSS class
 373       only:        false,
 374       hoverclass:  null,
 375       ghosting:    false,
 376       onChange:    function() {},
 377       onUpdate:    function() {}
 378     }, arguments[1] || {});
 379
 380     // clear any old sortable with same element
 381     this.destroy(element);
 382
 383     // build options for the draggables
 384     var options_for_draggable = {
 385       revert:      true,
 386       ghosting:    options.ghosting,
 387       constraint:  options.constraint,
 388       handle:      handle };
 389
 390     if(options.starteffect)
 391       options_for_draggable.starteffect = options.starteffect;
 392
 393     if(options.reverteffect)
 394       options_for_draggable.reverteffect = options.reverteffect;
 395     else
 396       if(options.ghosting) options_for_draggable.reverteffect = function(element) {
 397         element.style.top  = 0;
 398         element.style.left = 0;
 399       };
 400
 401     if(options.endeffect)
 402       options_for_draggable.endeffect = options.endeffect;
 403
 404     if(options.zindex)
 405       options_for_draggable.zindex = options.zindex;
 406
 407     // build options for the droppables
 408     var options_for_droppable = {
 409       overlap:     options.overlap,
 410       containment: options.containment,
 411       hoverclass:  options.hoverclass,
 412       onHover:     Sortable.onHover,
 413       greedy:      !options.dropOnEmpty
 414     }
 415
 416     // fix for gecko engine
 417     Element.cleanWhitespace(element);
 418
 419     options.draggables = [];
 420     options.droppables = [];
 421
 422     // make it so
 423
 424     // drop on empty handling
 425     if(options.dropOnEmpty) {
 426       Droppables.add(element,
 427         {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false});
 428       options.droppables.push(element);
 429     }
 430
 431     var elements = this.findElements(element, options);
 432     if(elements) {
 433       for (var i = 0; i < elements.length; i++) {
 434         // handles are per-draggable
 435         var handle = options.handle ?
 436           Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i];
 437             options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle })));
 438             Droppables.add(elements[i], options_for_droppable);
 439
 440         options.droppables.push(elements[i]);
 441       }
 442     }
 443
 444     // keep reference
 445     this.sortables.push(options);
 446
 447     // for onupdate
 448     Draggables.addObserver(new SortableObserver(element, options.onUpdate));
 449
 450   },
 451
 452   // return all suitable-for-sortable elements in a guaranteed order
 453   findElements: function(element, options) {
 454     if(!element.hasChildNodes()) return null;
 455     var elements = [];
 456     var children = element.childNodes;
 457     for(var i = 0; i<children.length; i++) {
 458       if(children[i].tagName && children[i].tagName==options.tag.toUpperCase() &&
 459         (!options.only || (Element.Class.has(children[i], options.only))))
 460           elements.push(children[i]);
 461       if(options.tree) {
 462         var grandchildren = this.findElements(children[i], options);
 463         if(grandchildren) elements.push(grandchildren);
 464       }
 465     }
 466
 467     return (elements.length>0 ? elements.flatten() : null);
 468   },
 469
 470   onHover: function(element, dropon, overlap) {
 471     if(overlap>0.5) {
 472       Sortable.mark(dropon, 'before');
 473       if(dropon.previousSibling != element) {
 474         var oldParentNode = element.parentNode;
 475         element.style.visibility = "hidden"; // fix gecko rendering
 476         dropon.parentNode.insertBefore(element, dropon);
 477         if(dropon.parentNode!=oldParentNode)
 478           Sortable.options(oldParentNode).onChange(element);
 479         Sortable.options(dropon.parentNode).onChange(element);
 480       }
 481     } else {
 482       Sortable.mark(dropon, 'after');
 483       var nextElement = dropon.nextSibling || null;
 484       if(nextElement != element) {
 485         var oldParentNode = element.parentNode;
 486         element.style.visibility = "hidden"; // fix gecko rendering
 487         dropon.parentNode.insertBefore(element, nextElement);
 488         if(dropon.parentNode!=oldParentNode)
 489           Sortable.options(oldParentNode).onChange(element);
 490         Sortable.options(dropon.parentNode).onChange(element);
 491       }
 492     }
 493   },
 494
 495   onEmptyHover: function(element, dropon) {
 496     if(element.parentNode!=dropon) {
 497       dropon.appendChild(element);
 498     }
 499   },
 500
 501   unmark: function() {
 502     if(Sortable._marker) Element.hide(Sortable._marker);
 503   },
 504
 505   mark: function(dropon, position) {
 506     // mark on ghosting only
 507     var sortable = Sortable.options(dropon.parentNode);
 508     if(sortable && !sortable.ghosting) return;
 509
 510     if(!Sortable._marker) {
 511       Sortable._marker = $('dropmarker') || document.createElement('DIV');
 512       Element.hide(Sortable._marker);
 513       Element.Class.add(Sortable._marker, 'dropmarker');
 514       Sortable._marker.style.position = 'absolute';
 515       document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
 516     }
 517     var offsets = Position.cumulativeOffset(dropon);
 518     Sortable._marker.style.top  = offsets[1] + 'px';
 519     if(position=='after') Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';
 520     Sortable._marker.style.left = offsets[0] + 'px';
 521     Element.show(Sortable._marker);
 522   },
 523
 524   serialize: function(element) {
 525     element = $(element);
 526     var sortableOptions = this.options(element);
 527     var options = Object.extend({
 528       tag:  sortableOptions.tag,
 529       only: sortableOptions.only,
 530       name: element.id
 531     }, arguments[1] || {});
 532
 533     var items = $(element).childNodes;
 534     var queryComponents = new Array();
 535
 536     for(var i=0; i<items.length; i++)
 537       if(items[i].tagName && items[i].tagName==options.tag.toUpperCase() &&
 538         (!options.only || (Element.Class.has(items[i], options.only))))
 539         queryComponents.push(
 540           encodeURIComponent(options.name) + "[]=" +
 541           encodeURIComponent(items[i].id.split("_")[1]));
 542
 543     return queryComponents.join("&");
 544   }
 545 }