← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/openlayers/tests/Handler/Feature.html

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/openlayers/tests/Handler/Feature.html
 
1
<html>
 
2
<head>
 
3
  <script src="../../lib/OpenLayers.js"></script>
 
4
  <script type="text/javascript">
 
5
    function test_initialize(t) {
 
6
        t.plan(4);
 
7
        var control = new OpenLayers.Control();
 
8
        control.id = Math.random();
 
9
        var layer = "boo";
 
10
        var callbacks = {foo: "bar"};
 
11
        var options = {bar: "foo"};
 
12
        
 
13
        var oldInit = OpenLayers.Handler.prototype.initialize;
 
14
        
 
15
        OpenLayers.Handler.prototype.initialize = function(con, call, opt) {
 
16
            t.eq(con.id, control.id,
 
17
                 "constructor calls parent with the correct control");
 
18
            t.eq(call, callbacks,
 
19
                 "constructor calls parent with the correct callbacks");
 
20
            t.eq(opt, options,
 
21
                 "constructor calls parent with the correct options");
 
22
        }
 
23
        var handler = new OpenLayers.Handler.Feature(control, layer,
 
24
                                                     callbacks, options);
 
25
        
 
26
        t.eq(handler.layer, "boo",
 
27
             "layer property properly set");
 
28
 
 
29
        OpenLayers.Handler.prototype.initialize = oldInit;
 
30
    }
 
31
 
 
32
    function test_activate(t) {
 
33
        t.plan(3);
 
34
        var map = new OpenLayers.Map('map');
 
35
        var control = new OpenLayers.Control();
 
36
        map.addControl(control);
 
37
        var layer = new OpenLayers.Layer();
 
38
        map.addLayer(layer);
 
39
        var handler = new OpenLayers.Handler.Feature(control, layer);
 
40
        handler.active = true;
 
41
        var activated = handler.activate();
 
42
        t.ok(!activated,
 
43
             "activate returns false if the handler was already active");
 
44
        handler.active = false;
 
45
        
 
46
        var zIndex = layer.div.style.zIndex;
 
47
        activated = handler.activate();
 
48
        t.ok(activated,
 
49
             "activate returns true if the handler was not already active");
 
50
        t.eq(parseInt(layer.div.style.zIndex),
 
51
             map.Z_INDEX_BASE['Feature'],
 
52
             "layer z-index properly adjusted");
 
53
        
 
54
    }
 
55
    function test_events(t) {
 
56
        t.plan(25);
 
57
        
 
58
        var map = new OpenLayers.Map('map');
 
59
        var control = new OpenLayers.Control();
 
60
        map.addControl(control);
 
61
        var layer = new OpenLayers.Layer();
 
62
        map.addLayer(layer);
 
63
        var handler = new OpenLayers.Handler.Feature(control, layer);
 
64
 
 
65
        // list below events that should be handled (events) and those
 
66
        // that should not be handled (nonevents) by the handler
 
67
        var events = ["mousedown", "mouseup", "mousemove", "click", "dblclick"];
 
68
        var nonevents = ["mouseout", "resize", "focus", "blur"];
 
69
        map.events.registerPriority = function(type, obj, func) {
 
70
            var output = func();
 
71
            // Don't listen for setEvent handlers (#902)
 
72
            if (typeof output == "string") {
 
73
                t.eq(OpenLayers.Util.indexOf(nonevents, type), -1,
 
74
                     "registered method is not one of the events " +
 
75
                     "that should not be handled");
 
76
                t.ok(OpenLayers.Util.indexOf(events, type) > -1,
 
77
                     "activate calls registerPriority with browser event: " + type);
 
78
                t.eq(typeof func, "function",
 
79
                     "activate calls registerPriority with a function");
 
80
                t.eq(func(), type,
 
81
                     "activate calls registerPriority with the correct method:"+type);
 
82
                t.eq(obj["CLASS_NAME"], "OpenLayers.Handler.Feature",
 
83
                     "activate calls registerPriority with the handler");
 
84
            }     
 
85
        }
 
86
        
 
87
        // set browser event like properties on the handler
 
88
        for(var i=0; i<events.length; ++i) {
 
89
            setMethod(events[i]);
 
90
        }
 
91
        function setMethod(key) {
 
92
            handler[key] = function() {return key};
 
93
        }
 
94
 
 
95
        var activated = handler.activate();
 
96
 
 
97
    }
 
98
 
 
99
    function test_geometrytype_limit(t) {
 
100
        t.plan(1);
 
101
        var map = new OpenLayers.Map('map');
 
102
        var control = new OpenLayers.Control();
 
103
        map.addControl(control);
 
104
        var layer = new OpenLayers.Layer();
 
105
        var feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(0,0));
 
106
        feature.layer = layer;
 
107
        layer.getFeatureFromEvent = function(evt) { return feature };
 
108
        map.addLayer(layer);
 
