1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
/* Copyright (c) 2006-2013 by OpenLayers Contributors (see authors.txt for
* full list of contributors). Published under the 2-clause BSD license.
* See license.txt in the OpenLayers distribution or repository for the
* full text of the license. */
/**
* @requires OpenLayers/Layer/Vector.js
*/
/**
* Class: OpenLayers.Layer.Vector.RootContainer
* A special layer type to combine multiple vector layers inside a single
* renderer root container. This class is not supposed to be instantiated
* from user space, it is a helper class for controls that require event
* processing for multiple vector layers.
*
* Inherits from:
* - <OpenLayers.Layer.Vector>
*/
OpenLayers.Layer.Vector.RootContainer = OpenLayers.Class(OpenLayers.Layer.Vector, {
/**
* Property: displayInLayerSwitcher
* Set to false for this layer type
*/
displayInLayerSwitcher: false,
/**
* APIProperty: layers
* Layers that are attached to this container. Required config option.
*/
layers: null,
/**
* Constructor: OpenLayers.Layer.Vector.RootContainer
* Create a new root container for multiple vector layer. This constructor
* is not supposed to be used from user space, it is only to be used by
* controls that need feature selection across multiple vector layers.
*
* Parameters:
* name - {String} A name for the layer
* options - {Object} Optional object with non-default properties to set on
* the layer.
*
* Required options properties:
* layers - {Array(<OpenLayers.Layer.Vector>)} The layers managed by this
* container
*
* Returns:
* {<OpenLayers.Layer.Vector.RootContainer>} A new vector layer root
* container
*/
/**
* Method: display
*/
display: function() {},
/**
* Method: getFeatureFromEvent
* walk through the layers to find the feature returned by the event
*
* Parameters:
* evt - {Object} event object with a feature property
*
* Returns:
* {<OpenLayers.Feature.Vector>}
*/
getFeatureFromEvent: function(evt) {
var layers = this.layers;
var feature;
for(var i=0; i<layers.length; i++) {
feature = layers[i].getFeatureFromEvent(evt);
if(feature) {
return feature;
}
}
},
/**
* Method: setMap
*
* Parameters:
* map - {<OpenLayers.Map>}
*/
setMap: function(map) {
OpenLayers.Layer.Vector.prototype.setMap.apply(this, arguments);
this.collectRoots();
map.events.register("changelayer", this, this.handleChangeLayer);
},
/**
* Method: removeMap
*
* Parameters:
* map - {<OpenLayers.Map>}
*/
removeMap: function(map) {
map.events.unregister("changelayer", this, this.handleChangeLayer);
this.resetRoots();
OpenLayers.Layer.Vector.prototype.removeMap.apply(this, arguments);
},
/**
* Method: collectRoots
* Collects the root nodes of all layers this control is configured with
* and moveswien the nodes to this control's layer
*/
collectRoots: function() {
var layer;
// walk through all map layers, because we want to keep the order
for(var i=0; i<this.map.layers.length; ++i) {
layer = this.map.layers[i];
if(OpenLayers.Util.indexOf(this.layers, layer) != -1) {
layer.renderer.moveRoot(this.renderer);
}
}
},
/**
* Method: resetRoots
* Resets the root nodes back into the layers they belong to.
*/
resetRoots: function() {
var layer;
for(var i=0; i<this.layers.length; ++i) {
layer = this.layers[i];
if(this.renderer && layer.renderer.getRenderLayerId() == this.id) {
this.renderer.moveRoot(layer.renderer);
}
}
},
/**
* Method: handleChangeLayer
* Event handler for the map's changelayer event. We need to rebuild
* this container's layer dom if order of one of its layers changes.
* This handler is added with the setMap method, and removed with the
* removeMap method.
*
* Parameters:
* evt - {Object}
*/
handleChangeLayer: function(evt) {
var layer = evt.layer;
if(evt.property == "order" &&
OpenLayers.Util.indexOf(this.layers, layer) != -1) {
this.resetRoots();
this.collectRoots();
}
},
CLASS_NAME: "OpenLayers.Layer.Vector.RootContainer"
});
|
