lib/dojo/dnd/Moveable.js

   1 /*
   2         Copyright (c) 2004-2010, 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
  12 dojo.require("dojo.dnd.Mover");
  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                         // cancel text selection and text dragging
  58                         dojo.connect(this.handle, "ondragstart",   this, "onSelectStart"),
  59                         dojo.connect(this.handle, "onselectstart", this, "onSelectStart")
  60                 ];
  61         },
  62
  63         // markup methods
  64         markupFactory: function(params, node){
  65                 return new dojo.dnd.Moveable(node, params);
  66         },
  67
  68         // methods
  69         destroy: function(){
  70                 // summary:
  71                 //              stops watching for possible move, deletes all references, so the object can be garbage-collected
  72                 dojo.forEach(this.events, dojo.disconnect);
  73                 this.events = this.node = this.handle = null;
  74         },
  75
  76         // mouse event processors
  77         onMouseDown: function(e){
  78                 // summary:
  79                 //              event processor for onmousedown, creates a Mover for the node
  80                 // e: Event
  81                 //              mouse event
  82                 if(this.skip && dojo.dnd.isFormElement(e)){ return; }
  83                 if(this.delay){
  84                         this.events.push(
  85                                 dojo.connect(this.handle, "onmousemove", this, "onMouseMove"),
  86                                 dojo.connect(this.handle, "onmouseup", this, "onMouseUp")
  87                         );
  88                         this._lastX = e.pageX;
  89                         this._lastY = e.pageY;
  90                 }else{
  91                         this.onDragDetected(e);
  92                 }
  93                 dojo.stopEvent(e);
  94         },
  95         onMouseMove: function(e){
  96                 // summary:
  97                 //              event processor for onmousemove, used only for delayed drags
  98                 // e: Event
  99                 //              mouse event
 100                 if(Math.abs(e.pageX - this._lastX) > this.delay || Math.abs(e.pageY - this._lastY) > this.delay){
 101                         this.onMouseUp(e);
 102                         this.onDragDetected(e);
 103                 }
 104                 dojo.stopEvent(e);
 105         },
 106         onMouseUp: function(e){
 107                 // summary:
 108                 //              event processor for onmouseup, used only for delayed drags
 109                 // e: Event
 110                 //              mouse event
 111                 for(var i = 0; i < 2; ++i){
 112                         dojo.disconnect(this.events.pop());
 113                 }
 114                 dojo.stopEvent(e);
 115         },
 116         onSelectStart: function(e){
 117                 // summary:
 118                 //              event processor for onselectevent and ondragevent
 119                 // e: Event
 120                 //              mouse event
 121                 if(!this.skip || !dojo.dnd.isFormElement(e)){
 122                         dojo.stopEvent(e);
 123                 }
 124         },
 125
 126         // local events
 127         onDragDetected: function(/* Event */ e){
 128                 // summary:
 129                 //              called when the drag is detected;
 130                 //              responsible for creation of the mover
 131                 new this.mover(this.node, e, this);
 132         },
 133         onMoveStart: function(/* dojo.dnd.Mover */ mover){
 134                 // summary:
 135                 //              called before every move operation
 136                 dojo.publish("/dnd/move/start", [mover]);
 137                 dojo.addClass(dojo.body(), "dojoMove");
 138                 dojo.addClass(this.node, "dojoMoveItem");
 139         },
 140         onMoveStop: function(/* dojo.dnd.Mover */ mover){
 141                 // summary:
 142                 //              called after every move operation
 143                 dojo.publish("/dnd/move/stop", [mover]);
 144                 dojo.removeClass(dojo.body(), "dojoMove");
 145                 dojo.removeClass(this.node, "dojoMoveItem");
 146         },
 147         onFirstMove: function(/* dojo.dnd.Mover */ mover, /* Event */ e){
 148                 // summary:
 149                 //              called during the very first move notification;
 150                 //              can be used to initialize coordinates, can be overwritten.
 151
 152                 // default implementation does nothing
 153         },
 154         onMove: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop, /* Event */ e){
 155                 // summary:
 156                 //              called during every move notification;
 157                 //              should actually move the node; can be overwritten.
 158                 this.onMoving(mover, leftTop);
 159                 var s = mover.node.style;
 160                 s.left = leftTop.l + "px";
 161                 s.top  = leftTop.t + "px";
 162                 this.onMoved(mover, leftTop);
 163         },
 164         onMoving: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
 165                 // summary:
 166                 //              called before every incremental move; can be overwritten.
 167
 168                 // default implementation does nothing
 169         },
 170         onMoved: function(/* dojo.dnd.Mover */ mover, /* Object */ leftTop){
 171                 // summary:
 172                 //              called after every incremental move; can be overwritten.
 173
 174                 // default implementation does nothing
 175         }
 176 });
 177
 178 }