lib/dojo/dnd/Moveable.js

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