109
        var handler = new OpenLayers.Handler.Feature(control, layer, {}, {'geometryTypes':['OpenLayers.Geometry.Point']});
 
110
        handler.activate();
 
111
        handler.callback = function(type,featurelist) {
 
112
            t.eq(featurelist[0].id, feature.id, "Correct feature called back on");
 
113
        }
 
114
        handler.handle({type: "click"});
 
115
        handler.feature = null;
 
116
        handler.lastFeature = null;
 
117
        handler.callback = function(type,featurelist) {
 
118
            t.fail("Shouldn't have called back on " + featurelist[0].geometry);
 
119
        }    
 
120
        feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.LineString(0,0));
 
121
        feature.layer = layer;
 
122
        handler.handle("click", {}); 
 
123
    }
 
124
 
 
125
    function test_callbacks(t) {
 
126
        t.plan(9);
 
127
        
 
128
        var map = new OpenLayers.Map('map', {controls: []});
 
129
        var control = new OpenLayers.Control();
 
130
        map.addControl(control);
 
131
        var layer = new OpenLayers.Layer();
 
132
        map.addLayer(layer);
 
133
 
 
134
        var callbacks = {};
 
135
        var newFeature, lastFeature;
 
136
        var evtPx = {xy: new OpenLayers.Pixel(Math.random(), Math.random())};
 
137
 
 
138
        // define a callback factory function
 
139
        function getCallback(evt, feature) {
 
140
            return function(f) {
 
141
                t.ok(f == feature, evt + " callback called with proper feature");
 
142
            };
 
143
        }
 
144
 
 
145
        // override the layer's getFeatureFromEvent func so that it always
 
146
        // returns newFeature
 
147
        layer.getFeatureFromEvent = function(evt) { return newFeature; };
 
148
 
 
149
        var handler = new OpenLayers.Handler.Feature(control, layer, callbacks);
 
150
        handler.activate();
 
151
 
 
152
        // test click in new feature
 
153
        // only 'click' callback should be called
 
154
        handler.feature = null;
 
155
        lastFeature = null;
 
156
        newFeature = new OpenLayers.Feature.Vector();
 
157
        newFeature.layer = layer;
 
158
        callbacks['click'] = getCallback('click', newFeature);
 
159
        callbacks['clickout'] = getCallback('clickout', lastFeature);
 
160
        evtPx.type = "click";
 
161
        map.events.triggerEvent('click', evtPx);
 
162
 
 
163
        // test click in new feature and out of last feature
 
164
        // both 'click' and 'clickout' callbacks should be called
 
165
        lastFeature = newFeature;
 
166
        newFeature = new OpenLayers.Feature.Vector();
 
167
        newFeature.layer = layer;
 
168
        callbacks['click'] = getCallback('click', newFeature);
 
169
        callbacks['clickout'] = getCallback('clickout', lastFeature);
 
170
        evtPx.type = "click";
 
171
        map.events.triggerEvent('click', evtPx);
 
172
 
 
173
        // test click out of last feature
 
174
        // only 'clickout' callback should be called
 
175
        lastFeature = newFeature;
 
176
        newFeature = null;
 
177
        callbacks['click'] = getCallback('click', newFeature);
 
178
        callbacks['clickout'] = getCallback('clickout', lastFeature);
 
179
        evtPx.type = "click";
 
180
        map.events.triggerEvent('click', evtPx);
 
181
 
 
182
        layer.getFeatureFromEvent = function(evt) { t.fail("mousemove called getFeatureFromEvent without any mousemove callbacks"); };
 
183
        evtPx.type = "mousemove";
 
184
        map.events.triggerEvent('mousemove', evtPx);
 
185
        layer.getFeatureFromEvent = function(evt) { return newFeature; };
 
186
        
 
187
        // test over a new feature
 
188
        // only 'over' callback should be called
 
189
        handler.feature = null;
 
190
        lastFeature = null;
 
191
        newFeature = new OpenLayers.Feature.Vector();
 
192
        newFeature.layer = layer;
 
193
        callbacks['over'] = getCallback('over', newFeature);
 
194
        callbacks['out'] = getCallback('out', lastFeature);
 
195
        evtPx.type = "mousemove";
 
196
        map.events.triggerEvent('mousemove', evtPx);
 
197
 
 
198
        // test over a new feature and out of last feature
 
199
        // both 'over' and 'out' callbacks should be called
 
200
        lastFeature = newFeature;
 
201
        newFeature = new OpenLayers.Feature.Vector();
 
202
        newFeature.layer = layer;
 
203
        callbacks['over'] = getCallback('over', newFeature);
 
204
        callbacks['out'] = getCallback('out', lastFeature);
 
205
        evtPx.type = "mousemove";
 
206
        map.events.triggerEvent('mousemove', evtPx);
 
207
 
 
208
        // test out of last feature
 
209
        // only 'out' callback should be called
 
210
        lastFeature = newFeature;
 
211
        newFeature = null;
 
212
        callbacks['over'] = getCallback('over', newFeature);
 
213
        callbacks['out'] = getCallback('out', lastFeature);
 
214
        evtPx.type = "mousemove";
 
215
        map.events.triggerEvent('mousemove', evtPx);
 
216
 
 
217
        // test dblclick on a feature
 
218
        // 'dblclick' callback should be called
 
219
        handler.feature = null;
 
220
        lastFeature = null;
 
221
        newFeature = new OpenLayers.Feature.Vector();
 
222
        newFeature.layer = layer;
 
223
        callbacks['dblclick'] = getCallback('dblclick', newFeature);
 
224
        evtPx.type = "dblclick";
 
225
        map.events.triggerEvent('dblclick', evtPx);
 
226
    }
 
