rem
stringlengths 0
126k
| add
stringlengths 0
441k
| context
stringlengths 13
136k
| meta
stringlengths 132
347
|
|---|---|---|---|
if (gBrowserIs.gecko) { debug.print("finishImport: normalizing for gecko workaround"); document.normalize(); } | function cqOnLoad() { debug.print("cqOnLoad: begin"); // register for key-presses Event.observe(this, "keypress", handleKeyPress); // set up the UI objects gBuffers = new QueryBufferListClass("/cq:input", "/cq:eval-in", "/cq:buffer-list", "/cq:textarea-status"); gBuffers.initHandlers(); gHistory = new QueryHistoryClass("/cq:history", gBuffers); gBufferTabs = new BufferTabsClass("/cq:buffer-tabs", "/cq:buffer-accesskey-text", gBuffers, gHistory); // set the OS-specific instruction text gBufferTabs.setInstructionText(); gSession = new SessionClass(gBufferTabs, "/cq:restore-session"); gSession.restore(); // TODO enable autosave gSession.setAutoSave(); gBufferTabs.setSession(gSession); // enforce local policy, if any var policy = new PolicyClass("/cq:title", $F("/cq:policy/title"), "head1", $F("/cq:policy/accent-color")); policy.enforce(); // display the buffer list, exposing buffer 0 gBuffers.activate(); // once more, to fix widths gBufferTabs.refresh(); resizeFrameset(); // TODO save on unload // looks like we need prototype 1.5 for this: // "$A is not defined" at line 48, in the bind() code.... //Event.observe(parent.window, "unload", // gBufferTabs.unload.bindAsEventListener(gBufferTabs));} | 952 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/952/cf74ef313893031578d400b23f43029587880d43/query.js/clean/query.js |
|
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2069 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2069/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2069 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2069/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2069 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2069/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2069 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2069/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
|
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5523 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5523/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
|
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
create : function(n, c, p) { | create : function(n, c, p, h) { | create : function(n, c, p) { var d = this.doc, e = d.createElement(n); e.setAttribute('id', this.id); if (c) e.className = c; if (!p) p = d.body; p.appendChild(e); return this.element = e; }, | 10343 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/10343/524e24acf79702622c51dba4bb678337072e34b9/tiny_mce_src.js/clean/mambots/editors/tinymce/jscripts/tiny_mce/tiny_mce_src.js |
if (h) e.innerHTML = h; | create : function(n, c, p) { var d = this.doc, e = d.createElement(n); e.setAttribute('id', this.id); if (c) e.className = c; if (!p) p = d.body; p.appendChild(e); return this.element = e; }, | 10343 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/10343/524e24acf79702622c51dba4bb678337072e34b9/tiny_mce_src.js/clean/mambots/editors/tinymce/jscripts/tiny_mce/tiny_mce_src.js |
|
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 167 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/167/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 167 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/167/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 167 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/167/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 167 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/167/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
|
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 4687 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/4687/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 4687 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/4687/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 4687 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/4687/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 4687 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/4687/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 4053 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/4053/968de66848ffeb0b3f31d6319404feade4c70092/dragdrop.js/clean/src/dragdrop.js |
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 949 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/949/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 949 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/949/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 949 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/949/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 949 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/949/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 949 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/949/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1534 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1534/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
|
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2069 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2069/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
|
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1534 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1534/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1534 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1534/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1534 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1534/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1534 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1534/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 269 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/269/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5523 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5523/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
|
tree: false, | tree: false, treeTag: 'ul', | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
onHover: Sortable.onHover, greedy: !options.dropOnEmpty | onHover: Sortable.onHover } var options_for_tree = { onHover: Sortable.onEmptyHover, overlap: options.overlap, containment: options.containment, hoverclass: options.hoverclass | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
||
if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); | if(options.dropOnEmpty || options.tree) { Droppables.add(element, options_for_tree); | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
this.sortables.push(options); | this.sortables[element.id] = options; | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); 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); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 6649 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/6649/bb2276098a5a21c35e5ee72b3097bd9d7caa919f/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 5521 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5521/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/buggy/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
|
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 107 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/107/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
|
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 1534 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1534/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
|
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 107 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/107/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 107 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/107/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 107 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/107/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 107 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/107/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 2338 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/2338/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
|
format: null, | create: function(element) { element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' dropOnEmpty: false, tree: false, // fixme: unimplemented 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, 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, hoverclass: options.hoverclass, onHover: Sortable.onHover, greedy: !options.dropOnEmpty } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so // drop on empty handling if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 167 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/167/7d101d58400acaff232091485c8e140f0a37cbaf/dragdrop.js/clean/railties/html/javascripts/dragdrop.js |
|
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5523 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5523/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5523 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5523/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5523 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5523/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 5523 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/5523/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/buggy/railties/html/javascripts/dragdrop.js |
var element = $(element); | element = $(element); | create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
||
create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
||
handle: handle }; | handle: options.handle }; | create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
||
onHover: function(element, dropon, overlap) { if(overlap>0.5) { if(dropon.previousSibling != element) { var oldParentNode = element.parentNode; element.style.visibility = "hidden"; 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"; dropon.parentNode.insertBefore(element, nextElement); if(dropon.parentNode!=oldParentNode && oldParentNode.sortable) oldParentNode.sortable.onChange(element); if(dropon.parentNode.sortable) dropon.parentNode.sortable.onChange(element); } } } | onHover: Sortable.onHover, greedy: !options.dropOnEmpty | create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
||
var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } | if(options.dropOnEmpty) { Droppables.add(element, {containment: options.containment, onHover: Sortable.onEmptyHover, greedy: false}); options.droppables.push(element); } (this.findElements(element, options) || []).each( function(e) { var handle = options.handle ? Element.Class.childrenWith(e, options.handle)[0] : e; options.draggables.push( new Draggable(e, Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(e, options_for_droppable); options.droppables.push(e); }); | create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
create: function(element) { var element = $(element); var options = Object.extend({ element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }, arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate Draggables.addObserver(new SortableObserver(element, options.onUpdate)); }, | 742 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/742/3f913f897829fb026ef98df2d57f8da94ee5339d/dragdrop.js/clean/public/javascripts/dragdrop.js |
||
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
}.extend(arguments[1] || {}); | }, arguments[1] || {}); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); | options.draggables.push(new Draggable(elements[i], Object.extend(options_for_draggable, { handle: handle }))); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); | Draggables.addObserver(new SortableObserver(element, options.onUpdate)); | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 1604 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/1604/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
var options = { | var options = Object.extend({ | create: function(element) { var element = $(element); var options = { element: element, tag: 'li', // assumes li children, override with tag: 'tagname' 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, onChange: function() {}, onUpdate: function() {} }.extend(arguments[1] || {}); // clear any old sortable with same element this.destroy(element); // build options for the draggables var options_for_draggable = { revert: true, constraint: options.constraint, handle: handle }; if(options.starteffect) options_for_draggable.starteffect = options.starteffect; if(options.reverteffect) options_for_draggable.reverteffect = options.reverteffect; 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, hoverclass: options.hoverclass, onHover: function(element, dropon, overlap) { if(overlap>0.5) { 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); } } } } // fix for gecko engine Element.cleanWhitespace(element); options.draggables = []; options.droppables = []; // make it so var elements = element.childNodes; for (var i = 0; i < elements.length; i++) if(elements[i].tagName && elements[i].tagName==options.tag.toUpperCase() && (!options.only || (Element.Class.has(elements[i], options.only)))) { // handles are per-draggable var handle = options.handle ? Element.Class.childrenWith(elements[i], options.handle)[0] : elements[i]; options.draggables.push(new Draggable(elements[i], options_for_draggable.extend({ handle: handle }))); Droppables.add(elements[i], options_for_droppable); options.droppables.push(elements[i]); } // keep reference this.sortables.push(options); // for onupdate options.observer = new SortableObserver(element, options.onUpdate); Draggables.addObserver(options.observer); }, | 4687 /local1/tlutelli/issta_data/temp/all_js/javascript/2006_temp/2006/4687/16669774903dd7bfaaf1bf8f0c72e49ebaeffeeb/dragdrop.js/clean/actionpack/lib/action_view/helpers/javascripts/dragdrop.js |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.