← 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/Layer/Vector.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/Layer/Vector.html
 
1
<html>
 
2
<head>
 
3
<script src="../../lib/OpenLayers.js"></script>
 
4
  <script type="text/javascript">
 
5
 
 
6
    var name = "Vector Layer";
 
7
    
 
8
    function test_Layer_Vector_constructor(t) {
 
9
        t.plan(4);
 
10
 
 
11
        var options = {protocol: new OpenLayers.Protocol(), 
 
12
                       strategies: [new OpenLayers.Strategy(), new OpenLayers.Strategy()]}
 
13
        var layer = new OpenLayers.Layer.Vector(name, options);
 
14
 
 
15
        t.ok(layer instanceof OpenLayers.Layer.Vector, "new OpenLayers.Layer.Vector returns correct object" );
 
16
        t.eq(layer.name, name, "layer name is correctly set");
 
17
        t.ok(layer.renderer.CLASS_NAME, "layer has a renderer");
 
18
        
 
19
        t.ok((layer.name == layer.strategies[0].layer.name) &&
 
20
             (layer.strategies[0].layer.name == layer.strategies[1].layer.name), 
 
21
             "setLayer was called on strategies");
 
22
    }
 
23
 
 
24
    function test_Layer_Vector_refresh(t) {
 
25
        t.plan(1);
 
26
 
 
27
        var obj = {"an": "object"};
 
28
 
 
29
        var layer = new OpenLayers.Layer.Vector(name, {
 
30
            eventListeners: {
 
31
                refresh: function(o) {
 
32
                    t.ok(o == obj,
 
33
                         "refresh listener called with correct arg");
 
34
                }
 
35
            }
 
36
        });
 
37
 
 
38
        // 0 test
 
39
        layer.inRange = false;
 
40
        layer.visibility = false;
 
41
        layer.refresh(obj);
 
42
 
 
43
        // 0 test
 
44
        layer.inRange = true;
 
45
        layer.visibility = false;
 
46
        layer.refresh(obj);
 
47
 
 
48
        // 0 test
 
49
        layer.inRange = false;
 
50
        layer.visibility = true;
 
51
        layer.refresh(obj);
 
52
      
 
53
        // 1 test
 
54
        layer.inRange = true;
 
55
        layer.visibility = true;
 
56
        layer.refresh(obj);
 
57
    }
 
58
    
 
59
    function test_Layer_Vector_addFeatures(t) {
 
60
        t.plan(8);
 
61
    
 
62
        var layer = new OpenLayers.Layer.Vector(name);
 
63
 
 
64
        var point = new OpenLayers.Geometry.Point(-111.04, 45.68);
 
65
        var pointFeature = new OpenLayers.Feature.Vector(point);
 
66
 
 
67
        layer.preFeatureInsert = function(feature) {
 
68
            t.ok(feature == pointFeature, "OpenLayers.Layer.Vector.addFeatures calls preFeatureInsert with the right arg");
 
69
        };
 
70
        layer.onFeatureInsert = function(feature) {
 
71
            t.ok(feature == pointFeature, "OpenLayers.Layer.Vector.addFeatures calls onFeatureInsert with the right arg");
 
72
        };
 
73
        layer.events.register('beforefeatureadded', null, function(obj) {
 
74
            t.ok(pointFeature == obj.feature, "OpenLayers.Layer.Vector.addFeatures triggers beforefeatureadded with correct feature passed to callback");
 
75
        });
 
76
        layer.events.register('featureadded', null, function(obj) {
 
77
            t.ok(pointFeature == obj.feature, "OpenLayers.Layer.Vector.addFeatures triggers featureadded with correct feature passed to callback");
 
78
        });
 
79
        layer.events.register('featuresadded', null, function(obj) {
 
80
            t.ok(pointFeature == obj.features[0], "OpenLayers.Layer.Vector.addFeatures triggers featuresadded with correct features passed to callback");
 
81
        });
 
82
 
 
83
        layer.addFeatures([pointFeature]);
 
84
        
 
85
        t.eq(layer.features.length, 1, "OpenLayers.Layer.Vector.addFeatures adds something to the array");
 
86
        t.ok(layer.features[0] == pointFeature, "OpenLayers.Layer.Vector.addFeatures returns an array of features");
 
87
 
 
88
        layer.preFeatureInsert = function(feature) {
 
89
            t.fail("OpenLayers.Layer.Vector.addFeatures calls preFeatureInsert while it must not");
 
90
        };
 
91
        layer.onFeatureInsert = function(feature) {
 
92
            t.fail("OpenLayers.Layer.Vector.addFeatures calls onFeatureInsert while it must not");
 
93
        };
 
94
        layer.events.register('beforefeatureadded', null, function(obj) {
 
95
            t.fail("OpenLayers.Layer.Vector.addFeatures triggers beforefeatureadded while it must not");
 
96
        });
 
97
        layer.events.register('featureadded', null, function(obj) {
 
98
            t.fail("OpenLayers.Layer.Vector.addFeatures triggers featureadded while it must not");
 
99
        });
 
100
        layer.events.register('featuresadded', null, function(obj) {
 
101
            t.fail("OpenLayers.Layer.Vector.addFeatures triggers featuresadded while it must not");
 
102
        });
 
103
 
 
104
        layer.addFeatures([pointFeature], {silent: true});
 
105
 
 
106
        var extent = layer.getDataExtent();
 
107
        t.eq(extent.toBBOX(), "-111.04,45.68,-111.04,45.68", "extent from getDataExtent is correct");
 
108
    }
 
