cc2e19d789
geometries. Thanks crschmidt for the great help with this patch, and thanks to camptocamp for the initial work on this and rcoup for creating the first patches. r=crschmidt (closes #1895) git-svn-id: http://svn.openlayers.org/trunk/openlayers@9262 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
1014 lines
32 KiB
JavaScript
1014 lines
32 KiB
JavaScript
/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
|
|
* license. See http://svn.openlayers.org/trunk/openlayers/license.txt for the
|
|
* full text of the license. */
|
|
|
|
/**
|
|
* @requires OpenLayers/Renderer.js
|
|
*/
|
|
|
|
/**
|
|
* Class: OpenLayers.ElementsIndexer
|
|
* This class takes care of figuring out which order elements should be
|
|
* placed in the DOM based on given indexing methods.
|
|
*/
|
|
OpenLayers.ElementsIndexer = OpenLayers.Class({
|
|
|
|
/**
|
|
* Property: maxZIndex
|
|
* {Integer} This is the largest-most z-index value for a node
|
|
* contained within the indexer.
|
|
*/
|
|
maxZIndex: null,
|
|
|
|
/**
|
|
* Property: order
|
|
* {Array<String>} This is an array of node id's stored in the
|
|
* order that they should show up on screen. Id's higher up in the
|
|
* array (higher array index) represent nodes with higher z-indeces.
|
|
*/
|
|
order: null,
|
|
|
|
/**
|
|
* Property: indices
|
|
* {Object} This is a hash that maps node ids to their z-index value
|
|
* stored in the indexer. This is done to make finding a nodes z-index
|
|
* value O(1).
|
|
*/
|
|
indices: null,
|
|
|
|
/**
|
|
* Property: compare
|
|
* {Function} This is the function used to determine placement of
|
|
* of a new node within the indexer. If null, this defaults to to
|
|
* the Z_ORDER_DRAWING_ORDER comparison method.
|
|
*/
|
|
compare: null,
|
|
|
|
/**
|
|
* APIMethod: initialize
|
|
* Create a new indexer with
|
|
*
|
|
* Parameters:
|
|
* yOrdering - {Boolean} Whether to use y-ordering.
|
|
*/
|
|
initialize: function(yOrdering) {
|
|
|
|
this.compare = yOrdering ?
|
|
OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_Y_ORDER :
|
|
OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER_DRAWING_ORDER;
|
|
|
|
this.order = [];
|
|
this.indices = {};
|
|
this.maxZIndex = 0;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: insert
|
|
* Insert a new node into the indexer. In order to find the correct
|
|
* positioning for the node to be inserted, this method uses a binary
|
|
* search. This makes inserting O(log(n)).
|
|
*
|
|
* Parameters:
|
|
* newNode - {DOMElement} The new node to be inserted.
|
|
*
|
|
* Returns
|
|
* {DOMElement} the node before which we should insert our newNode, or
|
|
* null if newNode can just be appended.
|
|
*/
|
|
insert: function(newNode) {
|
|
// If the node is known to the indexer, remove it so we can
|
|
// recalculate where it should go.
|
|
if (this.exists(newNode)) {
|
|
this.remove(newNode);
|
|
}
|
|
|
|
var nodeId = newNode.id;
|
|
|
|
this.determineZIndex(newNode);
|
|
|
|
var leftIndex = -1;
|
|
var rightIndex = this.order.length;
|
|
var middle;
|
|
|
|
while (rightIndex - leftIndex > 1) {
|
|
middle = parseInt((leftIndex + rightIndex) / 2);
|
|
|
|
var placement = this.compare(this, newNode,
|
|
OpenLayers.Util.getElement(this.order[middle]));
|
|
|
|
if (placement > 0) {
|
|
leftIndex = middle;
|
|
} else {
|
|
rightIndex = middle;
|
|
}
|
|
}
|
|
|
|
this.order.splice(rightIndex, 0, nodeId);
|
|
this.indices[nodeId] = this.getZIndex(newNode);
|
|
|
|
// If the new node should be before another in the index
|
|
// order, return the node before which we have to insert the new one;
|
|
// else, return null to indicate that the new node can be appended.
|
|
return this.getNextElement(rightIndex);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: remove
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement} The node to be removed.
|
|
*/
|
|
remove: function(node) {
|
|
var nodeId = node.id;
|
|
var arrayIndex = OpenLayers.Util.indexOf(this.order, nodeId);
|
|
if (arrayIndex >= 0) {
|
|
// Remove it from the order array, as well as deleting the node
|
|
// from the indeces hash.
|
|
this.order.splice(arrayIndex, 1);
|
|
delete this.indices[nodeId];
|
|
|
|
// Reset the maxium z-index based on the last item in the
|
|
// order array.
|
|
if (this.order.length > 0) {
|
|
var lastId = this.order[this.order.length - 1];
|
|
this.maxZIndex = this.indices[lastId];
|
|
} else {
|
|
this.maxZIndex = 0;
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* APIMethod: clear
|
|
*/
|
|
clear: function() {
|
|
this.order = [];
|
|
this.indices = {};
|
|
this.maxZIndex = 0;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: exists
|
|
*
|
|
* Parameters:
|
|
* node- {DOMElement} The node to test for existence.
|
|
*
|
|
* Returns:
|
|
* {Boolean} Whether or not the node exists in the indexer?
|
|
*/
|
|
exists: function(node) {
|
|
return (this.indices[node.id] != null);
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getZIndex
|
|
* Get the z-index value for the current node from the node data itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement} The node whose z-index to get.
|
|
*
|
|
* Returns:
|
|
* {Integer} The z-index value for the specified node (from the node
|
|
* data itself).
|
|
*/
|
|
getZIndex: function(node) {
|
|
return node._style.graphicZIndex;
|
|
},
|
|
|
|
/**
|
|
* Method: determineZIndex
|
|
* Determine the z-index for the current node if there isn't one,
|
|
* and set the maximum value if we've found a new maximum.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
*/
|
|
determineZIndex: function(node) {
|
|
var zIndex = node._style.graphicZIndex;
|
|
|
|
// Everything must have a zIndex. If none is specified,
|
|
// this means the user *must* (hint: assumption) want this
|
|
// node to succomb to drawing order. To enforce drawing order
|
|
// over all indexing methods, we'll create a new z-index that's
|
|
// greater than any currently in the indexer.
|
|
if (zIndex == null) {
|
|
zIndex = this.maxZIndex;
|
|
node._style.graphicZIndex = zIndex;
|
|
} else if (zIndex > this.maxZIndex) {
|
|
this.maxZIndex = zIndex;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* APIMethod: getNextElement
|
|
* Get the next element in the order stack.
|
|
*
|
|
* Parameters:
|
|
* index - {Integer} The index of the current node in this.order.
|
|
*
|
|
* Returns:
|
|
* {DOMElement} the node following the index passed in, or
|
|
* null.
|
|
*/
|
|
getNextElement: function(index) {
|
|
var nextIndex = index + 1;
|
|
if (nextIndex < this.order.length){
|
|
var nextElement = OpenLayers.Util.getElement(this.order[nextIndex]);
|
|
if (nextElement == undefined){
|
|
nextElement = this.getNextElement(nextIndex);
|
|
}
|
|
return nextElement;
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.ElementsIndexer"
|
|
});
|
|
|
|
/**
|
|
* Namespace: OpenLayers.ElementsIndexer.IndexingMethods
|
|
* These are the compare methods for figuring out where a new node should be
|
|
* placed within the indexer. These methods are very similar to general
|
|
* sorting methods in that they return -1, 0, and 1 to specify the
|
|
* direction in which new nodes fall in the ordering.
|
|
*/
|
|
OpenLayers.ElementsIndexer.IndexingMethods = {
|
|
|
|
/**
|
|
* Method: Z_ORDER
|
|
* This compare method is used by other comparison methods.
|
|
* It can be used individually for ordering, but is not recommended,
|
|
* because it doesn't subscribe to drawing order.
|
|
*
|
|
* Parameters:
|
|
* indexer - {<OpenLayers.ElementsIndexer>}
|
|
* newNode - {DOMElement}
|
|
* nextNode - {DOMElement}
|
|
*
|
|
* Returns:
|
|
* {Integer}
|
|
*/
|
|
Z_ORDER: function(indexer, newNode, nextNode) {
|
|
var newZIndex = indexer.getZIndex(newNode);
|
|
|
|
var returnVal = 0;
|
|
if (nextNode) {
|
|
var nextZIndex = indexer.getZIndex(nextNode);
|
|
returnVal = newZIndex - nextZIndex;
|
|
}
|
|
|
|
return returnVal;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: Z_ORDER_DRAWING_ORDER
|
|
* This method orders nodes by their z-index, but does so in a way
|
|
* that, if there are other nodes with the same z-index, the newest
|
|
* drawn will be the front most within that z-index. This is the
|
|
* default indexing method.
|
|
*
|
|
* Parameters:
|
|
* indexer - {<OpenLayers.ElementsIndexer>}
|
|
* newNode - {DOMElement}
|
|
* nextNode - {DOMElement}
|
|
*
|
|
* Returns:
|
|
* {Integer}
|
|
*/
|
|
Z_ORDER_DRAWING_ORDER: function(indexer, newNode, nextNode) {
|
|
var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(
|
|
indexer,
|
|
newNode,
|
|
nextNode
|
|
);
|
|
|
|
// Make Z_ORDER subscribe to drawing order by pushing it above
|
|
// all of the other nodes with the same z-index.
|
|
if (nextNode && returnVal == 0) {
|
|
returnVal = 1;
|
|
}
|
|
|
|
return returnVal;
|
|
},
|
|
|
|
/**
|
|
* APIMethod: Z_ORDER_Y_ORDER
|
|
* This one should really be called Z_ORDER_Y_ORDER_DRAWING_ORDER, as it
|
|
* best describes which ordering methods have precedence (though, the
|
|
* name would be too long). This method orders nodes by their z-index,
|
|
* but does so in a way that, if there are other nodes with the same
|
|
* z-index, the nodes with the lower y position will be "closer" than
|
|
* those with a higher y position. If two nodes have the exact same y
|
|
* position, however, then this method will revert to using drawing
|
|
* order to decide placement.
|
|
*
|
|
* Parameters:
|
|
* indexer - {<OpenLayers.ElementsIndexer>}
|
|
* newNode - {DOMElement}
|
|
* nextNode - {DOMElement}
|
|
*
|
|
* Returns:
|
|
* {Integer}
|
|
*/
|
|
Z_ORDER_Y_ORDER: function(indexer, newNode, nextNode) {
|
|
var returnVal = OpenLayers.ElementsIndexer.IndexingMethods.Z_ORDER(
|
|
indexer,
|
|
newNode,
|
|
nextNode
|
|
);
|
|
|
|
if (nextNode && returnVal == 0) {
|
|
var newLat = newNode._geometry.getBounds().bottom;
|
|
var nextLat = nextNode._geometry.getBounds().bottom;
|
|
|
|
var result = nextLat - newLat;
|
|
returnVal = (result ==0) ? 1 : result;
|
|
}
|
|
|
|
return returnVal;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Class: OpenLayers.Renderer.Elements
|
|
* This is another virtual class in that it should never be instantiated by
|
|
* itself as a Renderer. It exists because there is *tons* of shared
|
|
* functionality between different vector libraries which use nodes/elements
|
|
* as a base for rendering vectors.
|
|
*
|
|
* The highlevel bits of code that are implemented here are the adding and
|
|
* removing of geometries, which is essentially the same for any
|
|
* element-based renderer. The details of creating each node and drawing the
|
|
* paths are of course different, but the machinery is the same.
|
|
*
|
|
* Inherits:
|
|
* - <OpenLayers.Renderer>
|
|
*/
|
|
OpenLayers.Renderer.Elements = OpenLayers.Class(OpenLayers.Renderer, {
|
|
|
|
/**
|
|
* Property: rendererRoot
|
|
* {DOMElement}
|
|
*/
|
|
rendererRoot: null,
|
|
|
|
/**
|
|
* Property: root
|
|
* {DOMElement}
|
|
*/
|
|
root: null,
|
|
|
|
/**
|
|
* Property: vectorRoot
|
|
* {DOMElement}
|
|
*/
|
|
vectorRoot: null,
|
|
|
|
/**
|
|
* Property: textRoot
|
|
* {DOMElement}
|
|
*/
|
|
textRoot: null,
|
|
|
|
/**
|
|
* Property: xmlns
|
|
* {String}
|
|
*/
|
|
xmlns: null,
|
|
|
|
/**
|
|
* Property: Indexer
|
|
* {<OpenLayers.ElementIndexer>} An instance of OpenLayers.ElementsIndexer
|
|
* created upon initialization if the zIndexing or yOrdering options
|
|
* passed to this renderer's constructor are set to true.
|
|
*/
|
|
indexer: null,
|
|
|
|
/**
|
|
* Constant: BACKGROUND_ID_SUFFIX
|
|
* {String}
|
|
*/
|
|
BACKGROUND_ID_SUFFIX: "_background",
|
|
|
|
/**
|
|
* Constant: BACKGROUND_ID_SUFFIX
|
|
* {String}
|
|
*/
|
|
LABEL_ID_SUFFIX: "_label",
|
|
|
|
/**
|
|
* Property: minimumSymbolizer
|
|
* {Object}
|
|
*/
|
|
minimumSymbolizer: {
|
|
strokeLinecap: "round",
|
|
strokeOpacity: 1,
|
|
strokeDashstyle: "solid",
|
|
fillOpacity: 1,
|
|
pointRadius: 0
|
|
},
|
|
|
|
/**
|
|
* Constructor: OpenLayers.Renderer.Elements
|
|
*
|
|
* Parameters:
|
|
* containerID - {String}
|
|
* options - {Object} options for this renderer. Supported options are:
|
|
* * yOrdering - {Boolean} Whether to use y-ordering
|
|
* * zIndexing - {Boolean} Whether to use z-indexing. Will be ignored
|
|
* if yOrdering is set to true.
|
|
*/
|
|
initialize: function(containerID, options) {
|
|
OpenLayers.Renderer.prototype.initialize.apply(this, arguments);
|
|
|
|
this.rendererRoot = this.createRenderRoot();
|
|
this.root = this.createRoot("_root");
|
|
this.vectorRoot = this.createRoot("_vroot");
|
|
this.textRoot = this.createRoot("_troot");
|
|
|
|
this.root.appendChild(this.vectorRoot);
|
|
this.root.appendChild(this.textRoot);
|
|
|
|
this.rendererRoot.appendChild(this.root);
|
|
this.container.appendChild(this.rendererRoot);
|
|
|
|
if(options && (options.zIndexing || options.yOrdering)) {
|
|
this.indexer = new OpenLayers.ElementsIndexer(options.yOrdering);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: destroy
|
|
*/
|
|
destroy: function() {
|
|
|
|
this.clear();
|
|
|
|
this.rendererRoot = null;
|
|
this.root = null;
|
|
this.xmlns = null;
|
|
|
|
OpenLayers.Renderer.prototype.destroy.apply(this, arguments);
|
|
},
|
|
|
|
/**
|
|
* Method: clear
|
|
* Remove all the elements from the root
|
|
*/
|
|
clear: function() {
|
|
if (this.vectorRoot) {
|
|
while (this.vectorRoot.childNodes.length > 0) {
|
|
this.vectorRoot.removeChild(this.vectorRoot.firstChild);
|
|
}
|
|
}
|
|
if (this.textRoot) {
|
|
while (this.textRoot.childNodes.length > 0) {
|
|
this.textRoot.removeChild(this.textRoot.firstChild);
|
|
}
|
|
}
|
|
if (this.indexer) {
|
|
this.indexer.clear();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: getNodeType
|
|
* This function is in charge of asking the specific renderer which type
|
|
* of node to create for the given geometry and style. All geometries
|
|
* in an Elements-based renderer consist of one node and some
|
|
* attributes. We have the nodeFactory() function which creates a node
|
|
* for us, but it takes a 'type' as input, and that is precisely what
|
|
* this function tells us.
|
|
*
|
|
* Parameters:
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
* style - {Object}
|
|
*
|
|
* Returns:
|
|
* {String} The corresponding node type for the specified geometry
|
|
*/
|
|
getNodeType: function(geometry, style) { },
|
|
|
|
/**
|
|
* Method: drawGeometry
|
|
* Draw the geometry, creating new nodes, setting paths, setting style,
|
|
* setting featureId on the node. This method should only be called
|
|
* by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
* style - {Object}
|
|
* featureId - {String}
|
|
*
|
|
* Returns:
|
|
* {Boolean} true if the geometry has been drawn completely; null if
|
|
* incomplete; false otherwise
|
|
*/
|
|
drawGeometry: function(geometry, style, featureId) {
|
|
var className = geometry.CLASS_NAME;
|
|
var rendered = true;
|
|
if ((className == "OpenLayers.Geometry.Collection") ||
|
|
(className == "OpenLayers.Geometry.MultiPoint") ||
|
|
(className == "OpenLayers.Geometry.MultiLineString") ||
|
|
(className == "OpenLayers.Geometry.MultiPolygon")) {
|
|
for (var i = 0, len=geometry.components.length; i<len; i++) {
|
|
rendered = this.drawGeometry(
|
|
geometry.components[i], style, featureId) && rendered;
|
|
}
|
|
return rendered;
|
|
};
|
|
|
|
rendered = false;
|
|
if (style.display != "none") {
|
|
if (style.backgroundGraphic) {
|
|
this.redrawBackgroundNode(geometry.id, geometry, style,
|
|
featureId);
|
|
}
|
|
rendered = this.redrawNode(geometry.id, geometry, style,
|
|
featureId);
|
|
}
|
|
if (rendered == false) {
|
|
var node = document.getElementById(geometry.id);
|
|
if (node) {
|
|
if (node._style.backgroundGraphic) {
|
|
node.parentNode.removeChild(document.getElementById(
|
|
geometry.id + this.BACKGROUND_ID_SUFFIX));
|
|
}
|
|
node.parentNode.removeChild(node);
|
|
}
|
|
}
|
|
return rendered;
|
|
},
|
|
|
|
/**
|
|
* Method: redrawNode
|
|
*
|
|
* Parameters:
|
|
* id - {String}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
* style - {Object}
|
|
* featureId - {String}
|
|
*
|
|
* Returns:
|
|
* {Boolean} true if the complete geometry could be drawn, null if parts of
|
|
* the geometry could not be drawn, false otherwise
|
|
*/
|
|
redrawNode: function(id, geometry, style, featureId) {
|
|
// Get the node if it's already on the map.
|
|
var node = this.nodeFactory(id, this.getNodeType(geometry, style));
|
|
|
|
// Set the data for the node, then draw it.
|
|
node._featureId = featureId;
|
|
node._geometry = geometry;
|
|
node._geometryClass = geometry.CLASS_NAME;
|
|
node._style = style;
|
|
|
|
var drawResult = this.drawGeometryNode(node, geometry, style);
|
|
if(drawResult === false) {
|
|
return false;
|
|
}
|
|
|
|
node = drawResult.node;
|
|
|
|
// Insert the node into the indexer so it can show us where to
|
|
// place it. Note that this operation is O(log(n)). If there's a
|
|
// performance problem (when dragging, for instance) this is
|
|
// likely where it would be.
|
|
if (this.indexer) {
|
|
var insert = this.indexer.insert(node);
|
|
if (insert) {
|
|
this.vectorRoot.insertBefore(node, insert);
|
|
} else {
|
|
this.vectorRoot.appendChild(node);
|
|
}
|
|
} else {
|
|
// if there's no indexer, simply append the node to root,
|
|
// but only if the node is a new one
|
|
if (node.parentNode !== this.root){
|
|
this.vectorRoot.appendChild(node);
|
|
}
|
|
}
|
|
|
|
this.postDraw(node);
|
|
|
|
return drawResult.complete;
|
|
},
|
|
|
|
/**
|
|
* Method: redrawBackgroundNode
|
|
* Redraws the node using special 'background' style properties. Basically
|
|
* just calls redrawNode(), but instead of directly using the
|
|
* 'externalGraphic', 'graphicXOffset', 'graphicYOffset', and
|
|
* 'graphicZIndex' properties directly from the specified 'style'
|
|
* parameter, we create a new style object and set those properties
|
|
* from the corresponding 'background'-prefixed properties from
|
|
* specified 'style' parameter.
|
|
*
|
|
* Parameters:
|
|
* id - {String}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
* style - {Object}
|
|
* featureId - {String}
|
|
*
|
|
* Returns:
|
|
* {Boolean} true if the complete geometry could be drawn, null if parts of
|
|
* the geometry could not be drawn, false otherwise
|
|
*/
|
|
redrawBackgroundNode: function(id, geometry, style, featureId) {
|
|
var backgroundStyle = OpenLayers.Util.extend({}, style);
|
|
|
|
// Set regular style attributes to apply to the background styles.
|
|
backgroundStyle.externalGraphic = backgroundStyle.backgroundGraphic;
|
|
backgroundStyle.graphicXOffset = backgroundStyle.backgroundXOffset;
|
|
backgroundStyle.graphicYOffset = backgroundStyle.backgroundYOffset;
|
|
backgroundStyle.graphicZIndex = backgroundStyle.backgroundGraphicZIndex;
|
|
backgroundStyle.graphicWidth = backgroundStyle.backgroundWidth || backgroundStyle.graphicWidth;
|
|
backgroundStyle.graphicHeight = backgroundStyle.backgroundHeight || backgroundStyle.graphicHeight;
|
|
|
|
// Erase background styles.
|
|
backgroundStyle.backgroundGraphic = null;
|
|
backgroundStyle.backgroundXOffset = null;
|
|
backgroundStyle.backgroundYOffset = null;
|
|
backgroundStyle.backgroundGraphicZIndex = null;
|
|
|
|
return this.redrawNode(
|
|
id + this.BACKGROUND_ID_SUFFIX,
|
|
geometry,
|
|
backgroundStyle,
|
|
null
|
|
);
|
|
},
|
|
|
|
/**
|
|
* Method: drawGeometryNode
|
|
* Given a node, draw a geometry on the specified layer.
|
|
* node and geometry are required arguments, style is optional.
|
|
* This method is only called by the render itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
* style - {Object}
|
|
*
|
|
* Returns:
|
|
* {Object} a hash with properties "node" (the drawn node) and "complete"
|
|
* (null if parts of the geometry could not be drawn, false if nothing
|
|
* could be drawn)
|
|
*/
|
|
drawGeometryNode: function(node, geometry, style) {
|
|
style = style || node._style;
|
|
OpenLayers.Util.applyDefaults(style, this.minimumSymbolizer);
|
|
|
|
var options = {
|
|
'isFilled': true,
|
|
'isStroked': !!style.strokeWidth
|
|
};
|
|
var drawn;
|
|
switch (geometry.CLASS_NAME) {
|
|
case "OpenLayers.Geometry.Point":
|
|
drawn = this.drawPoint(node, geometry);
|
|
break;
|
|
case "OpenLayers.Geometry.LineString":
|
|
options.isFilled = false;
|
|
drawn = this.drawLineString(node, geometry);
|
|
break;
|
|
case "OpenLayers.Geometry.LinearRing":
|
|
drawn = this.drawLinearRing(node, geometry);
|
|
break;
|
|
case "OpenLayers.Geometry.Polygon":
|
|
drawn = this.drawPolygon(node, geometry);
|
|
break;
|
|
case "OpenLayers.Geometry.Surface":
|
|
drawn = this.drawSurface(node, geometry);
|
|
break;
|
|
case "OpenLayers.Geometry.Rectangle":
|
|
drawn = this.drawRectangle(node, geometry);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
node._style = style;
|
|
node._options = options;
|
|
|
|
//set style
|
|
//TBD simplify this
|
|
if (drawn != false) {
|
|
return {
|
|
node: this.setStyle(node, style, options, geometry),
|
|
complete: drawn
|
|
};
|
|
} else {
|
|
return false;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: postDraw
|
|
* Things that have do be done after the geometry node is appended
|
|
* to its parent node. To be overridden by subclasses.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
*/
|
|
postDraw: function(node) {},
|
|
|
|
/**
|
|
* Method: drawPoint
|
|
* Virtual function for drawing Point Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or false if the renderer could not draw the point
|
|
*/
|
|
drawPoint: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: drawLineString
|
|
* Virtual function for drawing LineString Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or null if the renderer could not draw all components of
|
|
* the linestring, or false if nothing could be drawn
|
|
*/
|
|
drawLineString: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: drawLinearRing
|
|
* Virtual function for drawing LinearRing Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or null if the renderer could not draw all components
|
|
* of the linear ring, or false if nothing could be drawn
|
|
*/
|
|
drawLinearRing: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: drawPolygon
|
|
* Virtual function for drawing Polygon Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or null if the renderer could not draw all components
|
|
* of the polygon, or false if nothing could be drawn
|
|
*/
|
|
drawPolygon: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: drawRectangle
|
|
* Virtual function for drawing Rectangle Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or false if the renderer could not draw the rectangle
|
|
*/
|
|
drawRectangle: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: drawCircle
|
|
* Virtual function for drawing Circle Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or false if the renderer could not draw the circle
|
|
*/
|
|
drawCircle: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: drawSurface
|
|
* Virtual function for drawing Surface Geometry.
|
|
* Should be implemented by subclasses.
|
|
* This method is only called by the renderer itself.
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*
|
|
* Returns:
|
|
* {DOMElement} or false if the renderer could not draw the surface
|
|
*/
|
|
drawSurface: function(node, geometry) {},
|
|
|
|
/**
|
|
* Method: removeText
|
|
* Removes a label
|
|
*
|
|
* Parameters:
|
|
* featureId - {String}
|
|
*/
|
|
removeText: function(featureId) {
|
|
var label = document.getElementById(featureId + this.LABEL_ID_SUFFIX);
|
|
if (label) {
|
|
this.textRoot.removeChild(label);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: getFeatureIdFromEvent
|
|
*
|
|
* Parameters:
|
|
* evt - {Object} An <OpenLayers.Event> object
|
|
*
|
|
* Returns:
|
|
* {<OpenLayers.Geometry>} A geometry from an event that
|
|
* happened on a layer.
|
|
*/
|
|
getFeatureIdFromEvent: function(evt) {
|
|
var target = evt.target;
|
|
var useElement = target && target.correspondingUseElement;
|
|
var node = useElement ? useElement : (target || evt.srcElement);
|
|
var featureId = node._featureId;
|
|
return featureId;
|
|
},
|
|
|
|
/**
|
|
* Method: eraseGeometry
|
|
* Erase a geometry from the renderer. In the case of a multi-geometry,
|
|
* we cycle through and recurse on ourselves. Otherwise, we look for a
|
|
* node with the geometry.id, destroy its geometry, and remove it from
|
|
* the DOM.
|
|
*
|
|
* Parameters:
|
|
* geometry - {<OpenLayers.Geometry>}
|
|
*/
|
|
eraseGeometry: function(geometry) {
|
|
if ((geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPoint") ||
|
|
(geometry.CLASS_NAME == "OpenLayers.Geometry.MultiLineString") ||
|
|
(geometry.CLASS_NAME == "OpenLayers.Geometry.MultiPolygon") ||
|
|
(geometry.CLASS_NAME == "OpenLayers.Geometry.Collection")) {
|
|
for (var i=0, len=geometry.components.length; i<len; i++) {
|
|
this.eraseGeometry(geometry.components[i]);
|
|
}
|
|
} else {
|
|
var element = OpenLayers.Util.getElement(geometry.id);
|
|
if (element && element.parentNode) {
|
|
if (element.geometry) {
|
|
element.geometry.destroy();
|
|
element.geometry = null;
|
|
}
|
|
element.parentNode.removeChild(element);
|
|
|
|
if (this.indexer) {
|
|
this.indexer.remove(element);
|
|
}
|
|
|
|
if (element._style.backgroundGraphic) {
|
|
var backgroundId = geometry.id + this.BACKGROUND_ID_SUFFIX;
|
|
var bElem = OpenLayers.Util.getElement(backgroundId);
|
|
if (bElem && bElem.parentNode) {
|
|
// No need to destroy the geometry since the element and the background
|
|
// node share the same geometry.
|
|
bElem.parentNode.removeChild(bElem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Method: nodeFactory
|
|
* Create new node of the specified type, with the (optional) specified id.
|
|
*
|
|
* If node already exists with same ID and a different type, we remove it
|
|
* and then call ourselves again to recreate it.
|
|
*
|
|
* Parameters:
|
|
* id - {String}
|
|
* type - {String} type Kind of node to draw.
|
|
*
|
|
* Returns:
|
|
* {DOMElement} A new node of the given type and id.
|
|
*/
|
|
nodeFactory: function(id, type) {
|
|
var node = OpenLayers.Util.getElement(id);
|
|
if (node) {
|
|
if (!this.nodeTypeCompare(node, type)) {
|
|
node.parentNode.removeChild(node);
|
|
node = this.nodeFactory(id, type);
|
|
}
|
|
} else {
|
|
node = this.createNode(type, id);
|
|
}
|
|
return node;
|
|
},
|
|
|
|
/**
|
|
* Method: nodeTypeCompare
|
|
*
|
|
* Parameters:
|
|
* node - {DOMElement}
|
|
* type - {String} Kind of node
|
|
*
|
|
* Returns:
|
|
* {Boolean} Whether or not the specified node is of the specified type
|
|
* This function must be overridden by subclasses.
|
|
*/
|
|
nodeTypeCompare: function(node, type) {},
|
|
|
|
/**
|
|
* Method: createNode
|
|
*
|
|
* Parameters:
|
|
* type - {String} Kind of node to draw.
|
|
* id - {String} Id for node.
|
|
*
|
|
* Returns:
|
|
* {DOMElement} A new node of the given type and id.
|
|
* This function must be overridden by subclasses.
|
|
*/
|
|
createNode: function(type, id) {},
|
|
|
|
/**
|
|
* Method: moveRoot
|
|
* moves this renderer's root to a different renderer.
|
|
*
|
|
* Parameters:
|
|
* renderer - {<OpenLayers.Renderer>} target renderer for the moved root
|
|
*/
|
|
moveRoot: function(renderer) {
|
|
var root = this.root;
|
|
if(renderer.root.parentNode == this.rendererRoot) {
|
|
root = renderer.root;
|
|
}
|
|
root.parentNode.removeChild(root);
|
|
renderer.rendererRoot.appendChild(root);
|
|
},
|
|
|
|
/**
|
|
* Method: getRenderLayerId
|
|
* Gets the layer that this renderer's output appears on. If moveRoot was
|
|
* used, this will be different from the id of the layer containing the
|
|
* features rendered by this renderer.
|
|
*
|
|
* Returns:
|
|
* {String} the id of the output layer.
|
|
*/
|
|
getRenderLayerId: function() {
|
|
return this.root.parentNode.parentNode.id;
|
|
},
|
|
|
|
/**
|
|
* Method: isComplexSymbol
|
|
* Determines if a symbol cannot be rendered using drawCircle
|
|
*
|
|
* Parameters:
|
|
* graphicName - {String}
|
|
*
|
|
* Returns
|
|
* {Boolean} true if the symbol is complex, false if not
|
|
*/
|
|
isComplexSymbol: function(graphicName) {
|
|
return (graphicName != "circle") && !!graphicName;
|
|
},
|
|
|
|
CLASS_NAME: "OpenLayers.Renderer.Elements"
|
|
});
|
|
|
|
|
|
/**
|
|
* Constant: OpenLayers.Renderer.symbol
|
|
* Coordinate arrays for well known (named) symbols.
|
|
*/
|
|
OpenLayers.Renderer.symbol = {
|
|
"star": [350,75, 379,161, 469,161, 397,215, 423,301, 350,250, 277,301,
|
|
303,215, 231,161, 321,161, 350,75],
|
|
"cross": [4,0, 6,0, 6,4, 10,4, 10,6, 6,6, 6,10, 4,10, 4,6, 0,6, 0,4, 4,4,
|
|
4,0],
|
|
"x": [0,0, 25,0, 50,35, 75,0, 100,0, 65,50, 100,100, 75,100, 50,65, 25,100, 0,100, 35,50, 0,0],
|
|
"square": [0,0, 0,1, 1,1, 1,0, 0,0],
|
|
"triangle": [0,10, 10,10, 5,0, 0,10]
|
|
};
|