lib/dojo/dnd/Moveable.js.uncompressed.js

   1 define("dojo/dnd/Moveable", ["../main", "../Evented", "../touch", "./Mover"], function(dojo, Evented, touch) {
   2         // module:
   3         //              dojo/dnd/Moveable
   4         // summary:
   5         //              TODOC
   6
   7
   8 /*=====
   9 dojo.declare("dojo.dnd.__MoveableArgs", [], {
  10         // handle: Node||String
  11         //              A node (or node's id), which is used as a mouse handle.
  12         //              If omitted, the node itself is used as a handle.
  13         handle: null,
  14
  15         // delay: Number
  16         //              delay move by this number of pixels
  17         delay: 0,
  18
  19         // skip: Boolean
  20         //              skip move of form elements
  21         skip: false,
  22
  23         // mover: Object
  24         //              a constructor of custom Mover
  25         mover: dojo.dnd.Mover
  26 });
  27 =====*/
  28
  29 dojo.declare("dojo.dnd.Moveable", [Evented], {
  30         // object attributes (for markup)
  31         handle: "",
  32         delay: 0,
  33         skip: false,
  34
  35         constructor: function(node, params){
  36                 // summary:
  37                 //              an object, which makes a node moveable
  38                 // node: Node
  39                 //              a node (or node's id) to be moved
  40                 // params: dojo.dnd.__MoveableArgs?
  41                 //              optional parameters
  42                 this.node = dojo.byId(node);
  43                 if(!params){ params = {}; }
  44                 this.handle = params.handle ? dojo.byId(params.handle) : null;
  45                 if(!this.handle){ this.handle = this.node; }
  46                 this.delay = params.delay > 0 ? params.delay : 0;
  47                 this.skip  = params.skip;
  48                 this.mover = params.mover ? params.mover : dojo.dnd.Mover;
  49                 this.events = [
  50                         dojo.connect(this.handle, touch.press, this, "onMouseDown"),
  51                         // cancel text selection and text dragging
  52                         dojo.connect(this.handle, "ondragstart",   this, "onSelectStart"),
  53                         dojo.connect(this.handle, "onselectstart", this, "onSelectStart")
  54                 ];
  55         },
  56
  57         // markup methods
  58         markupFactory: function(params, node, ctor){
  59                 return new ctor(node, params);
  60         },
  61
  62         // methods
  63         destroy: function(){
  64                 // summary:
  65                 //              stops watching for possible move, deletes all references, so the object can be garbage-collected
  66                 dojo.forEach(this.events, dojo.disconnect);
  67                 this.events = this.node = this.handle = null;
  68         },
  69
  70         // mouse event processors
  71         onMouseDown: function(e){
  72                 // summary:
  73                 //              event processor for onmousedown/ontouchstart, creates a Mover for the node
  74                 // e: Event
  75                 //              mouse/touch event
  76                 if(this.skip && dojo.dnd.isFormElement(e)){ return; }
  77                 if(this.delay){
  78                         this.events.push(
  79                                 dojo.connect(this.handle, touch.move, this, "onMouseMove"),
  80                                 dojo.connect(this.handle, touch.release, this, "onMouseUp")
  81                         );
  82                         this._lastX = e.pageX;
  83                         this._lastY = e.pageY;
  84                 }else{
  85                         this.onDragDetected(e);
  86                 }
  87                 dojo.stopEvent(e);
  88         },
  89         onMouseMove: function(e){
  90                 // summary:
  91                 //              event processor for onmousemove/ontouchmove, used only for delayed drags
  92                 // e: Event
  93                 //              mouse/touch event
  94                 if(Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay){
  95                         this.onMouseUp(e);
  96                         this.onDragDetected(e);
  97                 }
  98                 dojo.stopEvent(e);
  99         },
 100         onMouseUp: function(e){
 101                 // summary:
 102                 //              event processor for onmouseup, used only for delayed drags
 103                 // e: Event
 104                 //              mouse event
 105                 for(var i = 0; i < 2; ++i){
 106                         dojo.disconnect(this.events.pop());
 107                 }
 108                 dojo.stopEvent(e);
 109         },
 110         onSelectStart: function(e){
 111                 // summary:
 112                 //              event processor for onselectevent and ondragevent
 113                 // e: Event
 114                 //              mouse event
 115                 if(!this.skip || !dojo.dnd.isFormElement(e)){
 116                         dojo.stopEvent(e);
 117                 }
 118         },
 119
 120         // local events
 121         onDragDetected: function(/* Event */ e){
 122                 // summary:
 123                 //              called when the drag is detected;
 124                 //              responsible for creation of the mover
 125                 new this.mover(this.node, e, this);
 126         },
 127         onMoveStart: function(/* dojo.dnd.Mover */ mover){
 128                 // summary:
 129                 //              called before every move operation
 130                 dojo.publish("/dnd/move/start", [mover]);
 131                 dojo.addClass(dojo.body(), "dojoMove");
 132                 dojo.addClass(this.node, "dojoMoveItem");
 133         },
 134         onMoveStop: function(/* dojo.dnd.Mover */ mover){
 135                 // summary:
 136                 //              called after every move operation
 137                 dojo.publish("/dnd/move/stop", [mover]);
 138                 dojo.removeClass(dojo.body(), "dojoMove");
 139                 dojo.removeClass(this.node, "dojoMoveItem");
 140         },
 141         onFirstMove: function(/* dojo.dnd.Mover */ mover, /* Event */ e){
 142                 // summary:
 143                 //              called during the very first move notification;
 144                 //              can be used to initialize coordinates, can be overwritten.
 145
 146                 // default implementation does nothing
 147         },
 148         onMove: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop, /* Event */ e){
 149                 // summary:
 150                 //              called during every move notification;
 151                 //              should actually move the node; can be overwritten.
 152                 this.onMoving(mover, leftTop);
 153                 var s = mover.node.style;
 154                 s.left = leftTop.l + "px";
 155                 s.top  = leftTop.t + "px";
 156                 this.onMoved(mover, leftTop);
 157         },
 158         onMoving: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
 159                 // summary:
 160                 //              called before every incremental move; can be overwritten.
 161
 162                 // default implementation does nothing
 163         },
 164         onMoved: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
 165                 // summary:
 166                 //              called after every incremental move; can be overwritten.
 167
 168                 // default implementation does nothing
 169         }
 170 });
 171
 172 return dojo.dnd.Moveable;
 173 });