| New file |
|---|
| 0,0 → 1,139 |
|---|
| if(!dojo._hasResource["dijit._base.typematic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dijit._base.typematic"] = true; |
| dojo.provide("dijit._base.typematic"); |
| |
| dijit.typematic = { |
| // summary: |
| // These functions are used to repetitively call a user specified callback |
| // method when a specific key or mouse click over a specific DOM node is |
| // held down for a specific amount of time. |
| // Only 1 such event is allowed to occur on the browser page at 1 time. |
| |
| _fireEventAndReload: function(){ |
| this._timer = null; |
| this._callback(++this._count, this._node, this._evt); |
| this._currentTimeout = (this._currentTimeout < 0) ? this._initialDelay : ((this._subsequentDelay > 1) ? this._subsequentDelay : Math.round(this._currentTimeout * this._subsequentDelay)); |
| this._timer = setTimeout(dojo.hitch(this, "_fireEventAndReload"), this._currentTimeout); |
| }, |
| |
| trigger: function(/*Event*/ evt, /* Object */ _this, /*DOMNode*/ node, /* Function */ callback, /* Object */ obj, /* Number */ subsequentDelay, /* Number */ initialDelay){ |
| // summary: |
| // Start a timed, repeating callback sequence. |
| // If already started, the function call is ignored. |
| // This method is not normally called by the user but can be |
| // when the normal listener code is insufficient. |
| // Parameters: |
| // evt: key or mouse event object to pass to the user callback |
| // _this: pointer to the user's widget space. |
| // node: the DOM node object to pass the the callback function |
| // callback: function to call until the sequence is stopped called with 3 parameters: |
| // count: integer representing number of repeated calls (0..n) with -1 indicating the iteration has stopped |
| // node: the DOM node object passed in |
| // evt: key or mouse event object |
| // obj: user space object used to uniquely identify each typematic sequence |
| // subsequentDelay: if > 1, the number of milliseconds until the 3->n events occur |
| // or else the fractional time multiplier for the next event's delay, default=0.9 |
| // initialDelay: the number of milliseconds until the 2nd event occurs, default=500ms |
| if(obj != this._obj){ |
| this.stop(); |
| this._initialDelay = initialDelay || 500; |
| this._subsequentDelay = subsequentDelay || 0.90; |
| this._obj = obj; |
| this._evt = evt; |
| this._node = node; |
| this._currentTimeout = -1; |
| this._count = -1; |
| this._callback = dojo.hitch(_this, callback); |
| this._fireEventAndReload(); |
| } |
| }, |
| |
| stop: function(){ |
| // summary: |
| // Stop an ongoing timed, repeating callback sequence. |
| if(this._timer){ |
| clearTimeout(this._timer); |
| this._timer = null; |
| } |
| if(this._obj){ |
| this._callback(-1, this._node, this._evt); |
| this._obj = null; |
| } |
| }, |
| |
| addKeyListener: function(/*DOMNode*/ node, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){ |
| // summary: Start listening for a specific typematic key. |
| // keyObject: an object defining the key to listen for. |
| // key: (mandatory) the keyCode (number) or character (string) to listen for. |
| // ctrlKey: desired ctrl key state to initiate the calback sequence: |
| // pressed (true) |
| // released (false) |
| // either (unspecified) |
| // altKey: same as ctrlKey but for the alt key |
| // shiftKey: same as ctrlKey but for the shift key |
| // See the trigger method for other parameters. |
| // Returns an array of dojo.connect handles |
| return [ |
| dojo.connect(node, "onkeypress", this, function(evt){ |
| if(evt.keyCode == keyObject.keyCode && (!keyObject.charCode || keyObject.charCode == evt.charCode) && |
| (keyObject.ctrlKey === undefined || keyObject.ctrlKey == evt.ctrlKey) && |
| (keyObject.altKey === undefined || keyObject.altKey == evt.ctrlKey) && |
| (keyObject.shiftKey === undefined || keyObject.shiftKey == evt.ctrlKey)){ |
| dojo.stopEvent(evt); |
| dijit.typematic.trigger(keyObject, _this, node, callback, keyObject, subsequentDelay, initialDelay); |
| }else if(dijit.typematic._obj == keyObject){ |
| dijit.typematic.stop(); |
| } |
| }), |
| dojo.connect(node, "onkeyup", this, function(evt){ |
| if(dijit.typematic._obj == keyObject){ |
| dijit.typematic.stop(); |
| } |
| }) |
| ]; |
| }, |
| |
| addMouseListener: function(/*DOMNode*/ node, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){ |
| // summary: Start listening for a typematic mouse click. |
| // See the trigger method for other parameters. |
| // Returns an array of dojo.connect handles |
| var dc = dojo.connect; |
| return [ |
| dc(node, "mousedown", this, function(evt){ |
| dojo.stopEvent(evt); |
| dijit.typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay); |
| }), |
| dc(node, "mouseup", this, function(evt){ |
| dojo.stopEvent(evt); |
| dijit.typematic.stop(); |
| }), |
| dc(node, "mouseout", this, function(evt){ |
| dojo.stopEvent(evt); |
| dijit.typematic.stop(); |
| }), |
| dc(node, "mousemove", this, function(evt){ |
| dojo.stopEvent(evt); |
| }), |
| dc(node, "dblclick", this, function(evt){ |
| dojo.stopEvent(evt); |
| if(dojo.isIE){ |
| dijit.typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay); |
| setTimeout(dijit.typematic.stop, 50); |
| } |
| }) |
| ]; |
| }, |
| |
| addListener: function(/*Node*/ mouseNode, /*Node*/ keyNode, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){ |
| // summary: Start listening for a specific typematic key and mouseclick. |
| // This is a thin wrapper to addKeyListener and addMouseListener. |
| // mouseNode: the DOM node object to listen on for mouse events. |
| // keyNode: the DOM node object to listen on for key events. |
| // See the addMouseListener and addKeyListener methods for other parameters. |
| // Returns an array of dojo.connect handles |
| return this.addKeyListener(keyNode, keyObject, _this, callback, subsequentDelay, initialDelay).concat( |
| this.addMouseListener(mouseNode, _this, callback, subsequentDelay, initialDelay)); |
| } |
| }; |
| |
| } |