/[webpac2]/Webpacus/root/js/dragdrop.js
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /Webpacus/root/js/dragdrop.js

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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