Add a map property to layers

2021-11-12 17:11:26 -07:00
parent 080fe8ca67
commit 371bb85350
7 changed files with 446 additions and 24 deletions
@@ -8,12 +8,15 @@ import ImageLayer from '../../../../src/ol/layer/Image.js';
 import ImageState from '../../../../src/ol/ImageState.js';
 import ImageStatic from '../../../../src/ol/source/ImageStatic.js';
 import Interaction from '../../../../src/ol/interaction/Interaction.js';
+import Layer from '../../../../src/ol/layer/Layer.js';
+import LayerGroup from '../../../../src/ol/layer/Group.js';
 import Map from '../../../../src/ol/Map.js';
 import MapBrowserEvent from '../../../../src/ol/MapBrowserEvent.js';
 import MapEvent from '../../../../src/ol/MapEvent.js';
 import MouseWheelZoom from '../../../../src/ol/interaction/MouseWheelZoom.js';
 import Overlay from '../../../../src/ol/Overlay.js';
 import PinchZoom from '../../../../src/ol/interaction/PinchZoom.js';
+import Property from '../../../../src/ol/layer/Property.js';
 import Select from '../../../../src/ol/interaction/Select.js';
 import TileLayer from '../../../../src/ol/layer/Tile.js';
 import TileLayerRenderer from '../../../../src/ol/renderer/canvas/TileLayer.js';
@@ -166,6 +169,7 @@ describe('ol/Map', function () {
      map.addLayer(layer);

      expect(map.getLayers().item(0)).to.be(layer);
+      expect(layer.get(Property.MAP)).to.be(map);
    });

    it('throws if a layer is added twice', function () {
@@ -180,6 +184,55 @@ describe('ol/Map', function () {
    });
  });

