1 // Copyright (c) 2005 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
3 // Element.Class part Copyright (c) 2005 by Rick Olson
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:
13 // The above copyright notice and this permission notice shall be
14 // included in all copies or substantial portions of the Software.
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.
25 /*--------------------------------------------------------------------------*/
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);
36 add: function(element) {
38 var options = Object.extend({
41 }, arguments[1] || {});
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]));
52 options._containers.push($(containment));
54 options._containers_length =
55 options._containers.length-1;
58 Element.makePositioned(element); // fix IE
60 options.element = element;
62 // activate the droppable
63 if(!this.drops) this.drops = [];
64 this.drops.push(options);
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--);
75 isAffected: function(pX, pY, element, drop) {
77 (drop.element!=element) &&
78 ((!drop._containers) ||
79 this.isContained(element, drop)) &&
81 (Element.Class.has_any(element, drop.accept))) &&
82 Position.within(drop.element, pX, pY) );
85 deactivate: function(drop) {
86 Element.Class.remove(drop.element, drop.hoverclass);
87 this.last_active = null;
90 activate: function(drop) {
91 if(this.last_active) this.deactivate(this.last_active);
93 Element.Class.add(drop.element, drop.hoverclass);
94 this.last_active = drop;
97 show: function(event, element) {
98 if(!this.drops) return;
99 var pX = Event.pointerX(event);
100 var pY = Event.pointerY(event);
103 var i = this.drops.length-1; do {
104 var drop = this.drops[i];
105 if(this.isAffected(pX, pY, element, drop)) {
107 drop.onHover(element, drop.element, Position.overlap(drop.overlap, drop.element));
116 fire: function(event, element) {
117 if(!this.last_active) return;
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);
128 this.deactivate(this.last_active);
133 observers: new Array(),
134 addObserver: function(observer) {
135 this.observers.push(observer);
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);
142 notify: function(eventName, draggable) { // 'onStart', 'onEnd'
143 for(var i = 0; i < this.observers.length; i++)
144 this.observers[i][eventName](draggable);
148 /*--------------------------------------------------------------------------*/
150 var Draggable = Class.create();
151 Draggable.prototype = {
152 initialize: function(element) {
153 var options = Object.extend({
155 starteffect: function(element) {
156 new Effect.Opacity(element, {duration:0.2, from:1.0, to:0.7});
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});
162 endeffect: function(element) {
163 new Effect.Opacity(element, {duration:0.2, from:0.7, to:1.0});
167 }, arguments[1] || {});
169 this.element = $(element);
170 this.handle = options.handle ? $(options.handle) : this.element;
172 Element.makePositioned(this.element); // fix IE
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");
182 this.options = options;
185 this.dragging = false;
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);
192 Event.observe(this.handle, "mousedown", this.eventMouseDown);
194 destroy: function() {
195 Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
196 this.unregisterEvents();
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);
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);
210 currentLeft: function() {
211 return parseInt(this.element.style.left || '0');
213 currentTop: function() {
214 return parseInt(this.element.style.top || '0')
216 startDrag: function(event) {
217 if(Event.isLeftClick(event)) {
218 this.registerEvents();
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]);
227 finishDrag: function(event, success) {
228 this.unregisterEvents();
231 this.dragging = false;
233 if(this.options.ghosting) {
234 Position.relativize(this.element);
235 Element.remove(this._clone);
239 if(success) Droppables.fire(event, this.element);
240 Draggables.notify('onEnd', this);
242 var revert = this.options.revert;
243 if(revert && typeof revert == 'function') revert = revert(this.element);
245 if(revert && this.options.reverteffect) {
246 this.options.reverteffect(this.element,
247 this.currentTop()-this.originalTop,
248 this.currentLeft()-this.originalLeft);
250 this.originalLeft = this.currentLeft();
251 this.originalTop = this.currentTop();
254 this.element.style.zIndex = this.originalZ;
256 if(this.options.endeffect)
257 this.options.endeffect(this.element);
262 keyPress: function(event) {
264 if(event.keyCode==Event.KEY_ESC) {
265 this.finishDrag(event, false);
270 endDrag: function(event) {
271 if(this.active && this.dragging) {
272 this.finishDrag(event, true);
276 this.dragging = false;
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
290 update: function(event) {
293 var style = this.element.style;
294 this.dragging = true;
295 if(style.position=="") style.position = "relative";
296 style.zIndex = this.options.zindex;
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);
304 Draggables.notify('onStart', this);
305 if(this.options.starteffect) this.options.starteffect(this.element);
308 Droppables.show(event, this.element);
310 if(this.options.change) this.options.change(this);
312 // fix AppleWebKit rendering
313 if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
320 /*--------------------------------------------------------------------------*/
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);
329 onStart: function() {
330 this.lastValue = Sortable.serialize(this.element);
334 if(this.lastValue != Sortable.serialize(this.element))
335 this.observer(this.element)
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];
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);
362 create: function(element) {
363 element = $(element);
364 var options = Object.extend({
366 tag: 'li', // assumes li children, override with tag: 'tagname'
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
376 onChange: function() {},
377 onUpdate: function() {}
378 }, arguments[1] || {});
380 // clear any old sortable with same element
381 this.destroy(element);
383 // build options for the draggables
384 var options_for_draggable = {
386 ghosting: options.ghosting,
387 constraint: options.constraint,
390 if(options.starteffect)
391 options_for_draggable.starteffect = options.starteffect;
393 if(options.reverteffect)
394 options_for_draggable.reverteffect = options.reverteffect;
396 if(options.ghosting) options_for_draggable.reverteffect = function(element) {
397 element.style.top = 0;
398 element.style.left = 0;
401 if(options.endeffect)
402 options_for_draggable.endeffect = options.endeffect;
405 options_for_draggable.zindex = options.zindex;
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
416 // fix for gecko engine
417 Element.cleanWhitespace(element);
419 options.draggables = [];
420 options.droppables = [];
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);
431 var elements = this.findElements(element, options);
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);
440 options.droppables.push(elements[i]);
445 this.sortables.push(options);
448 Draggables.addObserver(new SortableObserver(element, options.onUpdate));
452 // return all suitable-for-sortable elements in a guaranteed order
453 findElements: function(element, options) {
454 if(!element.hasChildNodes()) return null;
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]);
462 var grandchildren = this.findElements(children[i], options);
463 if(grandchildren) elements.push(grandchildren);
467 return (elements.length>0 ? elements.flatten() : null);
470 onHover: function(element, dropon, overlap) {
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);
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);
495 onEmptyHover: function(element, dropon) {
496 if(element.parentNode!=dropon) {
497 dropon.appendChild(element);
502 if(Sortable._marker) Element.hide(Sortable._marker);
505 mark: function(dropon, position) {
506 // mark on ghosting only
507 var sortable = Sortable.options(dropon.parentNode);
508 if(sortable && !sortable.ghosting) return;
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);
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);
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,
531 }, arguments[1] || {});
533 var items = $(element).childNodes;
534 var queryComponents = new Array();
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]));
543 return queryComponents.join("&");