109
 
 
110
    function test_Layer_Vector_removeFeatures(t) {
 
111
        t.plan(6);
 
112
    
 
113
        var layer = new OpenLayers.Layer.Vector(name);
 
114
 
 
115
        var point1 = new OpenLayers.Geometry.Point(-111.04, 45.68);
 
116
        var pointFeature1 = new OpenLayers.Feature.Vector(layer, point1);
 
117
        var point2 = new OpenLayers.Geometry.Point(-111.14, 45.78);
 
118
        var pointFeature2 = new OpenLayers.Feature.Vector(layer, point2);
 
119
      
 
120
        layer.addFeatures([pointFeature1, pointFeature2]);
 
121
        var features = layer.removeFeatures([pointFeature1]);
 
122
        
 
123
        t.ok(layer.features.length == 1, "OpenLayers.Layer.Vector.removeFeatures removes a feature from the features array");
 
124
        layer.addFeatures([pointFeature1.clone(), pointFeature2.clone()]);
 
125
        layer.selectedFeatures.push(layer.features[0]); 
 
126
        layer.removeFeatures(layer.features[0]);
 
127
        t.eq(layer.selectedFeatures, [], "Remove features removes selected features");
 
128
        var features = layer.removeFeatures(layer.features);
 
129
        
 
130
        t.ok(layer.features.length == 0,
 
131
             "OpenLayers.Layer.Vector.removeFeatures(layer.features) removes all feature from the features array");
 
132
 
 
133
        // 3 tests
 
134
        layer.events.register('beforefeatureremoved', null, function(obj) {
 
135
            t.ok(pointFeature1 == obj.feature,
 
136
                 "OpenLayers.Layer.Vector.removeFeatures triggers beforefeatureremoved with correct feature passed to callback");
 
137
        });
 
138
        layer.events.register('featureremoved', null, function(obj) {
 
139
            t.ok(pointFeature1 == obj.feature,
 
140
                 "OpenLayers.Layer.Vector.removeFeatures triggers featureremoved with correct feature passed to callback");
 
141
        });
 
142
        layer.events.register('featuresremoved', null, function(obj) {
 
143
            t.ok(pointFeature1 == obj.features[0],
 
144
                 "OpenLayers.Layer.Vector.removeFeatures triggers featuresremoved with correct features passed to callback");
 
145
        });
 
146
        layer.addFeatures([pointFeature1]);
 
147
        layer.removeFeatures([pointFeature1]);
 
148
 
 
149
        // 0 test
 
150
        layer.events.register('beforefeatureremoved', null, function(obj) {
 
151
            t.fail("OpenLayers.Layer.Vector.removeFeatures triggers beforefeatureremoved while it must not");
 
152
        });
 
153
        layer.events.register('featureremoved', null, function(obj) {
 
154
            t.fail("OpenLayers.Layer.Vector.removeFeatures triggers featureremoved while it must not");
 
155
        });
 
156
        layer.events.register('featuresremoved', null, function(obj) {
 
157
            t.fail("OpenLayers.Layer.Vector.removeFeatures triggers featuresremoved while it must not");
 
158
        });
 
159
        layer.addFeatures([pointFeature1]);
 
160
        layer.removeFeatures([pointFeature1], {silent: true});
 
161
     }
 