+  describe('#removeLayer()', function () {
+    it('removes a layer from the map', function () {
+      const map = new Map({});
+      const layer = new TileLayer();
+      map.addLayer(layer);
+
+      expect(layer.get(Property.MAP)).to.be(map);
+      map.removeLayer(layer);
+      expect(layer.get(Property.MAP)).to.be(null);
+    });
+
+    it('removes a layer group from the map', function () {
+      const map = new Map({});
+      const layer = new TileLayer();
+      const group = new LayerGroup({layers: [layer]});
+      map.addLayer(group);
+      expect(layer.get(Property.MAP)).to.be(map);
+
+      map.removeLayer(group);
+      expect(layer.get(Property.MAP)).to.be(null);
+    });
+  });
+
+  describe('#setLayerGroup()', function () {
+    it('sets the layer group', function () {
+      const map = new Map({});
+
+      const layer = new Layer({});
+      const group = new LayerGroup({layers: [layer]});
+      map.setLayerGroup(group);
+
+      expect(map.getLayerGroup()).to.be(group);
+      expect(layer.get(Property.MAP)).to.be(map);
+    });
+
+    it('removes the map property from old layers', function () {
+      const oldLayer = new Layer({});
+      const map = new Map({layers: [oldLayer]});
+      expect(oldLayer.get(Property.MAP)).to.be(map);
+
+      const layer = new Layer({});
+      const group = new LayerGroup({layers: [layer]});
+      map.setLayerGroup(group);
+
+      expect(layer.get(Property.MAP)).to.be(map);
+      expect(oldLayer.get(Property.MAP)).to.be(null);
+    });
+  });
+
  describe('#setLayers()', function () {
    it('adds an array of layers to the map', function () {
      const map = new Map({});
@@ -192,12 +245,21 @@ describe('ol/Map', function () {
      expect(collection.getLength()).to.be(2);
      expect(collection.item(0)).to.be(layer0);
      expect(collection.item(1)).to.be(layer1);
+      expect(layer0.get(Property.MAP)).to.be(map);
+      expect(layer1.get(Property.MAP)).to.be(map);
    });

    it('clears any existing layers', function () {
-      const map = new Map({layers: [new TileLayer()]});
+      const oldLayer = new TileLayer();
+      const map = new Map({layers: [oldLayer]});
+      expect(oldLayer.get(Property.MAP)).to.be(map);

-      map.setLayers([new TileLayer(), new TileLayer()]);
+      const newLayer1 = new TileLayer();
+      const newLayer2 = new TileLayer();
+      map.setLayers([newLayer1, newLayer2]);
+      expect(newLayer1.get(Property.MAP)).to.be(map);
+      expect(newLayer2.get(Property.MAP)).to.be(map);
+      expect(oldLayer.get(Property.MAP)).to.be(null);

      expect(map.getLayers().getLength()).to.be(2);
    });
@@ -6,7 +6,7 @@ import {assign} from '../../../../../src/ol/obj.js';
 import {getIntersection} from '../../../../../src/ol/extent.js';
 import {getUid} from '../../../../../src/ol/util.js';

-describe('ol.layer.Group', function () {
+describe('ol/layer/Group', function () {
  function disposeHierarchy(layer) {
    if (layer instanceof LayerGroup) {
      layer.getLayers().forEach((l) => disposeHierarchy(l));
@@ -219,6 +219,160 @@ describe('ol.layer.Group', function () {
    });
  });

+  describe('addlayer event', () => {
+    it('is dispatched when a layer is added', (done) => {
+      const group = new LayerGroup();
+      const layer = new Layer({});
+      group.on('addlayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      group.getLayers().push(layer);
+    });
+
+    it('is dispatched once for each layer added', (done) => {
+      const group = new LayerGroup();
+      const layers = [new Layer({}), new Layer({}), new Layer({})];
+
+      let count = 0;
+      group.on('addlayer', (event) => {
+        expect(event.layer).to.be(layers[count]);
+        count++;
+        if (count === layers.length) {
+          done();
+        }
+      });
+
+      group.getLayers().extend(layers);
+    });
+
+    it('is dispatched when setLayers is called', (done) => {
+      const group = new LayerGroup();
+
+      const layers = [new Layer({}), new Layer({}), new Layer({})];
+
+      let count = 0;
+      group.on('addlayer', (event) => {
+        expect(event.layer).to.be(layers[count]);
+        count++;
+        if (count === layers.length) {
+          done();
+        }
+      });
+
+      group.setLayers(new Collection(layers));
+    });
+
+    it('is dispatched when a layer group is added', (done) => {
+      const group = new LayerGroup();
+      const layer = new LayerGroup();
+      group.on('addlayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      group.getLayers().push(layer);
+    });
+
+    it('is dispatched for each layer added to a child group', (done) => {
+      const group = new LayerGroup();
+      const child = new LayerGroup();
+      group.getLayers().push(child);
+
+      const layer = new Layer({});
+      group.on('addlayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      child.getLayers().push(layer);
+    });
+
+    it('is dispatched for each layer added to a child group configured at construction', (done) => {
+      const child = new LayerGroup();
+      const group = new LayerGroup({
+        layers: [child],
+      });
+
+      const layer = new Layer({});
+      group.on('addlayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      child.getLayers().push(layer);
+    });
+
+    it('is not dispatched for layers added to a child group after the child group is removed', (done) => {
+      const child = new LayerGroup();
+      const group = new LayerGroup({
+        layers: [child],
+      });
+
+      const layer = new Layer({});
+      group.on('addlayer', (event) => {
+        done(new Error('unexpected addlayer after group removal'));
+      });
+
+      group.getLayers().remove(child);
+      child.getLayers().push(layer);
+
+      setTimeout(done, 10);
+    });
+  });
+
+  describe('removelayer event', () => {
+    it('is dispatched when a layer is removed', (done) => {
+      const layer = new Layer({});
+      const group = new LayerGroup({layers: [layer]});
+      group.on('removelayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      group.getLayers().remove(layer);
+    });
+
+    it('is dispatched when a setLayers is called', (done) => {
+      const layer = new Layer({});
+      const group = new LayerGroup({layers: [layer]});
+      group.on('removelayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      group.setLayers(new Collection());
+    });
+
+    it('is dispatched when a layer is removed from a child group', (done) => {
+      const layer = new Layer({});
+      const child = new LayerGroup({layers: [layer]});
+      const group = new LayerGroup({layers: [child]});
+      group.on('removelayer', (event) => {
+        expect(event.layer).to.be(layer);
+        done();
+      });
+
+      child.getLayers().remove(layer);
+    });
+
+    it('is not dispatched when a layer is removed from a child group after child group removal', (done) => {
+      const layer = new Layer({});
+      const child = new LayerGroup({layers: [layer]});
+      const group = new LayerGroup({layers: [child]});
+      group.getLayers().remove(child);
+
+      group.on('removelayer', (event) => {
+        done(new Error('unexpected removelayer after group removal'));
+      });
+
+      child.getLayers().remove(layer);
+
+      setTimeout(done, 10);
+    });
+  });
+
  describe('#getLayerState', function () {
    let group;

@@ -1,10 +1,12 @@
+import Group from '../../../../../src/ol/layer/Group.js';
 import Layer, {inView} from '../../../../../src/ol/layer/Layer.js';
 import Map from '../../../../../src/ol/Map.js';
+import Property from '../../../../../src/ol/layer/Property.js';
 import RenderEvent from '../../../../../src/ol/render/Event.js';
 import Source from '../../../../../src/ol/source/Source.js';
 import {get as getProjection} from '../../../../../src/ol/proj.js';

-describe('ol.layer.Layer', function () {
+describe('ol/layer/Layer', function () {
  describe('constructor (defaults)', function () {
    let layer;

@@ -620,6 +622,79 @@ describe('ol.layer.Layer', function () {
    });
  });

+  describe('map property', () => {
+    it('is set when a layer is added to a map', () => {
+      const map = new Map({});
+      const layer = new Layer({});
+      map.addLayer(layer);
+
+      expect(layer.get(Property.MAP)).to.be(map);
+    });
+
+    it('is set when a layer is added to a map in the constructor', () => {
+      const layer = new Layer({});
+      const map = new Map({layers: [layer]});
+
+      expect(layer.get(Property.MAP)).to.be(map);
+    });
+
+    it('is set when a layer is added to a group', () => {
+      const layer = new Layer({});
+      const group = new Group();
+      const map = new Map({});
+      map.addLayer(group);
+      group.getLayers().push(layer);
+
+      expect(layer.get(Property.MAP)).to.be(map);
+    });
+
+    it('is set when a layer is added to a group set in the constructor', () => {
+      const layer = new Layer({});
+      const group = new Group();
+      const map = new Map({layers: [group]});
+      group.getLayers().push(layer);
+
+      expect(layer.get(Property.MAP)).to.be(map);
+    });
+
+    it('is set when a layer already added to a group set in the constructor', () => {
+      const layer = new Layer({});
+      const group = new Group({layers: [layer]});
+      const map = new Map({layers: [group]});
+
+      expect(layer.get(Property.MAP)).to.be(map);
+    });
+
+    it('is removed when a layer is removed from the map', () => {
+      const map = new Map({});
+      const layer = new Layer({});
+      map.addLayer(layer);
+      expect(layer.get(Property.MAP)).to.be(map);
+
+      map.removeLayer(layer);
+      expect(layer.get(Property.MAP)).to.be(null);
+    });
+
+    it('is removed when a layer added in the constructor is removed from the map', () => {
+      const layer = new Layer({});
+      const map = new Map({layers: [layer]});
+      expect(layer.get(Property.MAP)).to.be(map);
+
+      map.removeLayer(layer);
+      expect(layer.get(Property.MAP)).to.be(null);
+    });
+
+    it('is removed when a layer is removed from a group', () => {
+      const layer = new Layer({});
+      const group = new Group({layers: [layer]});
+      const map = new Map({layers: [group]});
+      expect(layer.get(Property.MAP)).to.be(map);
+
+      group.getLayers().remove(layer);
+      expect(layer.get(Property.MAP)).to.be(null);
+    });
+  });
+
  describe('#setMap (unmanaged layer)', function () {
    let map;