Subversion Repositories Applications.papyrus

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2150 mathias 1 
if(!dojo._hasResource["dijit._base.typematic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
2 
dojo._hasResource["dijit._base.typematic"] = true;
3 
dojo.provide("dijit._base.typematic");
4 
 
5 
dijit.typematic = {
6 
	// summary:
7 
	//	These functions are used to repetitively call a user specified callback
8 
	//	method when a specific key or mouse click over a specific DOM node is
9 
	//	held down for a specific amount of time.
10 
	//	Only 1 such event is allowed to occur on the browser page at 1 time.
11 
 
12 
	_fireEventAndReload: function(){
13 
		this._timer = null;
14 
		this._callback(++this._count, this._node, this._evt);
15 
		this._currentTimeout = (this._currentTimeout < 0) ? this._initialDelay : ((this._subsequentDelay > 1) ? this._subsequentDelay : Math.round(this._currentTimeout * this._subsequentDelay));
16 
		this._timer = setTimeout(dojo.hitch(this, "_fireEventAndReload"), this._currentTimeout);
17 
	},
18 
 
19 
	trigger: function(/*Event*/ evt, /* Object */ _this, /*DOMNode*/ node, /* Function */ callback, /* Object */ obj, /* Number */ subsequentDelay, /* Number */ initialDelay){
20 
		// summary:
21 
		//      Start a timed, repeating callback sequence.
22 
		//      If already started, the function call is ignored.
23 
		//      This method is not normally called by the user but can be
24 
		//      when the normal listener code is insufficient.
25 
		//	Parameters:
26 
		//	evt: key or mouse event object to pass to the user callback
27 
		//	_this: pointer to the user's widget space.
28 
		//	node: the DOM node object to pass the the callback function
29 
		//	callback: function to call until the sequence is stopped called with 3 parameters:
30 
		//		count: integer representing number of repeated calls (0..n) with -1 indicating the iteration has stopped
31 
		//		node: the DOM node object passed in
32 
		//		evt: key or mouse event object
33 
		//	obj: user space object used to uniquely identify each typematic sequence
34 
		//	subsequentDelay: if > 1, the number of milliseconds until the 3->n events occur
35 
		//		or else the fractional time multiplier for the next event's delay, default=0.9
36 
		//	initialDelay: the number of milliseconds until the 2nd event occurs, default=500ms
37 
		if(obj != this._obj){
38 
			this.stop();
39 
			this._initialDelay = initialDelay || 500;
40 
			this._subsequentDelay = subsequentDelay || 0.90;
41 
			this._obj = obj;
42 
			this._evt = evt;
43 
			this._node = node;
44 
			this._currentTimeout = -1;
45 
			this._count = -1;
46 
			this._callback = dojo.hitch(_this, callback);
47 
			this._fireEventAndReload();
48 
		}
49 
	},
50 
 
51 
	stop: function(){
52 
		// summary:
53 
		//	  Stop an ongoing timed, repeating callback sequence.
54 
		if(this._timer){
55 
			clearTimeout(this._timer);
56 
			this._timer = null;
57 
		}
58 
		if(this._obj){
59 
			this._callback(-1, this._node, this._evt);
60 
			this._obj = null;
61 
		}
62 
	},
63 
 
64 
	addKeyListener: function(/*DOMNode*/ node, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){
65 
		// summary: Start listening for a specific typematic key.
66 
		//	keyObject: an object defining the key to listen for.
67 
		//		key: (mandatory) the keyCode (number) or character (string) to listen for.
68 
		//		ctrlKey: desired ctrl key state to initiate the calback sequence:
69 
		//			pressed (true)
70 
		//			released (false)
71 
		//			either (unspecified)
72 
		//		altKey: same as ctrlKey but for the alt key
73 
		//		shiftKey: same as ctrlKey but for the shift key
74 
		//	See the trigger method for other parameters.
75 
		//	Returns an array of dojo.connect handles
76 
		return [
77 
			dojo.connect(node, "onkeypress", this, function(evt){
78 
				if(evt.keyCode == keyObject.keyCode && (!keyObject.charCode || keyObject.charCode == evt.charCode) &&
79 
				(keyObject.ctrlKey === undefined || keyObject.ctrlKey == evt.ctrlKey) &&
80 
				(keyObject.altKey === undefined || keyObject.altKey == evt.ctrlKey) &&
81 
				(keyObject.shiftKey === undefined || keyObject.shiftKey == evt.ctrlKey)){
82 
					dojo.stopEvent(evt);
83 
					dijit.typematic.trigger(keyObject, _this, node, callback, keyObject, subsequentDelay, initialDelay);
84 
				}else if(dijit.typematic._obj == keyObject){
85 
					dijit.typematic.stop();
86 
				}
87 
			}),
88 
			dojo.connect(node, "onkeyup", this, function(evt){
89 
				if(dijit.typematic._obj == keyObject){
90 
					dijit.typematic.stop();
91 
				}
92 
			})
93 
		];
94 
	},
95 
 
96 
	addMouseListener: function(/*DOMNode*/ node, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){
97 
		// summary: Start listening for a typematic mouse click.
98 
		//	See the trigger method for other parameters.
99 
		//	Returns an array of dojo.connect handles
100 
		var dc = dojo.connect;
101 
		return [
102 
			dc(node, "mousedown", this, function(evt){
103 
				dojo.stopEvent(evt);
104 
				dijit.typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay);
105 
			}),
106 
			dc(node, "mouseup", this, function(evt){
107 
				dojo.stopEvent(evt);
108 
				dijit.typematic.stop();
109 
			}),
110 
			dc(node, "mouseout", this, function(evt){
111 
				dojo.stopEvent(evt);
112 
				dijit.typematic.stop();
113 
			}),
114 
			dc(node, "mousemove", this, function(evt){
115 
				dojo.stopEvent(evt);
116 
			}),
117 
			dc(node, "dblclick", this, function(evt){
118 
				dojo.stopEvent(evt);
119 
				if(dojo.isIE){
120 
					dijit.typematic.trigger(evt, _this, node, callback, node, subsequentDelay, initialDelay);
121 
					setTimeout(dijit.typematic.stop, 50);
122 
				}
123 
			})
124 
		];
125 
	},
126 
 
127 
	addListener: function(/*Node*/ mouseNode, /*Node*/ keyNode, /*Object*/ keyObject, /*Object*/ _this, /*Function*/ callback, /*Number*/ subsequentDelay, /*Number*/ initialDelay){
128 
		// summary: Start listening for a specific typematic key and mouseclick.
129 
		//	This is a thin wrapper to addKeyListener and addMouseListener.
130 
		//	mouseNode: the DOM node object to listen on for mouse events.
131 
		//	keyNode: the DOM node object to listen on for key events.
132 
		//	See the addMouseListener and addKeyListener methods for other parameters.
133 
		//	Returns an array of dojo.connect handles
134 
		return this.addKeyListener(keyNode, keyObject, _this, callback, subsequentDelay, initialDelay).concat(
135 
			this.addMouseListener(mouseNode, _this, callback, subsequentDelay, initialDelay));
136 
	}
137 
};
138 
 
139 
}