162
    
 
163
    function test_Layer_Vector_drawFeature(t) {
 
164
        t.plan(7);
 
165
        var layer = new OpenLayers.Layer.Vector("Test Layer", {isBaseLayer: true});
 
166
        var map = new OpenLayers.Map('map', {
 
167
            maxExtent: new OpenLayers.Bounds(-100, -100, 100, 100)
 
168
        });
 
169
        map.addLayer(layer);
 
170
        var geometry = new OpenLayers.Geometry.Point(10, 10);
 
171
        var feature = new OpenLayers.Feature.Vector(geometry);
 
172
        
 
173
        var f, s;
 
174
        
 
175
        // Bogus layer renderer needs some methods
 
176
        // for functional tests.
 
177
        layer.drawn = true;
 
178
        layer.renderer = {
 
179
            drawFeature: function(feature, style) {
 
180
                f = feature;
 
181
                s = style;
 
182
            },
 
183
            root: document.createElement("div"),
 
184
            destroy: function() { },
 
185
            eraseFeatures: function() {},
 
186
            setExtent: function() {}
 
187
        };
 
188
        
 
189
 
 
190
        layer.drawFeature(feature);
 
191
        t.ok(geometry.equals(f.geometry),
 
192
             "calls layer.renderer.drawFeature() with feature.geometry");
 
193
        
 
194
        feature.style = {foo: "bar"};
 
195
        layer.drawFeature(feature);
 
196
        t.eq(feature.style, s,
 
197
             "calls layer.renderer.drawFeature() with feature.style");
 
198
        
 
199
        feature.style = null;
 
200
        layer.style = {foo: "bar"};
 
201
        layer.drawFeature(feature);
 
202
        t.eq(layer.style.foo, s.foo,
 
203
             "given null feature style, uses layer style");
 
204
 
 
205
        feature.style = {foo1: "bar1"};
 
206
        layer.style = {foo2: "bar2"};
 
207
        var customStyle = {foo: "bar"};
 
208
        layer.drawFeature(feature, customStyle);
 
209
        t.eq(customStyle.foo, s.foo,
 
210
             "given a custom style, renders with that");
 
211
        
 
212
        // the real renderer's drawFeature method is tested in Renderer.html
 
213
        layer.renderer.drawFeature = function(feature) {
 
214
            return(feature.geometry.getBounds().intersectsBounds(map.getExtent()));
 
215
        }
 
216
        // reset the drawn to null as if the layer had never been rendered
 
217
        layer.drawn = null;
 
218
        
 
219
        layer.drawFeature(feature);
 
220
        t.ok(true, "Trying to draw a feature on an not drawn layer doesn't throw any error.");
 
221
        
 
222
        layer.addFeatures([feature]);
 
223
        
 
224
        map.setCenter(new OpenLayers.Bounds(0, 0, 0, 0), 6);
 
225
        t.ok(layer.unrenderedFeatures[feature.id], "Did not render feature outside the viewport.");
 
226
        map.panTo(new OpenLayers.LonLat(10, 10));
 
227
        t.ok(!layer.unrenderedFeatures[feature.id], "Rendered feature inside the viewport.");
 
228
        
 
229
        layer.features = [];
 
230
    }
 
