openlayers/tests/Strategy/Fixed.html

   1 <html>
   2 <head>
   3   <script src="../../lib/OpenLayers.js"></script>
   4   <script type="text/javascript">
   5
   6     function test_activate(t) {
   7         t.plan(5);
   8
   9         var featureList = ['foo', 'bar'];
  10         // a fake protocol
  11         var protocol = {
  12             read: function(options) {
  13                 options.callback.call(options.scope, {features: featureList});
  14             }
  15         };
  16
  17         // Create a dummy layer that can act as the map base layer.
  18         // This will be unnecessary if #1920 is addressed or if base layer
  19         // handling is changed.
  20         var dummy = new OpenLayers.Layer(null, {isBaseLayer: true});
  21
  22         var layer = new OpenLayers.Layer.Vector("Vector Layer", {
  23             strategies: [new OpenLayers.Strategy.Fixed()],
  24             protocol: protocol,
  25             addFeatures: function(features) {
  26                 t.eq(features, featureList, "Features added to the layer");
  27             }
  28         });
  29
  30         var layerp = new OpenLayers.Layer.Vector("Hidden preload Layer", {
  31             strategies: [new OpenLayers.Strategy.Fixed({preload:true})],
  32             protocol: protocol,
  33             visibility: false,
  34             addFeatures: function(features) {
  35                 t.ok(!this.visibility, "Features preloaded before visible");
  36             }
  37         });
  38
  39         var s = new OpenLayers.Strategy.Fixed();
  40         var layer2 = new OpenLayers.Layer.Vector("Hidden lazyload Layer", {
  41             strategies: [s],
  42             protocol: protocol,
  43             visibility: false,
  44             addFeatures: function(features) {
  45                 t.ok(this.visibility, "Layer visible when features added");
  46             }
  47         });
  48
  49         var map = new OpenLayers.Map('map');
  50         map.addLayers([dummy, layer, layerp, layer2]);
  51
  52         t.ok(layer2.events.listeners["visibilitychanged"][0].obj == s &&
  53                 layer2.events.listeners["visibilitychanged"][0].func == s.load,
  54                 "activate registers visibilitychanged listener if layer hidden"+
  55                 " and is lazyloading");
  56
  57         layer2.setVisibility(true);
  58
  59         t.ok(layer2.events.listeners["visibilitychanged"] == false,
  60                 "visibilitychanged listener unregistered");
  61     }
  62
  63     function test_events(t) {
  64
  65         t.plan(3);
  66
  67         var log = {
  68             loadstart: 0,
  69             loadend: 0
  70         };
  71
  72         var map = new OpenLayers.Map("map");
  73         var layer = new OpenLayers.Layer.Vector(null, {
  74             strategies: [new OpenLayers.Strategy.Fixed()],
  75             protocol: new OpenLayers.Protocol({
  76                 read: function(config) {
  77                     config.callback.call(config.scope, {});
  78                 }
  79             }),
  80             isBaseLayer: true,
  81             eventListeners: {
  82                 loadstart: function() {
  83                     ++log.loadstart;
  84                 },
  85                 loadend: function() {
  86                     ++log.loadend;
  87                 }
  88             }
  89         });
  90
  91         map.addLayer(layer);
  92         map.zoomToMaxExtent();
  93
  94         t.eq(log.loadstart, 1, "loadstart triggered");
  95         t.eq(log.loadend, 1, "loadend triggered");
  96         var log = {};
  97         layer.protocol.read = function(obj) {
  98             log.obj = obj;
  99         }
 100         layer.refresh({whee: 'chicken'});
 101
 102         t.eq(log.obj && log.obj.whee, "chicken", "properties passed to read on refresh correctly.");
 103
 104         map.destroy();
 105
 106     }
 107
 108
 109     function test_merge(t) {
 110
 111         t.plan(6);
 112
 113         var strategy = new OpenLayers.Strategy.Fixed();
 114
 115         // create map with default projection
 116         var map = new OpenLayers.Map("map");
 117
 118         var log = {
 119             loadend: 0
 120         };
 121
 122         // create layer with custom projection
 123         var layer = new OpenLayers.Layer.Vector(null, {
 124             isBaseLayer: true,
 125             strategies: [strategy],
 126             protocol: new OpenLayers.Protocol(),
 127             projection: new OpenLayers.Projection("EPSG:900913"),
 128             eventListeners: {
 129                 loadend: function() {
 130                     ++log.loadend;
 131                 }
 132             }
 133         });
 134
 135         // give the layer some existing features (one)
 136         layer.addFeatures([
 137             new OpenLayers.Feature.Vector(
 138                 new OpenLayers.Geometry.Point(0, 0)
 139             )
 140         ]);
 141
 142         map.addLayer(layer);
 143         map.zoomToMaxExtent();
 144
 145         // create some features
 146         var geometries = [
 147             new OpenLayers.Geometry.Point(100, 200),
 148             new OpenLayers.Geometry.Point(1000, 2000)
 149         ];
 150         var features = [
 151             new OpenLayers.Feature.Vector(geometries[0].clone()),
 152             new OpenLayers.Feature.Vector(geometries[1].clone())
 153         ];
 154
 155         // call merge with a mocked up response
 156         strategy.merge({features: features});
 157
 158         // confirm that the original features were destroyed
 159         t.eq(layer.features.length, 2, "old features destroyed");
 160
 161         // confirm that loadend was called
 162         t.eq(log.loadend, 1, "merge triggers loadend");
 163
 164         // test that feature geometries have been transformed to map projection
 165         var from = layer.projection;
 166         var to = map.getProjectionObject();
 167         t.geom_eq(layer.features[0].geometry, features[0].geometry.transform(from, to), "[different proj] feature 0 geometry transformed");
 168         t.geom_eq(layer.features[1].geometry, features[1].geometry.transform(from, to), "[different proj] feature 1 geometry transformed");
 169
 170         // same as above but with same map/layer projection
 171         layer.destroyFeatures();
 172         layer.projection = map.getProjectionObject();
 173
 174         features = [
 175             new OpenLayers.Feature.Vector(geometries[0].clone()),
 176             new OpenLayers.Feature.Vector(geometries[1].clone())
 177         ];
 178
 179         // call merge again with mocked up response
 180         strategy.merge({features: features});
 181
 182         // test that feature geometries have not been transformed
 183         t.geom_eq(layer.features[0].geometry, features[0].geometry, "[same proj] feature 0 geometry not transformed");
 184         t.geom_eq(layer.features[1].geometry, features[1].geometry, "[same proj] feature 1 geometry not transformed");
 185
 186     }
 187
 188   </script>
 189 </head>
 190 <body>
 191     <div id="map" style="width: 400px; height: 200px" />
 192 </body>
 193 </html>