]> dev.renevier.net Git - syp.git/blob - openlayers/tests/Handler/Click.html
show number of features on cluster markers
[syp.git] / openlayers / tests / Handler / Click.html
1 <html>
2 <head>
3   <script src="../../lib/OpenLayers.js"></script>
4   <script type="text/javascript">
5     function test_Handler_Click_constructor(t) {
6         t.plan(3);
7         var control = new OpenLayers.Control();
8         control.id = Math.random();
9         var callbacks = {foo: "bar"};
10         var options = {bar: "foo"};
11         
12         var oldInit = OpenLayers.Handler.prototype.initialize;
13         
14         OpenLayers.Handler.prototype.initialize = function(con, call, opt) {
15             t.eq(con.id, control.id,
16                  "constructor calls parent with the correct control");
17             t.eq(call, callbacks,
18                  "constructor calls parent with the correct callbacks");
19             t.eq(opt, options,
20                  "constructor calls parent with the correct options");
21         }
22         var handler = new OpenLayers.Handler.Click(control, callbacks, options);
23
24         OpenLayers.Handler.prototype.initialize = oldInit;
25     }
26
27     function test_Handler_Click_activate(t) {
28         t.plan(2);
29         var control = {
30             map: new OpenLayers.Map('map')
31         };
32         var handler = new OpenLayers.Handler.Click(control);
33         handler.active = true;
34         var activated = handler.activate();
35         t.ok(!activated,
36              "activate returns false if the handler was already active");
37         handler.active = false;
38         handler.dragging = true;
39         activated = handler.activate();
40         t.ok(activated,
41              "activate returns true if the handler was not already active");
42         
43     }
44     
45     function test_Handler_Click_events(t) {
46         t.plan(50);
47         
48         var map = new OpenLayers.Map('map');
49         var control = {
50             map: map
51         };
52         map.events.registerPriority = function(type, obj, func) {
53             var r = func();
54             if(typeof r == "string") {
55                 // this is one of the mock handler methods
56                 t.eq(OpenLayers.Util.indexOf(nonevents, type), -1,
57                      "registered method is not one of the events " +
58                      "that should not be handled");
59                 t.ok(OpenLayers.Util.indexOf(events, type) > -1,
60                      "activate calls registerPriority with browser event: " + type);
61                 t.eq(typeof func, "function",
62                      "activate calls registerPriority with a function");
63                 t.eq(func(), type,
64                      "activate calls registerPriority with the correct method");
65                 t.eq(obj["CLASS_NAME"], "OpenLayers.Handler.Click",
66                      "activate calls registerPriority with the handler");
67             }
68         }
69         function setMethod(key) {
70             handler[key] = function() {return key};
71         }
72
73         // list below events that should be handled (events) and those
74         // that should not be handled (nonevents) by the handler
75         var events = ["click", "dblclick", "mousedown", "mouseup", "rightclick"];
76         var nonevents = ["mousemove", "resize", "focus", "blur"];
77         var handler = new OpenLayers.Handler.Click(control);
78         // set browser event like properties on the handler
79         for(var i=0; i<events.length; ++i) {
80             setMethod(events[i]);
81         }
82         handler.activate();
83
84         // different listeners registered for pixelTolerance option
85         var events = ["click", "dblclick", "mousedown", "mouseup", "rightclick"];
86         var nonevents = ["mousemove", "resize", "focus", "blur"];
87         var handler = new OpenLayers.Handler.Click(control, {}, {
88             pixelTolerance: 2
89         });
90         for(var i=0; i<events.length; ++i) {
91             setMethod(events[i]);
92         }
93         handler.activate();
94
95     }
96
97     function test_Handler_Click_callbacks(t) {
98         t.plan(13);
99         
100         var map = new OpenLayers.Map('map', {controls: []});
101
102         var control = {
103             map: map
104         };
105
106         var handler = new OpenLayers.Handler.Click(control, {});
107         handler.activate();
108         
109         
110         // set up for single click - three tests here
111         var timers = {};
112         var sto = window.setTimeout;
113         window.setTimeout = function(func, delay) {
114             var key = Math.random();
115             timers[key] = true;
116             t.ok(typeof func == "function",
117                  "setTimeout called with a function");
118             t.eq(delay, handler.delay,
119                  "setTimeout called with proper delay");
120             // execute function that is supposed to be delayed
121             func();
122             return key;
123         }
124         var cto = window.clearTimeout;
125         window.clearTimeout = function(key) {
126             if(timers[key] === true) {
127                 delete timers[key];
128             } else {
129                 t.fail("clearTimeout called with non-existent timerId");
130             }
131         }
132         var testEvt = {id: Math.random()};
133         handler.callbacks = {
134             "click": function(evt) {
135                 t.eq(evt.id, testEvt.id,
136                      "(click w/ single true) click callback called with correct evt");
137             },
138             "dblclick": function(evt) {
139                 t.fail("(click w/ single true) dblclick should not be called here");
140             }
141         };
142         map.events.triggerEvent("click", testEvt);
143         
144         // set up for double click with double false - no tests here (only failures)
145         handler.callbacks = {
146             "click": function(evt) {
147                 t.fail("(dblclick w/ double false) click should not be called here");
148             },
149             "dblclick": function(evt) {
150                 t.fail("(dblclick w/ double false) dblclick should not be called here");
151             }
152         };
153         testEvt = Math.random();
154         map.events.triggerEvent("dblclick", testEvt);
155
156         // set up for double click with double true - one test here
157         handler.double = true;
158         handler.callbacks = {
159             "click": function(evt) {
160                 t.fail("(dblclick w/ double true) click should not be called here");
161             },
162             "dblclick": function(evt) {
163                 t.eq(evt, testEvt,
164                      "(dblclick w/ double true) dblclick called with correct evt");
165             }
166         };
167         testEvt = Math.random();
168         map.events.triggerEvent("dblclick", testEvt);
169         
170         // set up for two clicks with double true - 6 tests here (with timeout ones from above)
171         handler.double = true;
172         handler.callbacks = {
173             "click": function(evt) {
174                 t.ok(evt != null, "(two clicks w/ double true) click will not be called here if next three tests pass");
175             },
176             "dblclick": function(evt) {
177                 t.eq(evt, testEvt,
178                      "(two clicks w/ double true) dblclick called with correct evt");
179             }
180         };
181         testEvt = Math.random();
182         map.events.triggerEvent("click", testEvt);
183         t.ok(handler.timerId != null,
184              "(two clicks w/ double true) timer is set to call click");
185         map.events.triggerEvent("click", testEvt);
186         t.ok(handler.timerId == null,
187              "(two clicks w/ double true) timer is cleared to call click");
188         map.events.triggerEvent("dblclick", testEvt);
189         handler.destroy();
190         
191         // set up to tests pixelTolerance - three tests here (2 from setTimeout above)
192         handler = new OpenLayers.Handler.Click(control, {}, {
193             pixelTolerance: 2
194         });
195         handler.activate();
196         var downEvt = {
197             xy: new OpenLayers.Pixel(0, 0)
198         };
199         map.events.triggerEvent("mousedown", downEvt);
200         var clickEvt = {
201             xy: new OpenLayers.Pixel(0, 1)
202         };
203         // mouse moves one pixel, click should be called
204         handler.callbacks = {
205             "click": function(evt) {
206                 t.ok(evt.xy == clickEvt.xy, "(pixelTolerance met) click called");
207             }
208         };
209         map.events.triggerEvent("click", clickEvt);
210         handler.clearTimer();
211         
212         // mouse moves 3x3 pixels, click should not be called
213         map.events.triggerEvent("mousedown", downEvt);
214         var clickEvt = {
215             xy: new OpenLayers.Pixel(3, 3)
216         };
217         // mouse moves one pixel, click should be called
218         handler.callbacks = {
219             "click": function(evt) {
220                 t.fail("(pixelTolerance not met) click should not be called");
221             }
222         };
223         map.events.triggerEvent("click", clickEvt); // no test run
224         handler.clearTimer();
225         
226         window.setTimeout = sto;
227         window.clearTimeout = cto;
228         
229
230     }
231
232     function test_Handler_Click_deactivate(t) {
233         t.plan(4);
234         var control = {
235             map: new OpenLayers.Map('map')
236         };
237         var handler = new OpenLayers.Handler.Click(control);
238         handler.active = false;
239         var deactivated = handler.deactivate();
240         t.ok(!deactivated,
241              "deactivate returns false if the handler was not already active");
242         handler.active = true;
243         handler.down = true;
244         handler.timerId = true;
245         deactivated = handler.deactivate();
246         t.ok(deactivated,
247              "deactivate returns true if the handler was active already");
248         t.eq(handler.down, null,
249              "deactivate sets down to null");
250         t.eq(handler.timerId, null,
251              "deactivate sets timerId to null");
252     }
253
254     function test_Handler_Click_mouseup(t) {
255         t.plan(4);
256         g_Propagate = {};
257         g_evt = {};
258                 
259       //no modifiers, no handlerightclicks, no isrightclick        
260         var temp = OpenLayers.Event.isRightClick;
261         OpenLayers.Event.isRightClick = function(e) { 
262             t.ok(e == g_evt, 'correct event passed in to checkModifiers');
263             return false; 
264         };
265
266         var h = {
267             'checkModifiers': function(e) {
268                 t.ok(e == g_evt, 'correct event passed in to checkModifiers');
269                 return false;
270             },
271             'control': {
272                 'handleRightClicks': false
273             },
274             'rightclick': function(e) {
275                 t.ok(e == g_evt, 'correct event passed in to checkModifiers');
276                 return g_Propagate;
277             }
278         };
279         var propagate = OpenLayers.Handler.Click.prototype.mouseup.apply(h, [g_evt]);
280         t.ok(propagate, "default propagate is true when no modifiers, no handlerightclicks, no isrightclick")
281
282       //modifiers, handlerightclicks, and isrightclick
283         h.checkModifiers = function() { return true; };
284         h.control.handleRightClicks = true;        
285         OpenLayers.Event.isRightClick = function(e) { return true; };
286         propagate = OpenLayers.Handler.Click.prototype.mouseup.apply(h, [g_evt]);
287
288         t.ok(propagate == g_Propagate, "return from handler's rightClick() returned from mouseup");
289
290         OpenLayers.Event.isRightClick = temp;
291     }
292
293
294   </script>
295 </head>
296 <body>
297     <div id="map" style="width: 300px; height: 150px;"/>
298 </body>
299 </html>