231
    
 
232
    function test_Layer_Vector_eraseFeatures(t) {
 
233
        t.plan(2);
 
234
        var layer = new OpenLayers.Layer.Vector("Test Layer");
 
235
        var map = new OpenLayers.Map('map');
 
236
        map.addLayer(layer);
 
237
        var geometry = new OpenLayers.Geometry.Point(10, 10);
 
238
        var feature = new OpenLayers.Feature.Vector(geometry);
 
239
        
 
240
        var f;
 
241
        layer.renderer = {
 
242
            eraseFeatures: function(features) {
 
243
                f = features[0];
 
244
            },
 
245
            destroy: function() { }
 
246
        };
 
247
 
 
248
        layer.eraseFeatures([feature]);
 
249
        t.ok(f, "calls layer.renderer.eraseFeatures");
 
250
        t.ok(geometry.equals(f.geometry),
 
251
             "calls layer.renderer.eraseFeatures() given an array of features");
 
252
    }
 
253
 
 
254
    function test_Layer_Vector_destroyFeatures (t) {
 
255
        t.plan(5); 
 
256
        layer = new OpenLayers.Layer.Vector(name);
 
257
        var map = new OpenLayers.Map('map');
 
258
        map.addLayer(layer);
 
259
        var features = [];
 
260
        for (var i = 0; i < 5; i++) {
 
261
            features.push(new OpenLayers.Feature.Vector(
 
262
                          new OpenLayers.Geometry.Point(0,0)));
 
263
        }
 
264
        layer.addFeatures(features);
 
265
        t.eq(layer.features.length, 5, "addFeatures adds 5 features");
 
266
        layer.selectedFeatures.push(features[0]); 
 
267
        layer.destroyFeatures();
 
268
        t.eq(layer.features.length, 0, "destroyFeatures triggers removal");
 
269
        t.eq(layer.selectedFeatures, [], "Destroy features removes selected features");
 
270
        features = [];
 
271
        for (var i = 0; i < 5; i++) {
 
272
            features.push(new OpenLayers.Feature.Vector(
 
273
                          new OpenLayers.Geometry.Point(0,0)));
 
274
        }
 
275
        layer.addFeatures(features);
 
276
        layer.selectedFeatures.push(features[0]);
 
277
        layer.selectedFeatures.push(features[1]);
 
278
        layer.destroyFeatures([features[0], features[1]]);
 
279
        t.eq(layer.features.length, 3, "destroyFeatures removes appropriate features");
 
280
        t.eq(layer.selectedFeatures, [], "destroyFeatures removes appropriate selected features");
 
281
    }
 
282
 
 
283
    function test_Layer_Vector_destroy (t) {
 
284
        t.plan(5);    
 
285
 
 
286
        var options = {protocol: new OpenLayers.Protocol(), 
 
287
                       strategies: [new OpenLayers.Strategy(), new OpenLayers.Strategy()]}
 
288
        var layer = new OpenLayers.Layer.Vector(name, options);
 
289
        var map = new OpenLayers.Map('map');
 
290
        map.addLayer(layer);
 
291
        layer.destroy();
 
292
        t.eq(layer.map, null, "layer.map is null after destroy");
 
293
        t.eq(layer.getFeatureFromEvent({'target':'map'}), null, 
 
294
            "getFeatureIdFromEvent doesn't cause an error when called on layer which has been destroyed.");
 
295
 
 
296
        t.eq(layer.protocol, null, "layer.protocol is null after destroy");
 
297
        t.eq(layer.strategies, null, "layer.strategies is null after destroy");
 
298
        
 
299
        // test that we can call layer.destroy a second time without trouble
 
300
        try {
 
301
            layer.destroy();
 
302
            layer.destroy();
 
303
            t.ok(true, "layer.destroy called twice without any issues");
 
304
        } catch(err) {
 
305
            t.fail("calling layer.destroy twice triggers exception: " + err + " in " + err.fileName + " line " + err.lineNumber);
 
306
        }
 
307
        
 
308
    }
 
