summaryrefslogtreecommitdiff
path: root/frontend/beta/js/YUI-extensions/dd
Unidiff
Diffstat (limited to 'frontend/beta/js/YUI-extensions/dd') (more/less context) (ignore whitespace changes)
-rw-r--r--frontend/beta/js/YUI-extensions/dd/DragSource.js218
-rw-r--r--frontend/beta/js/YUI-extensions/dd/DragZone.js64
-rw-r--r--frontend/beta/js/YUI-extensions/dd/DropTarget.js45
-rw-r--r--frontend/beta/js/YUI-extensions/dd/DropZone.js81
-rw-r--r--frontend/beta/js/YUI-extensions/dd/Registry.js80
-rw-r--r--frontend/beta/js/YUI-extensions/dd/ScrollManager.js171
-rw-r--r--frontend/beta/js/YUI-extensions/dd/StatusProxy.js110
7 files changed, 769 insertions, 0 deletions
diff --git a/frontend/beta/js/YUI-extensions/dd/DragSource.js b/frontend/beta/js/YUI-extensions/dd/DragSource.js
new file mode 100644
index 0000000..efee2d6
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/DragSource.js
@@ -0,0 +1,218 @@
1// kill drag drop dependency
2if(YAHOO.util.DragDrop){
3
4YAHOO.ext.dd.DragSource = function(el, config){
5 this.el = getEl(el);
6 this.dragData = {};
7
8 YAHOO.ext.util.Config.apply(this, config);
9
10 if(!this.proxy){
11 this.proxy = new YAHOO.ext.dd.StatusProxy();
12 }
13 this.el.on('mouseup', this.handleMouseUp);
14 YAHOO.ext.dd.DragSource.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group,
15 {dragElId : this.proxy.id, resizeFrame: false, isTarget: false, scroll: this.scroll === true});
16
17 this.dragging = false;
18};
19
20YAHOO.extendX(YAHOO.ext.dd.DragSource, YAHOO.util.DDProxy, {
21 dropAllowed : 'ydd-drop-ok',
22 dropNotAllowed : 'ydd-drop-nodrop',
23
24 getDragData : function(e){
25 return this.dragData;
26 },
27
28 onDragEnter : function(e, id){
29 var target = YAHOO.util.DragDropMgr.getDDById(id);
30 this.cachedTarget = target;
31 if(this.beforeDragEnter(target, e, id) !== false){
32 if(target.isNotifyTarget){
33 var status = target.notifyEnter(this, e, this.dragData);
34 this.proxy.setStatus(status);
35 }else{
36 this.proxy.setStatus(this.dropAllowed);
37 }
38
39 if(this.afterDragEnter){
40 this.afterDragEnter(target, e, id);
41 }
42 }
43 },
44
45 beforeDragEnter : function(target, e, id){
46 return true;
47 },
48
49 alignElWithMouse: function() {
50 YAHOO.ext.dd.DragSource.superclass.alignElWithMouse.apply(this, arguments);
51 this.proxy.sync();
52 },
53
54 onDragOver : function(e, id){
55 var target = this.cachedTarget || YAHOO.util.DragDropMgr.getDDById(id);
56 if(this.beforeDragOver(target, e, id) !== false){
57 if(target.isNotifyTarget){
58 var status = target.notifyOver(this, e, this.dragData);
59 this.proxy.setStatus(status);
60 }
61
62 if(this.afterDragOver){
63 this.afterDragOver(target, e, id);
64 }
65 }
66 },
67
68 beforeDragOver : function(target, e, id){
69 return true;
70 },
71
72 onDragOut : function(e, id){
73 var target = this.cachedTarget || YAHOO.util.DragDropMgr.getDDById(id);
74 if(this.beforeDragOut(target, e, id) !== false){
75 if(target.isNotifyTarget){
76 target.notifyOut(this, e, this.dragData);
77 }
78 this.proxy.reset();
79 if(this.afterDragOut){
80 this.afterDragOut(target, e, id);
81 }
82 }
83 this.cachedTarget = null;
84 },
85
86 beforeDragOut : function(target, e, id){
87 return true;
88 },
89
90
91 onDragDrop : function(e, id){
92 var target = this.cachedTarget || YAHOO.util.DragDropMgr.getDDById(id);
93 if(this.beforeDragDrop(target, e, id) !== false){
94 if(target.isNotifyTarget){
95 if(target.notifyDrop(this, e, this.dragData)){ // valid drop?
96 this.onValidDrop(target, e, id);
97 }else{
98 this.onInvalidDrop(target, e, id);
99 }
100 }else{
101 this.onValidDrop(target, e, id);
102 }
103
104 if(this.afterDragDrop){
105 this.afterDragDrop(target, e, id);
106 }
107 }
108 },
109
110 beforeDragDrop : function(target, e, id){
111 return true;
112 },
113
114 onValidDrop : function(target, e, id){
115 this.hideProxy();
116 },
117
118 getRepairXY : function(e, data){
119 return this.el.getXY();
120 },
121
122 onInvalidDrop : function(target, e, id){
123 this.beforeInvalidDrop(target, e, id);
124 if(this.cachedTarget){
125 if(this.cachedTarget.isNotifyTarget){
126 this.cachedTarget.notifyOut(this, e, this.dragData);
127 }
128 this.cacheTarget = null;
129 }
130 this.proxy.repair(this.getRepairXY(e, this.dragData), this.afterRepair, this);
131 if(this.afterInvalidDrop){
132 this.afterInvalidDrop(e, id);
133 }
134 },
135
136 afterRepair : function(){
137 this.el.highlight(this.hlColor || 'c3daf9');
138 this.dragging = false;
139 },
140
141 beforeInvalidDrop : function(target, e, id){
142 return true;
143 },
144
145 handleMouseDown : function(e){
146 if(this.dragging) {
147 return;
148 }
149 if(YAHOO.ext.QuickTips){
150 YAHOO.ext.QuickTips.disable();
151 }
152 var data = this.getDragData(e);
153 if(data && this.onBeforeDrag(data, e) !== false){
154 this.dragData = data;
155 this.proxy.stop();
156 YAHOO.ext.dd.DragSource.superclass.handleMouseDown.apply(this, arguments);
157 }
158 },
159
160 handleMouseUp : function(e){
161 if(YAHOO.ext.QuickTips){
162 YAHOO.ext.QuickTips.enable();
163 }
164 },
165
166 onBeforeDrag : function(data, e){
167 return true;
168 },
169
170 startDrag : function(e){
171 this.proxy.reset();
172 this.dragging = true;
173 this.proxy.update('');
174 this.onInitDrag(e);
175 this.proxy.show();
176 },
177
178 onInitDrag : function(e){
179 var clone = this.el.dom.cloneNode(true);
180 clone.id = YAHOO.util.Dom.generateId(); // prevent duplicate ids
181 this.proxy.update(clone);
182 return true;
183 },
184
185
186 getProxy : function(){
187 return this.proxy;
188 },
189
190 hideProxy : function(){
191 this.proxy.hide();
192 this.proxy.reset(true);
193 this.dragging = false;
194 },
195
196 triggerCacheRefresh : function(){
197 YAHOO.util.DDM.refreshCache(this.groups);
198 },
199
200 // override to prevent hiding
201 b4EndDrag: function(e) {
202 },
203
204 // override to prevent moving
205 endDrag : function(e){
206 this.onEndDrag(this.dragData, e);
207 },
208
209 onEndDrag : function(data, e){
210
211 },
212
213 // pin to cursor
214 autoOffset : function(x, y) {
215 this.setDelta(-12, -20);
216 }
217});
218}
diff --git a/frontend/beta/js/YUI-extensions/dd/DragZone.js b/frontend/beta/js/YUI-extensions/dd/DragZone.js
new file mode 100644
index 0000000..7a6edb6
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/DragZone.js
@@ -0,0 +1,64 @@
1// kill drag drop dependency
2if(YAHOO.util.DragDrop){
3/**
4 * @class YAHOO.ext.dd.DragZone
5 * @extends YAHOO.ext.dd.Source
6 * This class provides a container DD instance that proxies for multiple child node sources.<br />
7 * By default, this class requires that draggable child nodes are registered with
8 * {@link YAHOO.ext.dd.Registry}.
9 * @cfg {Boolean} containerScroll True to register this container with the Scrollmanager
10 * for auto scrolling during drag operations.
11 * @constructor
12 * @param {String/HTMLElement/Element} el The container element
13 * @param {Object} config
14 */
15YAHOO.ext.dd.DragZone = function(el, config){
16 YAHOO.ext.dd.DragZone.superclass.constructor.call(this, el, config);
17 if(this.containerScroll){
18 YAHOO.ext.dd.ScrollManager.register(this.el);
19 }
20};
21
22YAHOO.extendX(YAHOO.ext.dd.DragZone, YAHOO.ext.dd.DragSource, {
23 /**
24 * Called when a mousedown occurs in this container. Looks in {@link YAHOO.ext.dd.Registry}
25 * for a valid target to drag based on the mouse down. Override this method
26 * to provide your own lookup logic (e.g. finding a child by class name). Make sure your returned
27 * object has a "ddel" attribute (with an HTML Element) for other functions to work.
28 * @param {EventObject} e The mouse down event
29 * @return {Object} The dragData
30 */
31 getDragData : function(e){
32 return YAHOO.ext.dd.Registry.getHandleFromEvent(e);
33 },
34
35 /**
36 * Called once drag threshold has been reached to initialize the proxy element. By default, it clones the
37 * this.dragData.ddel
38 * @param {EventObject} e The current event
39 * @return {Boolean} true to continue the drag, false to cancel
40 */
41 onInitDrag : function(e){
42 this.proxy.update(this.dragData.ddel.cloneNode(true));
43 return true;
44 },
45
46 /**
47 * Called after a repair of an invalid drop. By default, highlights this.dragData.ddel
48 */
49 afterRepair : function(){
50 YAHOO.ext.Element.fly(this.dragData.ddel).highlight(this.hlColor || 'c3daf9');
51 this.dragging = false;
52 },
53
54 /**
55 * Called before a repair of an invalid drop to get the XY to animate to. By default returns
56 * the XY of this.dragData.ddel
57 * @param {EventObject} e The mouse up event
58 * @return {Array} The xy location (e.g. [100, 200])
59 */
60 getRepairXY : function(e){
61 return YAHOO.ext.Element.fly(this.dragData.ddel).getXY();
62 }
63});
64}
diff --git a/frontend/beta/js/YUI-extensions/dd/DropTarget.js b/frontend/beta/js/YUI-extensions/dd/DropTarget.js
new file mode 100644
index 0000000..30e59cd
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/DropTarget.js
@@ -0,0 +1,45 @@
1// kill drag drop dependency
2if(YAHOO.util.DragDrop){
3
4YAHOO.ext.dd.DropTarget = function(el, config){
5 this.el = getEl(el);
6
7 YAHOO.ext.util.Config.apply(this, config);
8
9 if(this.containerScroll){
10 YAHOO.ext.dd.ScrollManager.register(this.el);
11 }
12
13 YAHOO.ext.dd.DropTarget.superclass.constructor.call(this, this.el.dom, this.ddGroup || this.group,
14 {isTarget: true});
15
16};
17
18YAHOO.extendX(YAHOO.ext.dd.DropTarget, YAHOO.util.DDTarget, {
19 isTarget : true,
20 isNotifyTarget : true,
21 dropAllowed : 'ydd-drop-ok',
22 dropNotAllowed : 'ydd-drop-nodrop',
23
24 notifyEnter : function(dd, e, data){
25 if(this.overClass){
26 this.el.addClass(this.overClass);
27 }
28 return this.dropAllowed;
29 },
30
31 notifyOver : function(dd, e, data){
32 return this.dropAllowed;
33 },
34
35 notifyOut : function(dd, e, data){
36 if(this.overClass){
37 this.el.removeClass(this.overClass);
38 }
39 },
40
41 notifyDrop : function(dd, e, data){
42 return false;
43 }
44});
45}
diff --git a/frontend/beta/js/YUI-extensions/dd/DropZone.js b/frontend/beta/js/YUI-extensions/dd/DropZone.js
new file mode 100644
index 0000000..ce446fb
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/DropZone.js
@@ -0,0 +1,81 @@
1// kill drag drop dependency
2if(YAHOO.util.DragDrop){
3YAHOO.ext.dd.DropZone = function(el, config){
4 YAHOO.ext.dd.DropZone.superclass.constructor.call(this, el, config);
5};
6
7YAHOO.extendX(YAHOO.ext.dd.DropZone, YAHOO.ext.dd.DropTarget, {
8 getTargetFromEvent : function(e){
9 return YAHOO.ext.dd.Registry.getTargetFromEvent(e);
10 },
11
12 onNodeEnter : function(n, dd, e, data){
13
14 },
15
16 onNodeOver : function(n, dd, e, data){
17 return this.dropAllowed;
18 },
19
20 onNodeOut : function(n, dd, e, data){
21
22 },
23
24 onNodeDrop : function(n, dd, e, data){
25 return false;
26 },
27
28 onContainerOver : function(n, dd, e, data){
29 return this.dropNotAllowed;
30 },
31
32 onContainerDrop : function(n, dd, e, data){
33 return false;
34 },
35
36 notifyEnter : function(dd, e, data){
37 return this.dropNotAllowed;
38 },
39
40 notifyOver : function(dd, e, data){
41 var n = this.getTargetFromEvent(e);
42 if(!n){ // not over valid drop target
43 if(this.lastOverNode){
44 this.onNodeOut(this.lastOverNode, dd, e, data);
45 this.lastOverNode = null;
46 }
47 return this.onContainerOver(dd, e, data);
48 }
49 if(this.lastOverNode != n){
50 if(this.lastOverNode){
51 this.onNodeOut(this.lastOverNode, dd, e, data);
52 }
53 this.onNodeEnter(n, dd, e, data);
54 this.lastOverNode = n;
55 }
56 return this.onNodeOver(n, dd, e, data);
57 },
58
59 notifyOut : function(dd, e, data){
60 if(this.lastOverNode){
61 this.onNodeOut(this.lastOverNode, dd, e, data);
62 this.lastOverNode = null;
63 }
64 },
65
66 notifyDrop : function(dd, e, data){
67 if(this.lastOverNode){
68 this.onNodeOut(this.lastOverNode, dd, e, data);
69 this.lastOverNode = null;
70 }
71 var n = this.getTargetFromEvent(e);
72 return n ?
73 this.onNodeDrop(n, dd, e, data) :
74 this.onContainerDrop(n, dd, e, data);
75 },
76
77 triggerCacheRefresh : function(){
78 YAHOO.util.DDM.refreshCache(this.groups);
79 }
80});
81}
diff --git a/frontend/beta/js/YUI-extensions/dd/Registry.js b/frontend/beta/js/YUI-extensions/dd/Registry.js
new file mode 100644
index 0000000..983b874
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/Registry.js
@@ -0,0 +1,80 @@
1// kill drag drop dependency
2if(YAHOO.util.DragDrop){
3
4YAHOO.ext.dd.Registry = function(){
5 var elements = {};
6 var handles = {};
7 var autoIdSeed = 0;
8 var doc = document; // local reference for IE
9
10 var getId = function(el, autogen){
11 if(typeof el == 'string'){
12 return el;
13 }
14 var id = el.id;
15 if(!id && autogen !== false){
16 id = 'yddgen-' + (++autoIdSeed);
17 el.id = id;
18 }
19 return id;
20 };
21
22 return {
23 register : function(el, data){
24 data = data || {};
25 if(typeof el == 'string'){
26 el = doc.getElementById(el);
27 }
28 data.ddel = el;
29 elements[getId(el)] = data;
30 if(data.isHandle !== false){
31 handles[data.ddel.id] = data;
32 }
33 if(data.handles){
34 var hs = data.handles;
35 for(var i = 0, len = hs.length; i < len; i++){
36 handles[getId(hs[i])] = data;
37 }
38 }
39 },
40
41 unregister : function(el){
42 var id = getId(el, false);
43 var data = elements[id];
44 if(data){
45 delete elements[id];
46 if(data.handles){
47 var hs = data.handles;
48 for(var i = 0, len = hs.length; i < len; i++){
49 delete handles[getId(hs[i], false)];
50 }
51 }
52 }
53 },
54
55 getHandle : function(id){
56 if(typeof id != 'string'){ // must be element?
57 id = id.id;
58 }
59 return handles[id];
60 },
61
62 getHandleFromEvent : function(e){
63 var t = YAHOO.util.Event.getTarget(e);
64 return t ? handles[t.id] : null;
65 },
66
67 getTarget : function(id){
68 if(typeof id != 'string'){ // must be element?
69 id = id.id;
70 }
71 return elements[id];
72 },
73
74 getTargetFromEvent : function(e){
75 var t = YAHOO.util.Event.getTarget(e);
76 return t ? elements[t.id] || handles[t.id] : null;
77 }
78 };
79}();
80}
diff --git a/frontend/beta/js/YUI-extensions/dd/ScrollManager.js b/frontend/beta/js/YUI-extensions/dd/ScrollManager.js
new file mode 100644
index 0000000..615aadf
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/ScrollManager.js
@@ -0,0 +1,171 @@
1// kill dependency issue
2if(YAHOO.util.DragDrop){
3/**
4 * @class YAHOO.ext.dd.ScrollManager
5 * Provides automatic scrolling of overflow regions in the page during drag operations.<br><br>
6 * <b>Note: This class uses "Point Mode" and is untested in "Intersect Mode".</b>
7 * @singleton
8 */
9YAHOO.ext.dd.ScrollManager = function(){
10 var ddm = YAHOO.util.DragDropMgr;
11 var els = {};
12 var dragEl = null;
13 var proc = {};
14
15 var onStop = function(e){
16 dragEl = null;
17 clearProc();
18 };
19
20 var triggerRefresh = function(){
21 if(ddm.dragCurrent){
22 ddm.refreshCache(ddm.dragCurrent.groups);
23 }
24 }
25
26 var doScroll = function(){
27 if(ddm.dragCurrent){
28 var dds = YAHOO.ext.dd.ScrollManager;
29 if(!dds.animate || !YAHOO.util.Scroll){
30 if(proc.el.scroll(proc.dir, dds.increment)){
31 triggerRefresh();
32 }
33 }else{
34 proc.el.scroll(proc.dir, dds.increment, true, dds.animDuration, triggerRefresh);
35 }
36 }
37 };
38
39 var clearProc = function(){
40 if(proc.id){
41 clearInterval(proc.id);
42 }
43 proc.id = 0;
44 proc.el = null;
45 proc.dir = '';
46 };
47
48 var startProc = function(el, dir){
49 clearProc();
50 proc.el = el;
51 proc.dir = dir;
52 proc.id = setInterval(doScroll, YAHOO.ext.dd.ScrollManager.frequency);
53 };
54
55 var onFire = function(e, isDrop){
56 if(isDrop || !ddm.dragCurrent){ return; }
57 var dds = YAHOO.ext.dd.ScrollManager;
58 if(!dragEl || dragEl != ddm.dragCurrent){
59 dragEl = ddm.dragCurrent;
60 // refresh regions on drag start
61 dds.refreshCache();
62 }
63
64 var xy = YAHOO.util.Event.getXY(e);
65 var pt = new YAHOO.util.Point(xy[0], xy[1]);
66 for(var id in els){
67 var el = els[id], r = el._region;
68 if(r.contains(pt) && el.isScrollable()){
69 if(r.bottom - pt.y <= dds.thresh){
70 if(proc.el != el){
71 startProc(el, 'down');
72 }
73 return;
74 }else if(r.right - pt.x <= dds.thresh){
75 if(proc.el != el){
76 startProc(el, 'left');
77 }
78 return;
79 }else if(pt.y - r.top <= dds.thresh){
80 if(proc.el != el){
81 startProc(el, 'up');
82 }
83 return;
84 }else if(pt.x - r.left <= dds.thresh){
85 if(proc.el != el){
86 startProc(el, 'right');
87 }
88 return;
89 }
90 }
91 }
92 clearProc();
93 };
94
95 ddm.fireEvents = ddm.fireEvents.createSequence(onFire, ddm);
96 ddm.stopDrag = ddm.stopDrag.createSequence(onStop, ddm);
97
98 return {
99 /**
100 * Registers new overflow element(s) to auto scroll
101 * @param {String/HTMLElement/Element/Array} el The id of or the element to be scrolled or an array of either
102 */
103 register : function(el){
104 if(el instanceof Array){
105 for(var i = 0, len = el.length; i < len; i++) {
106 this.register(el[i]);
107 }
108 }else{
109 el = getEl(el);
110 els[el.id] = el;
111 }
112 },
113
114 /**
115 * Unregisters overflow element(s) so they are no longer scrolled
116 * @param {String/HTMLElement/Element/Array} el The id of or the element to be removed or an array of either
117 */
118 unregister : function(el){
119 if(el instanceof Array){
120 for(var i = 0, len = el.length; i < len; i++) {
121 this.unregister(el[i]);
122 }
123 }else{
124 el = getEl(el);
125 delete els[el.id];
126 }
127 },
128
129 /**
130 * The number of pixels from the edge of a container the pointer needs to be to
131 * trigger scrolling (defaults to 25)
132 * @type Number
133 */
134 thresh : 25,
135
136 /**
137 * The number of pixels to scroll in each scroll increment (defaults to 50)
138 * @type Number
139 */
140 increment : 100,
141
142 /**
143 * The frequency of scrolls in milliseconds (defaults to 500)
144 * @type Number
145 */
146 frequency : 500,
147
148 /**
149 * True to animate the scroll (defaults to true)
150 * @type Boolean
151 */
152 animate: true,
153
154 /**
155 * The animation duration in seconds -
156 * MUST BE less than YAHOO.ext.dd.ScrollManager.frequency! (defaults to .4)
157 * @type Number
158 */
159 animDuration: .4,
160
161 /**
162 * Manually trigger a cache refresh.
163 */
164 refreshCache : function(){
165 for(var id in els){
166 els[id]._region = els[id].getRegion();
167 }
168 }
169 }
170}();
171}
diff --git a/frontend/beta/js/YUI-extensions/dd/StatusProxy.js b/frontend/beta/js/YUI-extensions/dd/StatusProxy.js
new file mode 100644
index 0000000..97de4d9
--- a/dev/null
+++ b/frontend/beta/js/YUI-extensions/dd/StatusProxy.js
@@ -0,0 +1,110 @@
1YAHOO.ext.dd.StatusProxy = function(config){
2 YAHOO.ext.util.Config.apply(this, config);
3 this.id = this.id || YAHOO.util.Dom.generateId();
4 this.el = new YAHOO.ext.Layer({
5 dh: {
6 id: this.id, tag: 'div', cls: 'ydd-drag-proxy '+this.dropNotAllowed, children: [
7 {tag: 'div', cls: 'ydd-drop-icon'},
8 {tag: 'div', cls: 'ydd-drag-ghost'}
9 ]
10 },
11 shadow: !config || config.shadow !== false
12 });
13 /*this.el = YAHOO.ext.DomHelper.insertBefore(document.body.firstChild, {
14 id: this.id, tag: 'div', cls: 'ydd-drag-proxy '+this.dropNotAllowed, children: [
15 {tag: 'div', cls: 'ydd-drop-icon'},
16 {tag: 'div', cls: 'ydd-drag-ghost'}
17 ]
18 }, true);*/
19 this.ghost = getEl(this.el.dom.childNodes[1]);
20 this.dropStatus = this.dropNotAllowed;
21};
22
23YAHOO.ext.dd.StatusProxy.prototype = {
24 dropAllowed : 'ydd-drop-ok',
25 dropNotAllowed : 'ydd-drop-nodrop',
26 /**
27 * Updates the DD visual element to allow/not allow a drop
28 * @param {String} cssClass The css class for the new drop status indicator image
29 */
30 setStatus : function(cssClass){
31 cssClass = cssClass || this.dropNotAllowed;
32 if(this.dropStatus != cssClass){
33 this.el.replaceClass(this.dropStatus, cssClass);
34 this.dropStatus = cssClass;
35 }
36 },
37
38 reset : function(clearGhost){
39 this.el.dom.className = 'ydd-drag-proxy ' + this.dropNotAllowed;
40 this.dropStatus = this.dropNotAllowed;
41 if(clearGhost){
42 this.ghost.update('');
43 }
44 },
45
46 update : function(html){
47 if(typeof html == 'string'){
48 this.ghost.update(html);
49 }else{
50 this.ghost.update('');
51 html.style.margin = '0';
52 this.ghost.dom.appendChild(html);
53 }
54 },
55
56 getEl : function(){
57 return this.el;
58 },
59
60 getGhost : function(){
61 return this.ghost;
62 },
63
64 hide : function(clear){
65 this.el.hide();
66 if(clear){
67 this.reset(true);
68 }
69 },
70
71 stop : function(){
72 if(this.anim && this.anim.isAnimated()){
73 this.anim.stop();
74 }
75 },
76
77 show : function(){
78 this.el.show();
79 },
80
81 sync : function(){
82 this.el.syncLocalXY();
83 },
84
85 repair : function(xy, callback, scope){
86 this.callback = callback;
87 this.scope = scope;
88 if(xy && this.animRepair !== false && YAHOO.util.Anim){
89 this.el.addClass('ydd-drag-repair');
90 this.el.hideUnders(true);
91 if(!this.anim){
92 this.anim = new YAHOO.util.Motion(this.el.dom, {}, this.repairDuration || .5, YAHOO.util.Easing.easeOut);
93 this.anim.onComplete.subscribe(this.afterRepair, this, true);
94 }
95 this.anim.attributes = {points: {to:xy}};
96 this.anim.animate();
97 }else{
98 this.afterRepair();
99 }
100 },
101
102 afterRepair : function(){
103 this.hide(true);
104 if(typeof this.callback == 'function'){
105 this.callback.call(this.scope || this);
106 }
107 this.callback == null;
108 this.scope == null;
109 }
110};