227
 
 
228
    function test_deactivate(t) {
 
229
        t.plan(3);
 
230
        var map = new OpenLayers.Map('map');
 
231
        var control = new OpenLayers.Control();
 
232
        map.addControl(control);
 
233
        var layer = new OpenLayers.Layer();
 
234
        map.addLayer(layer);
 
235
        var layerIndex = parseInt(layer.div.style.zIndex);
 
236
        
 
237
        var handler = new OpenLayers.Handler.Feature(control, layer);
 
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
        
 
243
        handler.active = true;
 
244
 
 
245
        deactivated = handler.deactivate();
 
246
        t.ok(deactivated,
 
247
             "deactivate returns true if the handler was active already");
 
248
        t.eq(parseInt(layer.div.style.zIndex),
 
249
             layerIndex,
 
250
             "deactivate sets the layer z-index back");
 
251
    }
 
252
 
 
253
    function test_stopHandled(t) {
 
254
        t.plan(3);
 
255
        var map = new OpenLayers.Map('map');
 
256
        var control = new OpenLayers.Control();
 
257
        map.addControl(control);
 
258
        var layer = new OpenLayers.Layer();
 
259
        map.addLayer(layer);
 
260
        var handler = new OpenLayers.Handler.Feature(control, layer);
 
261
        handler.activate();
 
262
        handler.handle = function(evt) { return /* handled */ true; };
 
263
        var  evtPx = {xy: new OpenLayers.Pixel(Math.random(), Math.random())};
 
264
        map.events.register("click", map, function(e) {
 
265
            t.ok(!handler.stopClick, "clicks propagate with stopClick set to false" );
 
266
        });
 
267
        map.events.register("mousedown", map, function(e) {
 
268
            t.ok(!handler.stopDown, "mousedown propagate with stopDown set to false" );
 
269
        });
 
270
        map.events.register("mouseup", map, function(e) {
 
271
            t.ok(!handler.stopUp, "mouseup propagate with stopUp set to false" );
 
272
        });
 
273
 
 
274
        // 0 test
 
275
        map.events.triggerEvent('click', evtPx);
 
276
        // 0 test
 
277
        map.events.triggerEvent('mousedown', evtPx);
 
278
        // 0 test
 
279
        map.events.triggerEvent('mousedown', evtPx);
 
280
 
 
281
        // 1 test
 
282
        handler.stopClick = false;
 
283
        map.events.triggerEvent('click', evtPx);
 
284
        // 1 test
 
285
        handler.stopDown = false;
 
286
        map.events.triggerEvent('mousedown', evtPx);
 
287
        // 1 test
 
288
        handler.stopUp = false;
 
289
        map.events.triggerEvent('mouseup', evtPx);
 
290
        
 
291
        // 3 tests total
 
292
    }
 
293
 
 
294
    function test_destroyed_feature(t) {
 
295
        t.plan(2);
 
296
        var map = new OpenLayers.Map('map');
 
297
        var control = new OpenLayers.Control();
 
298
        map.addControl(control);
 
299
        var layer = new OpenLayers.Layer();
 
300
        layer.removeFeatures = function() {};
 
301
        var feature = new OpenLayers.Feature.Vector(new OpenLayers.Geometry.Point(0,0));
 
302
        feature.layer = layer;
 
303
        layer.getFeatureFromEvent = function(evt) {return feature};
 
304
        map.addLayer(layer);
 
305
        var handler = new OpenLayers.Handler.Feature(control, layer);
 
306
        handler.activate();
 
307
        var count = 0;
 
308
        handler.callback = function(type, featurelist) {
 
309
            ++count;
 
310
            t.eq(featurelist[0].id, feature.id, type + ": correct feature sent to callback");
 
311
        }
 
312
        handler.handle({type: "click"});
 
313
        
 
314
        // now destroy the feature and confirm that the callback is not called again
 
315
        feature.destroy();
 
316
        handler.handle({type: "click"});
 
317
        t.eq(count, 1, "callback not called after destroy");
 
318
    }
 
319
 
 
320
  </script>
 
321
</head>
 
322
<body>
 
323
    <div id="map" style="width: 300px; height: 150px;"/>
 
324
</body>
 
325
</html>