309
 
 
310
    function test_Layer_Vector_externalGraphic(t) {
 
311
        t.plan(11);
 
312
        var layer = new OpenLayers.Layer.Vector("Test Layer", {isBaseLayer: true});
 
313
        var renderer = layer.renderer;
 
314
        var map = new OpenLayers.Map('map');
 
315
        map.addLayers([layer]);
 
316
 
 
317
        var geometryX = 10;
 
318
        var geometryY = 10;
 
319
        var geometry = new OpenLayers.Geometry.Point(geometryX, geometryY);
 
320
        var feature = new OpenLayers.Feature.Vector(geometry);
 
321
 
 
322
        map.zoomToMaxExtent();
 
323
 
 
324
        var customStyle1 = new Object({
 
325
                externalGraphic: 'test.png',
 
326
                pointRadius: 10
 
327
        });
 
328
        var customStyle2 = new Object({
 
329
                externalGraphic: 'test.png',
 
330
                graphicWidth: 12
 
331
        });
 
332
        var customStyle3 = new Object({
 
333
                externalGraphic: 'test.png',
 
334
                graphicHeight: 14
 
335
        });
 
336
        var customStyle4 = new Object({
 
337
                externalGraphic: 'test.png',
 
338
                graphicWidth: 24,
 
339
                graphicHeight: 16
 
340
        });
 
341
        var customStyle5 = new Object({
 
342
                externalGraphic: 'test.png',
 
343
                graphicWidth: 24,
 
344
                graphicOpacity: 1
 
345
        });
 
346
        var customStyle6 = new Object({
 
347
                externalGraphic: 'test.png',
 
348
                graphicWidth: 24,
 
349
                graphicHeight: 16,
 
350
                graphicXOffset: -24,
 
351
                graphicYOffset: -16
 
352
        });
 
353
               
 
354
        var root = renderer.root;
 
355
        if (layer.renderer.CLASS_NAME == 'OpenLayers.Renderer.SVG') {
 
356
                feature.style = customStyle1;
 
357
                layer.drawFeature(feature);
 
358
                t.eq(root.firstChild.getAttributeNS(null, 'width'),
 
359
                             (2*customStyle1.pointRadius).toString(),
 
360
                             "given a pointRadius, width equals 2*pointRadius");
 
361
                t.eq(root.firstChild.getAttributeNS(null, 'height'),
 
362
                             (2*customStyle1.pointRadius).toString(),
 
363
                             "given a pointRadius, height equals 2*pointRadius");
 
364
                feature.style = customStyle2;
 
365
                layer.drawFeature(feature);
 
366
                t.eq(root.firstChild.getAttributeNS(null, 'width'),
 
367
                             root.firstChild.getAttributeNS(null, 'height'),
 
368
                             "given a graphicWidth, width equals height");
 
369
                t.eq(root.firstChild.getAttributeNS(null, 'width'),
 
370
                             customStyle2.graphicWidth.toString(),
 
371
                             "width is set correctly");
 
372
                feature.style = customStyle3;
 
373
                layer.drawFeature(feature);
 
374
                t.eq(root.firstChild.getAttributeNS(null, 'height'),
 
375
                             root.firstChild.getAttributeNS(null, 'width'),
 
376
                             "given a graphicHeight, height equals width");
 
377
                t.eq(root.firstChild.getAttributeNS(null, 'height'),
 
378
                             customStyle3.graphicHeight.toString(),
 
379
                             "height is set correctly");
 
380
                feature.style = customStyle4;
 
381
                layer.drawFeature(feature);
 
382
                t.eq(root.firstChild.getAttributeNS(null, 'height'),
 
383
                             customStyle4.graphicHeight.toString(),
 
384
                             "given graphicHeight and graphicWidth, both are set: height");
 
385
                t.eq(root.firstChild.getAttributeNS(null, 'width'),
 
386
                             customStyle4.graphicWidth.toString(),
 
387
                             "given graphicHeight and graphicWidth, both are set: width");
 
388
                feature.style = customStyle5;
 
389
                layer.drawFeature(feature);
 
390
                t.eq(root.firstChild.getAttributeNS(null, 'style'),
 
391
                             'opacity: '+customStyle5.graphicOpacity.toString()+((OpenLayers.Util.getBrowserName() == "opera" || OpenLayers.Util.getBrowserName() == "safari") ? "" : ';'),
 
392
                             "graphicOpacity correctly set");
 
393
                feature.style = customStyle6;
 
394
                layer.drawFeature(feature);
 
395
                var x = geometryX / renderer.getResolution() + renderer.left;
 
396
                var y = geometryY / renderer.getResolution() - renderer.top;
 
397
                // SVG setStyle() gets x and y using getAttributeNS(), which returns
 
398
                // a value with only 3 decimal digits. To mimic this we use toFixed(3) here
 
399
                x = x.toFixed(3);
 
400
                y = y.toFixed(3);
 
401
                // toFixed() returns a string
 
402
                x = parseFloat(x);
 
403
                y = parseFloat(y);
 
404
                t.eq(root.firstChild.getAttributeNS(null, 'x'),
 
405
                        (x + customStyle6.graphicXOffset).toFixed().toString(),
 
406
                        "graphicXOffset correctly set");
 
407
                t.eq(root.firstChild.getAttributeNS(null, 'y'),
 
408
                        (-y + customStyle6.graphicYOffset).toFixed().toString(),
 
409
                        "graphicYOffset correctly set");
 
410
        }
 
411
        if (layer.renderer.CLASS_NAME == 'OpenLayers.Renderer.VML') {
 
412
                feature.style = customStyle1;
 
413
                layer.drawFeature(feature);
 
414
                t.eq(root.firstChild.style.width,
 
415
                             (2*customStyle1.pointRadius).toString()+'px',
 
416
                             "given a pointRadius, width equals 2*pointRadius");
 
417
                t.eq(root.firstChild.style.height,
 
418
                             (2*customStyle1.pointRadius).toString()+'px',
 
419
                             "given a pointRadius, height equals 2*pointRadius");
 
420
                feature.style = customStyle2;
 
421
                layer.drawFeature(feature);
 
422
                t.eq(root.firstChild.style.width,
 
423
                             root.firstChild.style.height,
 
424
                             "given a graphicWidth, width equals height");
 
425
                t.eq(root.firstChild.style.width,
 
426
                             customStyle2.graphicWidth.toString()+'px',
 
427
                             "width is set correctly");
 
428
                feature.style = customStyle3;
 
429
                layer.drawFeature(feature);
 
430
                t.eq(root.firstChild.style.height,
 
431
                             root.firstChild.style.width,
 
432
                             "given a graphicHeight, height equals width");
 
433
                t.eq(root.firstChild.style.height,
 
434
                             customStyle3.graphicHeight.toString()+'px',
 
435
                             "height is set correctly");
 
436
                feature.style = customStyle4;
 
437
                layer.drawFeature(feature);
 
438
                t.eq(root.firstChild.style.height,
 
439
                             customStyle4.graphicHeight.toString()+'px',
 
440
                             "given graphicHeight and graphicWidth, both are set: height");
 
441
                t.eq(root.firstChild.style.width,
 
442
                             customStyle4.graphicWidth.toString()+'px',
 
443
                             "given graphicHeight and graphicWidth, both are set: width");
 
444
                feature.style = customStyle5;
 
445
                layer.renderer.clear();
 
446
                layer.drawFeature(feature);
 
447
                var fill = root.firstChild.getElementsByTagName("v:fill")[0];
 
448
                var opacity;
 
449
                if(fill) {
 
450
                    opacity = fill.getAttribute('opacity');
 
451
                }
 
452
                if(opacity === undefined) {
 
453
                    fill = root.firstChild.getElementsByTagName("fill")[0];
 
454
                    opacity = fill.getAttribute('opacity');
 
455
                }
 
456
                t.eq(opacity,
 
457
                             customStyle5.graphicOpacity,
 
458
                             "graphicOpacity correctly set"); 
 
459
                feature.style = customStyle6;
 
460
                layer.drawFeature(feature);
 
461
                var x = geometryX / renderer.getResolution();
 
462
                var y = geometryY / renderer.getResolution();
 
463
                t.eq(root.firstChild.style.left,
 
464
                            (x + customStyle6.graphicXOffset).toFixed().toString()+'px',
 
465
                            "graphicXOffset correctly set");
 
466
                            
 
467
                t.eq(root.firstChild.style.top,
 
468
                            (y - (customStyle6.graphicYOffset+parseInt(root.firstChild.style.height))).toFixed().toString()+'px',
 
469
                            "graphicYOffset correctly set");
 
470
 
 
471
        }
 
472
    }
 
473
 
 
474
  </script>
 
475
</head>
 
476
<body>
 
477
<div id="map" style="width:500px;height:550px"></div>
 
478
</body>
 
479
</html>