}      }    } else {      this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;      this.options.scroll.scrollTop  += this.scrollSpeed[1] * delta / 1000;    }        Position.prepare();    Droppables.show(Draggables._lastPointer, this.element);    Draggables.notify('onDrag', this);    Draggables._lastScrollPointer = Draggables._lastScrollPointer || $A(Draggables._lastPointer);    Draggables._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;    Draggables._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;    if (Draggables._lastScrollPointer[0] < 0)      Draggables._lastScrollPointer[0] = 0;    if (Draggables._lastScrollPointer[1] < 0)      Draggables._lastScrollPointer[1] = 0;    this.draw(Draggables._lastScrollPointer);        if(this.options.change) this.options.change(this);  },    _getWindowScroll: function(w) {    var T, L, W, H;    with (w.document) {      if (w.document.documentElement && documentElement.scrollTop) {        T = documentElement.scrollTop;        L = documentElement.scrollLeft;      } else if (w.document.body) {        T = body.scrollTop;        L = body.scrollLeft;      }      if (w.innerWidth) {        W = w.innerWidth;        H = w.innerHeight;      } else if (w.document.documentElement && documentElement.clientWidth) {        W = documentElement.clientWidth;        H = documentElement.clientHeight;      } else {        W = body.offsetWidth;        H = body.offsetHeight      }    }    return { top: T, left: L, width: W, height: H };  }}/*--------------------------------------------------------------------------*/var SortableObserver = Class.create();SortableObserver.prototype = {  initialize: function(element, observer) {    this.element   = $(element);    this.observer  = observer;    this.lastValue = Sortable.serialize(this.element);  },    onStart: function() {    this.lastValue = Sortable.serialize(this.element);  },    onEnd: function() {    Sortable.unmark();    if(this.lastValue != Sortable.serialize(this.element))      this.observer(this.element)  }}var Sortable = {  sortables: {},    _findRootElement: function(element) {    while (element.tagName != "BODY") {        if(element.id && Sortable.sortables[element.id]) return element;      element = element.parentNode;    }  },  options: function(element) {    element = Sortable._findRootElement($(element));    if(!element) return;    return Sortable.sortables[element.id];  },    destroy: function(element){    var s = Sortable.options(element);        if(s) {      Draggables.removeObserver(s.element);      s.droppables.each(function(d){ Droppables.remove(d) });      s.draggables.invoke('destroy');            delete Sortable.sortables[s.element.id];    }  },  create: function(element) {    element = $(element);    var options = Object.extend({       element:     element,      tag:         'li',       // assumes li children, override with tag: 'tagname'      dropOnEmpty: false,      tree:        false,      treeTag:     'ul',      overlap:     'vertical', // one of 'vertical', 'horizontal'      constraint:  'vertical', // one of 'vertical', 'horizontal', false      containment: element,    // also takes array of elements (or id's); or false      handle:      false,      // or a CSS class      only:        false,      hoverclass:  null,      ghosting:    false,      scroll:      false,      scrollSensitivity: 20,      scrollSpeed: 15,      format:      /^[^_]*_(.*)$/,      onChange:    Prototype.emptyFunction,      onUpdate:    Prototype.emptyFunction    }, arguments[1] || {});    // clear any old sortable with same element    this.destroy(element);    // build options for the draggables    var options_for_draggable = {      revert:      true,      scroll:      options.scroll,      scrollSpeed: options.scrollSpeed,      scrollSensitivity: options.scrollSensitivity,      ghosting:    options.ghosting,      constraint:  options.constraint,      handle:      options.handle };    if(options.starteffect)      options_for_draggable.starteffect = options.starteffect;    if(options.reverteffect)      options_for_draggable.reverteffect = options.reverteffect;    else      if(options.ghosting) options_for_draggable.reverteffect = function(element) {        element.style.top  = 0;        element.style.left = 0;      };    if(options.endeffect)      options_for_draggable.endeffect = options.endeffect;    if(options.zindex)      options_for_draggable.zindex = options.zindex;    // build options for the droppables      var options_for_droppable = {      overlap:     options.overlap,      containment: options.containment,      tree:        options.tree,      hoverclass:  options.hoverclass,      onHover:     Sortable.onHover      //greedy:      !options.dropOnEmpty    }        var options_for_tree = {      onHover:      Sortable.onEmptyHover,      overlap:      options.overlap,      containment:  options.containment,      hoverclass:   options.hoverclass    }    // fix for gecko engine    Element.cleanWhitespace(element);     options.draggables = [];    options.droppables = [];    // drop on empty handling    if(options.dropOnEmpty || options.tree) {      Droppables.add(element, options_for_tree);      options.droppables.push(element);    }    (this.findElements(element, options) || []).each( function(e) {      // handles are per-draggable      var handle = options.handle ?         Element.childrenWithClassName(e, options.handle)[0] : e;          options.draggables.push(        new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));      Droppables.add(e, options_for_droppable);      if(options.tree) e.treeNode = element;      options.droppables.push(e);          });        if(options.tree) {      (Sortable.findTreeElements(element, options) || []).each( function(e) {        Droppables.add(e, options_for_tree);        e.treeNode = element;        options.droppables.push(e);      });    }    // keep reference    this.sortables[element.id] = options;    // for onupdate    Draggables.addObserver(new SortableObserver(element, options.onUpdate));  },  // return all suitable-for-sortable elements in a guaranteed order  findElements: function(element, options) {    return Element.findChildren(      element, options.only, options.tree ? true : false, options.tag);  },    findTreeElements: function(element, options) {    return Element.findChildren(      element, options.only, options.tree ? true : false, options.treeTag);  },  onHover: function(element, dropon, overlap) {    if(Element.isParent(dropon, element)) return;    if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {      return;    } else if(overlap>0.5) {      Sortable.mark(dropon, 'before');      if(dropon.previousSibling != element) {        var oldParentNode = element.parentNode;        element.style.visibility = "hidden"; // fix gecko rendering        dropon.parentNode.insertBefore(element, dropon);        if(dropon.parentNode!=oldParentNode)           Sortable.options(oldParentNode).onChange(element);        Sortable.options(dropon.parentNode).onChange(element);      }    } else {      Sortable.mark(dropon, 'after');      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)           Sortable.options(oldParentNode).onChange(element);        Sortable.options(dropon.parentNode).onChange(element);      }    }  },    onEmptyHover: function(element, dropon, overlap) {    var oldParentNode = element.parentNode;    var droponOptions = Sortable.options(dropon);            if(!Element.isParent(dropon, element)) {      var index;            var children = Sortable.findElements(dropon, {tag: droponOptions.tag});      var child = null;                  if(children) {        var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);                for (index = 0; index < children.length; index += 1) {          if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {            offset -= Element.offsetSize (children[index], droponOptions.overlap);          } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {            child = index + 1 < children.length ? children[index + 1] : null;            break;          } else {            child = children[index];            break;          }        }      }            dropon.insertBefore(element, child);            Sortable.options(oldParentNode).onChange(element);      droponOptions.onChange(element);    }  },  unmark: function() {    if(Sortable._marker) Element.hide(Sortable._marker);  },  mark: function(dropon, position) {    // mark on ghosting only    var sortable = Sortable.options(dropon.parentNode);    if(sortable && !sortable.ghosting) return;     if(!Sortable._marker) {      Sortable._marker = $('dropmarker') || document.createElement('DIV');      Element.hide(Sortable._marker);      Element.addClassName(Sortable._marker, 'dropmarker');      Sortable._marker.style.position = 'absolute';      document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);    }        var offsets = Position.cumulativeOffset(dropon);    Sortable._marker.style.left = offsets[0] + 'px';    Sortable._marker.style.top = offsets[1] + 'px';        if(position=='after')      if(sortable.overlap == 'horizontal')         Sortable._marker.style.left = (offsets[0]+dropon.clientWidth) + 'px';      else        Sortable._marker.style.top = (offsets[1]+dropon.clientHeight) + 'px';        Element.show(Sortable._marker);  },    _tree: function(element, options, parent) {    var children = Sortable.findElements(element, options) || [];      for (var i = 0; i < children.length; ++i) {      var match = children[i].id.match(options.format);      if (!match) continue;            var child = {        id: encodeURIComponent(match ? match[1] : null),        element: element,        parent: parent,        children: new Array,        position: parent.children.length,        container: Sortable._findChildrenElement(children[i], options.treeTag.toUpperCase())      }            /* Get the element containing the children and recurse over it */      if (child.container)        this._tree(child.container, options, child)            parent.children.push (child);    }    return parent;   },  /* Finds the first element of the given tag type within a parent element.    Used for finding the first LI[ST] within a L[IST]I[TEM].*/  _findChildrenElement: function (element, containerTag) {    if (element && element.hasChildNodes)      for (var i = 0; i < element.childNodes.length; ++i)        if (element.childNodes[i].tagName == containerTag)          return element.childNodes[i];      return null;  },  tree: function(element) {    element = $(element);    var sortableOptions = this.options(element);    var options = Object.extend({      tag: sortableOptions.tag,      treeTag: sortableOptions.treeTag,      only: sortableOptions.only,      name: element.id,      format: sortableOptions.format    }, arguments[1] || {});        var root = {      id: null,      parent: null,      children: new Array,      container: element,      position: 0    }        return Sortable._tree (element, options, root);  },  /* Construct a [i] index for a particular node */  _constructIndex: function(node) {    var index = '';    do {      if (node.id) index = '[' + node.position + ']' + index;    } while ((node = node.parent) != null);    return index;  },  sequence: function(element) {    element = $(element);    var options = Object.extend(this.options(element), arguments[1] || {});        return $(this.findElements(element, options) || []).map( function(item) {      return item.id.match(options.format) ? item.id.match(options.format)[1] : '';    });  },  setSequence: function(element, new_sequence) {    element = $(element);    var options = Object.extend(this.options(element), arguments[2] || {});        var nodeMap = {};    this.findElements(element, options).each( function(n) {        if (n.id.match(options.format))            nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];        n.parentNode.removeChild(n);    });       new_sequence.each(function(ident) {      var n = nodeMap[ident];      if (n) {        n[1].appendChild(n[0]);        delete nodeMap[ident];      }    });  },    serialize: function(element) {    element = $(element);    var options = Object.extend(Sortable.options(element), arguments[1] || {});    var name = encodeURIComponent(      (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);        if (options.tree) {      return Sortable.tree(element, arguments[1]).children.map( function (item) {        return [name + Sortable._constructIndex(item) + "=" +                 encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));      }).flatten().join('&');    } else {      return Sortable.sequence(element, arguments[1]).map( function(item) {        return name + "[]=" + encodeURIComponent(item);      }).join('&');    }  }}/* Returns true if child is contained within element */Element.isParent = function(child, element) {  if (!child.parentNode || child == element) return false;  if (child.parentNode == element) return true;  return Element.isParent(child.parentNode, element);}Element.findChildren = function(element, only, recursive, tagName) {      if(!element.hasChildNodes()) return null;  tagName = tagName.toUpperCase();  if(only) only = [only].flatten();  var elements = [];  $A(element.childNodes).each( function(e) {    if(e.tagName && e.tagName.toUpperCase()==tagName &&      (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))        elements.push(e);    if(recursive) {      var grandchildren = Element.findChildren(e, only, recursive, tagName);      if(grandchildren) elements.push(grandchildren);    }  });  return (elements.length>0 ? elements.flatten() : []);}Element.offsetSize = function (element, type) {  if (type == 'vertical' || type == 'height')    return element.offsetHeight;  else    return element.offsetWidth;}