ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Pullup commits from trunk to 2.6 branch:

Browse Source 
* virtualStyle typo (Closes #1495)
 * JSON fix for Safari 3.1 (Closes #1493)
 * panzoombar off-by-one (Closes #1486)
 * Handler Hover exception (Closes #1480)
 * Popup.framedcloud exception (Closes #1479)
 * VML Renderer when including namespace in page (Closes #1477)
 * SLD/Rule/Filter changes -- most of this commit (Closes #1492)


git-svn-id: http://svn.openlayers.org/branches/openlayers/2.6@6819 dc9f47b5-9b13-0410-9fdd-eb0c1a62fdaf
This commit is contained in:
crschmidt
2008-04-08 01:51:04 +00:00
parent b9348dd5d5
commit 4085a2c220
29 changed files with 842 additions and 665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
examples/georss-flickr.html
View File

@@ -31,28 +31,34 @@
// the thumbail attribute of the rss item // the thumbail attribute of the rss item
style = new OpenLayers.Style({externalGraphic: "${thumbnail}"}); style = new OpenLayers.Style({externalGraphic: "${thumbnail}"});
// make the thumbnails larger when we select them
selectStyle = new OpenLayers.Style({pointRadius: 35});
// create a rule with a point symbolizer that will make the thumbnail // create a rule with a point symbolizer that will make the thumbnail
// larger if the title of the rss item conatins "powder" // larger if the title of the rss item conatins "powder"
var rule = new OpenLayers.Rule.Comparison({ var rule = new OpenLayers.Rule({
type: OpenLayers.Rule.Comparison.LIKE, symbolizer: {pointRadius: 30},
filter: new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LIKE,
property: "title", property: "title",
value: "*powder*", value: "*powder*"
symbolizer: {"Point": {pointRadius: 30}}}); })
rule.value2regex("*"); });
rule.filter.value2regex("*");
// If the above rule does not apply, use a smaller pointRadius. // If the above rule does not apply, use a smaller pointRadius.
var elseRule = new OpenLayers.Rule({ var elseRule = new OpenLayers.Rule({
elseFilter: true, elseFilter: true,
symbolizer: {"Point": {pointRadius: 20}}}); symbolizer: {pointRadius: 20}
});
style.addRules([rule, elseRule]); style.addRules([rule, elseRule]);
markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({ // Create a layer with a style map. Giving the style map keys
"default": style, // for "default" and "select" rendering intent.
"select": selectStyle})}); markerLayer = new OpenLayers.Layer.Vector("", {
styleMap: new OpenLayers.StyleMap({
"default": style,
"select": new OpenLayers.Style({pointRadius: 35})
})
});
map.addLayer(markerLayer); map.addLayer(markerLayer);
// control that will show a popup when clicking on a thumbnail // control that will show a popup when clicking on a thumbnail

2
examples/spherical-mercator.html
View File

@@ -121,7 +121,7 @@
map.addControl(new OpenLayers.Control.EditingToolbar(vector)); map.addControl(new OpenLayers.Control.EditingToolbar(vector));
map.addControl(new OpenLayers.Control.Permalink()); map.addControl(new OpenLayers.Control.Permalink());
map.addControl(new OpenLayers.Control.MousePosition()); map.addControl(new OpenLayers.Control.MousePosition());
map.zoomToMaxExtent() if (!map.getCenter()) {map.zoomToMaxExtent()}
} }
function osm_getTileURL(bounds) { function osm_getTileURL(bounds) {

110
examples/styles-context.html
View File

@@ -105,112 +105,4 @@
on the context object passed to the Style constructor.</p> on the context object passed to the Style constructor.</p>
</div> </div>
</body> </body>
</html> </html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>OpenLayers Vector Styles</title>
<link rel="stylesheet" href="../theme/default/style.css" type="text/css" />
<style type="text/css">
#map {
width: 800px;
height: 400px;
border: 1px solid black;
}
</style>
<script src="../lib/OpenLayers.js"></script>
<script type="text/javascript">
var map;
function init(){
map = new OpenLayers.Map('map', {maxResolution:'auto'});
var wms = new OpenLayers.Layer.WMS( "OpenLayers WMS",
"http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} );
map.addLayer(wms);
map.setCenter(new OpenLayers.LonLat(0, 0), 0);
// Strategy 1: Style features based on some attribute.
// create 50 random features in the northern hemisphere
// give them a "type" attribute that will be used to style
// them by size
var features = new Array(50);
for (var i=0; i<features.length; i++) {
features[i] = new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(
(360 * Math.random()) - 180, 90 * Math.random()
), {
type: 5 + parseInt(5 * Math.random())
}
);
}
// create the layer styleMap with a simple symbolizer template
var layer1 = new OpenLayers.Layer.Vector('Points', {
styleMap: new OpenLayers.StyleMap({
pointRadius: "${type}", // based on feature.attributes.type
fillColor: "#666666"
})
});
layer1.addFeatures(features);
// Strategy 2: Style features based on something besides attributes.
// create 50 random features in the southern hemisphere
var features = new Array(50);
for (var i=0; i<features.length; i++) {
features[i] = new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(
(360 * Math.random()) - 180, -90 * Math.random()
), {
type: 5 + parseInt(5 * Math.random())
}
);
}
// create the layer styleMap by giving the default style a context
var colors = ["red", "green", "blue"];
var context = {
getColor: function(feature) {
var region = parseInt((feature.geometry.x + 180) / 120);
return colors[region];
},
getType: function(feature) {
return feature.attributes["type"];
}
};
var template = {
pointRadius: "${getType}", // using context.getType(feature)
fillColor: "${getColor}" // using context.getColor(feature)
};
var style = new OpenLayers.Style(template, {context: context});
var layer2 = new OpenLayers.Layer.Vector('Points', {
styleMap: new OpenLayers.StyleMap(style)
});
layer2.addFeatures(features);
map.addLayers([layer1, layer2]);
}
</script>
</head>
<body onload="init()">
<h1 id="title">Feature Styles Example</h1>
<div id="tags"></div>
<p id="shortdesc">
Shows how to create a feature styles.
</p>
<div id="map"></div>
<div id="docs">
<p>Features in the northern hemisphere are styled according to their
"type" attribute. This is accomplished with a simple template that
is evaluated with the feature attributes as context.</p>
<p>Features in the sourthern hemisphere are styled according to a
combination of their attributes and non-attribute properties. This
is accomplished using an advanced template that calls functions
on the context object passed to the Style constructor.</p>
</div>
</body>
</html>

7
lib/OpenLayers.js
View File

@@ -183,9 +183,10 @@
"OpenLayers/Style.js", "OpenLayers/Style.js",
"OpenLayers/StyleMap.js", "OpenLayers/StyleMap.js",
"OpenLayers/Rule.js", "OpenLayers/Rule.js",
"OpenLayers/Rule/FeatureId.js", "OpenLayers/Filter.js",
"OpenLayers/Rule/Logical.js", "OpenLayers/Filter/FeatureId.js",
"OpenLayers/Rule/Comparison.js", "OpenLayers/Filter/Logical.js",
"OpenLayers/Filter/Comparison.js",
"OpenLayers/Format.js", "OpenLayers/Format.js",
"OpenLayers/Format/XML.js", "OpenLayers/Format/XML.js",
"OpenLayers/Format/GML.js", "OpenLayers/Format/GML.js",

8
lib/OpenLayers/Control/ModifyFeature.js
View File

@@ -179,10 +179,10 @@ OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, {
this.layer = layer; this.layer = layer;
this.vertices = []; this.vertices = [];
this.virtualVertices = []; this.virtualVertices = [];
this.styleVirtual = OpenLayers.Util.extend({}, this.virtualStyle = OpenLayers.Util.extend({},
this.layer.style || this.layer.styleMap.createSymbolizer()); this.layer.style || this.layer.styleMap.createSymbolizer());
this.styleVirtual.fillOpacity = 0.3; this.virtualStyle.fillOpacity = 0.3;
this.styleVirtual.strokeOpacity = 0.3; this.virtualStyle.strokeOpacity = 0.3;
this.deleteCodes = [46, 100]; this.deleteCodes = [46, 100];
this.mode = OpenLayers.Control.ModifyFeature.RESHAPE; this.mode = OpenLayers.Control.ModifyFeature.RESHAPE;
OpenLayers.Control.prototype.initialize.apply(this, [options]); OpenLayers.Control.prototype.initialize.apply(this, [options]);
@@ -564,7 +564,7 @@ OpenLayers.Control.ModifyFeature = OpenLayers.Class(OpenLayers.Control, {
var y = (prevVertex.y + nextVertex.y) / 2; var y = (prevVertex.y + nextVertex.y) / 2;
var point = new OpenLayers.Feature.Vector( var point = new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(x, y), new OpenLayers.Geometry.Point(x, y),
null, control.styleVirtual null, control.virtualStyle
); );
// set the virtual parent and intended index // set the virtual parent and intended index
point.geometry.parent = geometry; point.geometry.parent = geometry;

2
lib/OpenLayers/Control/OverviewMap.js
View File

@@ -27,7 +27,7 @@ OpenLayers.Control.OverviewMap = OpenLayers.Class(OpenLayers.Control, {
/** /**
* APIProperty: ovmap * APIProperty: ovmap
* {<OpenLayers.Map>} A reference to the overvew map itself. * {<OpenLayers.Map>} A reference to the overview map itself.
*/ */
ovmap: null, ovmap: null,

9
lib/OpenLayers/Control/PanZoomBar.js
View File

@@ -242,12 +242,11 @@ OpenLayers.Control.PanZoomBar = OpenLayers.Class(OpenLayers.Control.PanZoom, {
var y = evt.xy.y; var y = evt.xy.y;
var top = OpenLayers.Util.pagePosition(evt.object)[1]; var top = OpenLayers.Util.pagePosition(evt.object)[1];
var levels = (y - top)/this.zoomStopHeight; var levels = (y - top)/this.zoomStopHeight;
var zoom = (this.map.getNumZoomLevels() - 1) - levels; if(!this.map.fractionalZoom) {
if(this.map.fractionalZoom) { levels = Math.floor(levels);
zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1);
} else {
zoom = Math.floor(zoom);
} }
var zoom = (this.map.getNumZoomLevels() - 1) - levels;
zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1);
this.map.zoomTo(zoom); this.map.zoomTo(zoom);
OpenLayers.Event.stop(evt); OpenLayers.Event.stop(evt);
}, },

55
lib/OpenLayers/Filter.js Normal file
View File

@@ -0,0 +1,55 @@
/* Copyright (c) 2006 MetaCarta, Inc., published under a modified BSD license.
* See http://svn.openlayers.org/trunk/openlayers/repository-license.txt
* for the full text of the license. */
/**
* @requires OpenLayers/Util.js
* @requires OpenLayers/Style.js
*/
/**
* Class: OpenLayers.Filter
* This class represents an OGC Filter.
*/
OpenLayers.Filter = OpenLayers.Class({
/**
* Constructor: OpenLayers.Filter
* This is an abstract class. Create an instance of a filter subclass.
*
* Parameters:
* options - {Object} Optional object whose properties will be set on the
* instance.
*
* Returns:
* {<OpenLayers.Filter>}
*/
initialize: function(options) {
OpenLayers.Util.extend(this, options);
},
/**
* APIMethod: destroy
* Remove reference to anything added.
*/
destroy: function() {
},
/**
* APIMethod: evaluate
* Evaluates this filter in a specific context. Should be implemented by
* subclasses.
*
* Parameters:
* context - {Object} Context to use in evaluating the filter.
*
* Returns:
* {Boolean} The filter applies.
*/
evaluate: function(context) {
return true;
},
CLASS_NAME: "OpenLayers.Filter"
});

92
lib/OpenLayers/Rule/Comparison.js → lib/OpenLayers/Filter/Comparison.js
View File

@@ -3,30 +3,29 @@
* full text of the license. */ * full text of the license. */
/** /**
* @requires OpenLayers/Rule.js * @requires OpenLayers/Filter.js
*/ */
/** /**
* Class: OpenLayers.Rule.Comparison * Class: OpenLayers.Filter.Comparison
* This class represents the comparison rules, as being used for rule-based * This class represents a comparison filter.
* SLD styling
* *
* Inherits from * Inherits from
* - <OpenLayers.Rule> * - <OpenLayers.Filter>
*/ */
OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, { OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, {
/** /**
* APIProperty: type * APIProperty: type
* {String} type: type of the comparison. This is one of * {String} type: type of the comparison. This is one of
* - OpenLayers.Rule.Comparison.EQUAL_TO = "=="; * - OpenLayers.Filter.Comparison.EQUAL_TO = "==";
* - OpenLayers.Rule.Comparison.NOT_EQUAL_TO = "!="; * - OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
* - OpenLayers.Rule.Comparison.LESS_THAN = "<"; * - OpenLayers.Filter.Comparison.LESS_THAN = "<";
* - OpenLayers.Rule.Comparison.GREATER_THAN = ">"; * - OpenLayers.Filter.Comparison.GREATER_THAN = ">";
* - OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; * - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
* - OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; * - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
* - OpenLayers.Rule.Comparison.BETWEEN = ".."; * - OpenLayers.Filter.Comparison.BETWEEN = "..";
* - OpenLayers.Rule.Comparison.LIKE = "~"; * - OpenLayers.Filter.Comparison.LIKE = "~";
*/ */
type: null, type: null,
@@ -65,7 +64,7 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
upperBoundary: null, upperBoundary: null,
/** /**
* Constructor: OpenLayers.Rule.Comparison * Constructor: OpenLayers.Filter.Comparison
* Creates a comparison rule. * Creates a comparison rule.
* *
* Parameters: * Parameters:
@@ -76,42 +75,39 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
* rule * rule
* *
* Returns: * Returns:
* {<OpenLayers.Rule.Comparison>} * {<OpenLayers.Filter.Comparison>}
*/ */
initialize: function(options) { initialize: function(options) {
OpenLayers.Rule.prototype.initialize.apply(this, [options]); OpenLayers.Filter.prototype.initialize.apply(this, [options]);
}, },
/** /**
* APIMethod: evaluate * APIMethod: evaluate
* evaluates this rule for a specific context * Evaluates this filter in a specific context. Should be implemented by
* subclasses.
* *
* Parameters: * Parameters:
* context - {Object} context to apply the rule to. * context - {Object} Context to use in evaluating the filter.
* *
* Returns: * Returns:
* {boolean} true if the rule applies, false if it does not * {Boolean} The filter applies.
*/ */
evaluate: function(feature) { evaluate: function(context) {
if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
return false;
}
var context = this.getContext(feature);
switch(this.type) { switch(this.type) {
case OpenLayers.Rule.Comparison.EQUAL_TO: case OpenLayers.Filter.Comparison.EQUAL_TO:
case OpenLayers.Rule.Comparison.LESS_THAN: case OpenLayers.Filter.Comparison.LESS_THAN:
case OpenLayers.Rule.Comparison.GREATER_THAN: case OpenLayers.Filter.Comparison.GREATER_THAN:
case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO: case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO:
case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO: case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
return this.binaryCompare(context, this.property, this.value); return this.binaryCompare(context, this.property, this.value);
case OpenLayers.Rule.Comparison.BETWEEN: case OpenLayers.Filter.Comparison.BETWEEN:
var result = var result =
context[this.property] >= this.lowerBoundary; context[this.property] >= this.lowerBoundary;
result = result && result = result &&
context[this.property] <= this.upperBoundary; context[this.property] <= this.upperBoundary;
return result; return result;
case OpenLayers.Rule.Comparison.LIKE: case OpenLayers.Filter.Comparison.LIKE:
var regexp = new RegExp(this.value, var regexp = new RegExp(this.value,
"gi"); "gi");
return regexp.test(context[this.property]); return regexp.test(context[this.property]);
@@ -139,7 +135,7 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
value2regex: function(wildCard, singleChar, escapeChar) { value2regex: function(wildCard, singleChar, escapeChar) {
if (wildCard == ".") { if (wildCard == ".") {
var msg = "'.' is an unsupported wildCard character for "+ var msg = "'.' is an unsupported wildCard character for "+
"OpenLayers.Rule.Comparison"; "OpenLayers.Filter.Comparison";
OpenLayers.Console.error(msg); OpenLayers.Console.error(msg);
return null; return null;
} }
@@ -212,30 +208,30 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
*/ */
binaryCompare: function(context, property, value) { binaryCompare: function(context, property, value) {
switch (this.type) { switch (this.type) {
case OpenLayers.Rule.Comparison.EQUAL_TO: case OpenLayers.Filter.Comparison.EQUAL_TO:
return context[property] == value; return context[property] == value;
case OpenLayers.Rule.Comparison.NOT_EQUAL_TO: case OpenLayers.Filter.Comparison.NOT_EQUAL_TO:
return context[property] != value; return context[property] != value;
case OpenLayers.Rule.Comparison.LESS_THAN: case OpenLayers.Filter.Comparison.LESS_THAN:
return context[property] < value; return context[property] < value;
case OpenLayers.Rule.Comparison.GREATER_THAN: case OpenLayers.Filter.Comparison.GREATER_THAN:
return context[property] > value; return context[property] > value;
case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO: case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO:
return context[property] <= value; return context[property] <= value;
case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO: case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
return context[property] >= value; return context[property] >= value;
} }
}, },
CLASS_NAME: "OpenLayers.Rule.Comparison" CLASS_NAME: "OpenLayers.Filter.Comparison"
}); });
OpenLayers.Rule.Comparison.EQUAL_TO = "=="; OpenLayers.Filter.Comparison.EQUAL_TO = "==";
OpenLayers.Rule.Comparison.NOT_EQUAL_TO = "!="; OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
OpenLayers.Rule.Comparison.LESS_THAN = "<"; OpenLayers.Filter.Comparison.LESS_THAN = "<";
OpenLayers.Rule.Comparison.GREATER_THAN = ">"; OpenLayers.Filter.Comparison.GREATER_THAN = ">";
OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO = "<="; OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">="; OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
OpenLayers.Rule.Comparison.BETWEEN = ".."; OpenLayers.Filter.Comparison.BETWEEN = "..";
OpenLayers.Rule.Comparison.LIKE = "~"; OpenLayers.Filter.Comparison.LIKE = "~";

21
lib/OpenLayers/Rule/FeatureId.js → lib/OpenLayers/Filter/FeatureId.js
View File

@@ -4,18 +4,18 @@
/** /**
* @requires OpenLayers/Rule.js * @requires OpenLayers/Filter.js
*/ */
/** /**
* Class: OpenLayers.Rule.FeatureId * Class: OpenLayers.Filter.FeatureId
* This class represents a ogc:FeatureId Rule, as being used for rule-based SLD * This class represents a ogc:FeatureId Filter, as being used for rule-based SLD
* styling * styling
* *
* Inherits from * Inherits from
* - <OpenLayers.Rule> * - <OpenLayers.Filter>
*/ */
OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, { OpenLayers.Filter.FeatureId = OpenLayers.Class(OpenLayers.Filter, {
/** /**
* APIProperty: fids * APIProperty: fids
@@ -25,7 +25,7 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
fids: null, fids: null,
/** /**
* Constructor: OpenLayers.Rule.FeatureId * Constructor: OpenLayers.Filter.FeatureId
* Creates an ogc:FeatureId rule. * Creates an ogc:FeatureId rule.
* *
* Parameters: * Parameters:
@@ -33,11 +33,11 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
* rule * rule
* *
* Returns: * Returns:
* {<OpenLayers.Rule.FeatureId>} * {<OpenLayers.Filter.FeatureId>}
*/ */
initialize: function(options) { initialize: function(options) {
this.fids = []; this.fids = [];
OpenLayers.Rule.prototype.initialize.apply(this, [options]); OpenLayers.Filter.prototype.initialize.apply(this, [options]);
}, },
/** /**
@@ -53,9 +53,6 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
* {boolean} true if the rule applies, false if it does not * {boolean} true if the rule applies, false if it does not
*/ */
evaluate: function(feature) { evaluate: function(feature) {
if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
return false;
}
for (var i=0; i<this.fids.length; i++) { for (var i=0; i<this.fids.length; i++) {
var fid = feature.fid || feature.id; var fid = feature.fid || feature.id;
if (fid == this.fids[i]) { if (fid == this.fids[i]) {
@@ -65,5 +62,5 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
return false; return false;
}, },
CLASS_NAME: "OpenLayers.Rule.FeatureId" CLASS_NAME: "OpenLayers.Filter.FeatureId"
}); });

99
lib/OpenLayers/Filter/Logical.js Normal file
View File

@@ -0,0 +1,99 @@
/* 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/Filter.js
*/
/**
* Class: OpenLayers.Filter.Logical
* This class represents ogc:And, ogc:Or and ogc:Not rules.
*
* Inherits from
* - <OpenLayers.Filter>
*/
OpenLayers.Filter.Logical = OpenLayers.Class(OpenLayers.Filter, {
/**
* APIProperty: filters
* {Array(<OpenLayers.Filter>)} Child filters for this filter.
*/
filters: null,
/**
* APIProperty: type
* {String} type of logical operator. Available types are:
* - OpenLayers.Filter.Locical.AND = "&&";
* - OpenLayers.Filter.Logical.OR = "||";
* - OpenLayers.Filter.Logical.NOT = "!";
*/
type: null,
/**
* Constructor: OpenLayers.Filter.Logical
* Creates a logical filter (And, Or, Not).
*
* Parameters:
* options - {Object} An optional object with properties to set on the
* filter.
*
* Returns:
* {<OpenLayers.Filter.Logical>}
*/
initialize: function(options) {
this.filters = [];
OpenLayers.Filter.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: destroy
* Remove reference to child filters.
*/
destroy: function() {
this.filters = null;
OpenLayers.Filter.prototype.destroy.apply(this);
},
/**
* APIMethod: evaluate
* Evaluates this filter in a specific context. Should be implemented by
* subclasses.
*
* Parameters:
* context - {Object} Context to use in evaluating the filter.
*
* Returns:
* {Boolean} The filter applies.
*/
evaluate: function(context) {
switch(this.type) {
case OpenLayers.Filter.Logical.AND:
for (var i=0; i<this.filters.length; i++) {
if (this.filters[i].evaluate(context) == false) {
return false;
}
}
return true;
case OpenLayers.Filter.Logical.OR:
for (var i=0; i<this.filters.length; i++) {
if (this.filters[i].evaluate(context) == true) {
return true;
}
}
return false;
case OpenLayers.Filter.Logical.NOT:
return (!this.filters[0].evaluate(context));
}
},
CLASS_NAME: "OpenLayers.Filter.Logical"
});
OpenLayers.Filter.Logical.AND = "&&";
OpenLayers.Filter.Logical.OR = "||";
OpenLayers.Filter.Logical.NOT = "!";

5
lib/OpenLayers/Format/JSON.js
View File

@@ -95,8 +95,9 @@ OpenLayers.Format.JSON = OpenLayers.Class(OpenLayers.Format, {
* characters. * characters.
*/ */
try { try {
if(/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/. if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, '@').
test(json)) { replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
/** /**
* In the second stage we use the eval function to compile the * In the second stage we use the eval function to compile the

309
lib/OpenLayers/Format/SLD/v1.js
View File

@@ -142,24 +142,8 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
style.rules = obj.rules; style.rules = obj.rules;
}, },
"Rule": function(node, obj) { "Rule": function(node, obj) {
// Rule elements are represented as OpenLayers.Rule instances. var rule = new OpenLayers.Rule();
// Filter elements are represented as instances of this.readChildNodes(node, rule);
// OpenLayers.Rule subclasses.
var config = {
rules: [],
symbolizer: {}
};
this.readChildNodes(node, config);
// Now we've either got zero or one rules (from filters)
var rule;
if(config.rules.length == 0) {
delete config.rules;
rule = new OpenLayers.Rule(config);
} else {
rule = config.rules[0];
delete config.rules;
OpenLayers.Util.extend(rule, config);
}
obj.rules.push(rule); obj.rules.push(rule);
}, },
"ElseFilter": function(node, rule) { "ElseFilter": function(node, rule) {
@@ -283,146 +267,121 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
}, },
"ogc": { "ogc": {
"Filter": function(node, rule) { "Filter": function(node, rule) {
// Filters correspond to subclasses of OpenLayers.Rule. // Filters correspond to subclasses of OpenLayers.Filter.
// Since they contain information we don't persist, we // Since they contain information we don't persist, we
// create a temporary object and then pass on the rules // create a temporary object and then pass on the filter
// (ogc:Filter) to the parent rule (sld:Rule). // (ogc:Filter) to the parent rule (sld:Rule).
var filter = { var obj = {
fids: [], fids: [],
rules: [] filters: []
}; };
this.readChildNodes(node, filter); this.readChildNodes(node, obj);
if(filter.fids.length > 0) { if(obj.fids.length > 0) {
rule.rules.push(new OpenLayers.Rule.FeatureId({ rule.filter = new OpenLayers.Filter.FeatureId({
fids: filter.fids fids: obj.fids
})); });
} } else if(obj.filters.length > 0) {
if(filter.rules.length > 0) { rule.filter = obj.filters[0];
rule.rules = rule.rules.concat(filter.rules);
} }
}, },
"FeatureId": function(node, filter) { "FeatureId": function(node, obj) {
var fid = node.getAttribute("fid"); var fid = node.getAttribute("fid");
if(fid) { if(fid) {
filter.fids.push(fid); obj.fids.push(fid);
} }
}, },
"And": function(node, filter) { "And": function(node, obj) {
var rule = new OpenLayers.Rule.Logical({ var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Rule.Logical.AND type: OpenLayers.Filter.Logical.AND
}); });
// since FeatureId rules may be nested here, make room for them this.readChildNodes(node, filter);
rule.fids = []; obj.filters.push(filter);
this.readChildNodes(node, rule);
if(rule.fids.length > 0) {
rule.rules.push(new OpenLayers.Rule.FeatureId({
fids: rule.fids
}));
}
delete rule.fids;
filter.rules.push(rule);
}, },
"Or": function(node, filter) { "Or": function(node, obj) {
var rule = new OpenLayers.Rule.Logical({ var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Rule.Logical.OR type: OpenLayers.Filter.Logical.OR
}); });
// since FeatureId rules may be nested here, make room for them this.readChildNodes(node, filter);
rule.fids = []; obj.filters.push(filter);
this.readChildNodes(node, rule);
if(rule.fids.length > 0) {
rule.rules.push(new OpenLayers.Rule.FeatureId({
fids: rule.fids
}));
}
delete rule.fids;
filter.rules.push(rule);
}, },
"Not": function(node, filter) { "Not": function(node, obj) {
var rule = new OpenLayers.Rule.Logical({ var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Rule.Logical.NOT type: OpenLayers.Filter.Logical.NOT
}); });
// since FeatureId rules may be nested here, make room for them this.readChildNodes(node, filter);
rule.fids = []; obj.filters.push(filter);
this.readChildNodes(node, rule);
if(rule.fids.length > 0) {
rule.rules.push(new OpenLayers.Rule.FeatureId({
fids: rule.fids
}));
}
delete rule.fids;
filter.rules.push(rule);
}, },
"PropertyIsEqualTo": function(node, filter) { "PropertyIsEqualTo": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.EQUAL_TO type: OpenLayers.Filter.Comparison.EQUAL_TO
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsNotEqualTo": function(node, filter) { "PropertyIsNotEqualTo": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.NOT_EQUAL_TO type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsLessThan": function(node, filter) { "PropertyIsLessThan": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.LESS_THAN type: OpenLayers.Filter.Comparison.LESS_THAN
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsGreaterThan": function(node, filter) { "PropertyIsGreaterThan": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.GREATER_THAN type: OpenLayers.Filter.Comparison.GREATER_THAN
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsLessThanOrEqualTo": function(node, filter) { "PropertyIsLessThanOrEqualTo": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsGreaterThanOrEqualTo": function(node, filter) { "PropertyIsGreaterThanOrEqualTo": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsBetween": function(node, filter) { "PropertyIsBetween": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.BETWEEN type: OpenLayers.Filter.Comparison.BETWEEN
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"PropertyIsLike": function(node, filter) { "PropertyIsLike": function(node, obj) {
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Rule.Comparison.LIKE type: OpenLayers.Filter.Comparison.LIKE
}); });
this.readChildNodes(node, rule); this.readChildNodes(node, filter);
var wildCard = node.getAttribute("wildCard"); var wildCard = node.getAttribute("wildCard");
var singleChar = node.getAttribute("singleChar"); var singleChar = node.getAttribute("singleChar");
var esc = node.getAttribute("escape"); var esc = node.getAttribute("escape");
rule.value2regex(wildCard, singleChar, esc); filter.value2regex(wildCard, singleChar, esc);
filter.rules.push(rule); obj.filters.push(filter);
}, },
"Literal": function(node, obj) { "Literal": function(node, obj) {
obj.value = this.getChildValue(node); obj.value = this.getChildValue(node);
}, },
"PropertyName": function(node, rule) { "PropertyName": function(node, filter) {
rule.property = this.getChildValue(node); filter.property = this.getChildValue(node);
}, },
"LowerBoundary": function(node, rule) { "LowerBoundary": function(node, filter) {
rule.lowerBoundary = this.readOgcExpression(node); filter.lowerBoundary = this.readOgcExpression(node);
}, },
"UpperBoundary": function(node, rule) { "UpperBoundary": function(node, filter) {
rule.upperBoundary = this.readOgcExpression(node); filter.upperBoundary = this.readOgcExpression(node);
} }
} }
}, },
@@ -682,8 +641,8 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
// add in optional filters // add in optional filters
if(rule.elseFilter) { if(rule.elseFilter) {
this.writeNode(node, "ElseFilter"); this.writeNode(node, "ElseFilter");
} else if(rule.CLASS_NAME != "OpenLayers.Rule") { } else if(rule.filter) {
this.writeNode(node, "ogc:Filter", rule); this.writeNode(node, "ogc:Filter", rule.filter);
} }
// add in scale limits // add in scale limits
@@ -867,15 +826,15 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
} }
}, },
"ogc": { "ogc": {
"Filter": function(rule) { "Filter": function(filter) {
var node = this.createElementNSPlus("ogc:Filter"); var node = this.createElementNSPlus("ogc:Filter");
var sub = rule.CLASS_NAME.split(".").pop(); var sub = filter.CLASS_NAME.split(".").pop();
if(sub == "FeatureId") { if(sub == "FeatureId") {
for(var i=0; i<rule.fids.length; ++i) { for(var i=0; i<filter.fids.length; ++i) {
this.writeNode(node, "FeatureId", rule.fids[i]); this.writeNode(node, "FeatureId", filter.fids[i]);
} }
} else { } else {
this.writeNode(node, this.getFilterType(rule), rule); this.writeNode(node, this.getFilterType(filter), filter);
} }
return node; return node;
}, },
@@ -884,120 +843,120 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
attributes: {fid: fid} attributes: {fid: fid}
}); });
}, },
"And": function(rule) { "And": function(filter) {
var node = this.createElementNSPlus("ogc:And"); var node = this.createElementNSPlus("ogc:And");
var childRule; var childFilter;
for(var i=0; i<rule.rules.length; ++i) { for(var i=0; i<filter.filters.length; ++i) {
childRule = rule.rules[i]; childFilter = filter.filters[i];
this.writeNode( this.writeNode(
node, this.getFilterType(childRule), childRule node, this.getFilterType(childFilter), childFilter
); );
} }
return node; return node;
}, },
"Or": function(rule) { "Or": function(filter) {
var node = this.createElementNSPlus("ogc:Or"); var node = this.createElementNSPlus("ogc:Or");
var childRule; var childFilter;
for(var i=0; i<rule.rules.length; ++i) { for(var i=0; i<filter.filters.length; ++i) {
childRule = rule.rules[i]; childFilter = filter.filters[i];
this.writeNode( this.writeNode(
node, this.getFilterType(childRule), childRule node, this.getFilterType(childFilter), childFilter
); );
} }
return node; return node;
}, },
"Not": function(rule) { "Not": function(filter) {
var node = this.createElementNSPlus("ogc:Not"); var node = this.createElementNSPlus("ogc:Not");
var childRule = rule.rules[0]; var childFilter = filter.filters[0];
this.writeNode( this.writeNode(
node, this.getFilterType(childRule), childRule node, this.getFilterType(childFilter), childFilter
); );
return node; return node;
}, },
"PropertyIsEqualTo": function(rule) { "PropertyIsEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsEqualTo"); var node = this.createElementNSPlus("ogc:PropertyIsEqualTo");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", rule); this.writeNode(node, "Literal", filter.value);
return node; return node;
}, },
"PropertyIsNotEqualTo": function(rule) { "PropertyIsNotEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo"); var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", rule); this.writeNode(node, "Literal", filter.value);
return node; return node;
}, },
"PropertyIsLessThan": function(rule) { "PropertyIsLessThan": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLessThan"); var node = this.createElementNSPlus("ogc:PropertyIsLessThan");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", rule); this.writeNode(node, "Literal", filter.value);
return node; return node;
}, },
"PropertyIsGreaterThan": function(rule) { "PropertyIsGreaterThan": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan"); var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", rule); this.writeNode(node, "Literal", filter.value);
return node; return node;
}, },
"PropertyIsLessThanOrEqualTo": function(rule) { "PropertyIsLessThanOrEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo"); var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", rule); this.writeNode(node, "Literal", filter.value);
return node; return node;
}, },
"PropertyIsGreaterThanOrEqualTo": function(rule) { "PropertyIsGreaterThanOrEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo"); var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", rule); this.writeNode(node, "Literal", filter.value);
return node; return node;
}, },
"PropertyIsBetween": function(rule) { "PropertyIsBetween": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsBetween"); var node = this.createElementNSPlus("ogc:PropertyIsBetween");
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "LowerBoundary", rule); this.writeNode(node, "LowerBoundary", filter);
this.writeNode(node, "UpperBoundary", rule); this.writeNode(node, "UpperBoundary", filter);
return node; return node;
}, },
"PropertyIsLike": function(rule) { "PropertyIsLike": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLike", { var node = this.createElementNSPlus("ogc:PropertyIsLike", {
attributes: { attributes: {
wildCard: "*", singleChar: ".", escape: "!" wildCard: "*", singleChar: ".", escape: "!"
} }
}); });
// no ogc:expression handling for now // no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule); this.writeNode(node, "PropertyName", filter);
// convert regex string to ogc string // convert regex string to ogc string
this.writeNode(node, "Literal", {value: rule.regex2value()}); this.writeNode(node, "Literal", filter.regex2value());
return node; return node;
}, },
"PropertyName": function(rule) { "PropertyName": function(filter) {
// no ogc:expression handling for now // no ogc:expression handling for now
return this.createElementNSPlus("ogc:PropertyName", { return this.createElementNSPlus("ogc:PropertyName", {
value: rule.property value: filter.property
}); });
}, },
"Literal": function(rule) { "Literal": function(value) {
// no ogc:expression handling for now // no ogc:expression handling for now
return this.createElementNSPlus("ogc:Literal", { return this.createElementNSPlus("ogc:Literal", {
value: rule.value value: value
}); });
}, },
"LowerBoundary": function(rule) { "LowerBoundary": function(filter) {
// no ogc:expression handling for now // no ogc:expression handling for now
var node = this.createElementNSPlus("ogc:LowerBoundary"); var node = this.createElementNSPlus("ogc:LowerBoundary");
this.writeNode(node, "Literal", rule.lowerBoundary); this.writeNode(node, "Literal", filter.lowerBoundary);
return node; return node;
}, },
"UpperBoundary": function(rule) { "UpperBoundary": function(filter) {
// no ogc:expression handling for now // no ogc:expression handling for now
var node = this.createElementNSPlus("ogc:UpperBoundary"); var node = this.createElementNSPlus("ogc:UpperBoundary");
this.writeNode(node, "Literal", rule.upperBoundary); this.writeNode(node, "Literal", filter.upperBoundary);
return node; return node;
} }
} }
@@ -1006,17 +965,17 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
/** /**
* Method: getFilterType * Method: getFilterType
*/ */
getFilterType: function(rule) { getFilterType: function(filter) {
var filterType = this.filterMap[rule.type]; var filterType = this.filterMap[filter.type];
if(!filterType) { if(!filterType) {
throw "SLD writing not supported for rule type: " + rule.type; throw "SLD writing not supported for rule type: " + filter.type;
} }
return filterType; return filterType;
}, },
/** /**
* Property: filterMap * Property: filterMap
* {Object} Contains a member for each rule type. Values are node names * {Object} Contains a member for each filter type. Values are node names
* for corresponding OGC Filter child elements. * for corresponding OGC Filter child elements.
*/ */
filterMap: { filterMap: {

88
lib/OpenLayers/Popup/Framed.js
View File

@@ -250,7 +250,16 @@ OpenLayers.Popup.Framed =
createBlocks: function() { createBlocks: function() {
this.blocks = []; this.blocks = [];
var position = this.positionBlocks[this.relativePosition]; //since all positions contain the same number of blocks, we can
// just pick the first position and use its blocks array to create
// our blocks array
var firstPosition = null;
for(var key in this.positionBlocks) {
firstPosition = key;
break;
}
var position = this.positionBlocks[firstPosition];
for (var i = 0; i < position.blocks.length; i++) { for (var i = 0; i < position.blocks.length; i++) {
var block = {}; var block = {};
@@ -283,48 +292,49 @@ OpenLayers.Popup.Framed =
* the popup's blocks in their appropropriate places. * the popup's blocks in their appropropriate places.
*/ */
updateBlocks: function() { updateBlocks: function() {
if (!this.blocks) { if (!this.blocks) {
this.createBlocks(); this.createBlocks();
} }
var position = this.positionBlocks[this.relativePosition]; if (this.relativePosition) {
for (var i = 0; i < position.blocks.length; i++) { var position = this.positionBlocks[this.relativePosition];
for (var i = 0; i < position.blocks.length; i++) {
var positionBlock = position.blocks[i];
var block = this.blocks[i]; var positionBlock = position.blocks[i];
var block = this.blocks[i];
// adjust sizes
var l = positionBlock.anchor.left; // adjust sizes
var b = positionBlock.anchor.bottom; var l = positionBlock.anchor.left;
var r = positionBlock.anchor.right; var b = positionBlock.anchor.bottom;
var t = positionBlock.anchor.top; var r = positionBlock.anchor.right;
var t = positionBlock.anchor.top;
//note that we use the isNaN() test here because if the
// size object is initialized with a "auto" parameter, the //note that we use the isNaN() test here because if the
// size constructor calls parseFloat() on the string, // size object is initialized with a "auto" parameter, the
// which will turn it into NaN // size constructor calls parseFloat() on the string,
// // which will turn it into NaN
var w = (isNaN(positionBlock.size.w)) ? this.size.w - (r + l) //
: positionBlock.size.w; var w = (isNaN(positionBlock.size.w)) ? this.size.w - (r + l)
: positionBlock.size.w;
var h = (isNaN(positionBlock.size.h)) ? this.size.h - (b + t)
: positionBlock.size.h; var h = (isNaN(positionBlock.size.h)) ? this.size.h - (b + t)
: positionBlock.size.h;
block.div.style.width = w + 'px';
block.div.style.height = h + 'px'; block.div.style.width = w + 'px';
block.div.style.height = h + 'px';
block.div.style.left = (l != null) ? l + 'px' : '';
block.div.style.bottom = (b != null) ? b + 'px' : ''; block.div.style.left = (l != null) ? l + 'px' : '';
block.div.style.right = (r != null) ? r + 'px' : ''; block.div.style.bottom = (b != null) ? b + 'px' : '';
block.div.style.top = (t != null) ? t + 'px' : ''; block.div.style.right = (r != null) ? r + 'px' : '';
block.div.style.top = (t != null) ? t + 'px' : '';
block.image.style.left = positionBlock.position.x + 'px';
block.image.style.top = positionBlock.position.y + 'px'; block.image.style.left = positionBlock.position.x + 'px';
block.image.style.top = positionBlock.position.y + 'px';
}
this.contentDiv.style.left = this.padding.left + "px";
this.contentDiv.style.top = this.padding.top + "px";
} }
this.contentDiv.style.left = this.padding.left + "px";
this.contentDiv.style.top = this.padding.top + "px";
}, },
CLASS_NAME: "OpenLayers.Popup.Framed" CLASS_NAME: "OpenLayers.Popup.Framed"

18
lib/OpenLayers/Renderer/VML.js
View File

@@ -37,10 +37,10 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
if (!this.supported()) { if (!this.supported()) {
return; return;
} }
if (!document.namespaces.v) { if (!document.namespaces.olv) {
document.namespaces.add("v", this.xmlns); document.namespaces.add("olv", this.xmlns);
var style = document.createStyleSheet(); var style = document.createStyleSheet();
style.addRule('v\\:*', "behavior: url(#default#VML); " + style.addRule('olv\\:*', "behavior: url(#default#VML); " +
"position: absolute; display: inline-block;"); "position: absolute; display: inline-block;");
} }
OpenLayers.Renderer.Elements.prototype.initialize.apply(this, OpenLayers.Renderer.Elements.prototype.initialize.apply(this,
@@ -120,17 +120,17 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
var nodeType = null; var nodeType = null;
switch (geometry.CLASS_NAME) { switch (geometry.CLASS_NAME) {
case "OpenLayers.Geometry.Point": case "OpenLayers.Geometry.Point":
nodeType = style.externalGraphic ? "v:rect" : "v:oval"; nodeType = style.externalGraphic ? "olv:rect" : "olv:oval";
break; break;
case "OpenLayers.Geometry.Rectangle": case "OpenLayers.Geometry.Rectangle":
nodeType = "v:rect"; nodeType = "olv:rect";
break; break;
case "OpenLayers.Geometry.LineString": case "OpenLayers.Geometry.LineString":
case "OpenLayers.Geometry.LinearRing": case "OpenLayers.Geometry.LinearRing":
case "OpenLayers.Geometry.Polygon": case "OpenLayers.Geometry.Polygon":
case "OpenLayers.Geometry.Curve": case "OpenLayers.Geometry.Curve":
case "OpenLayers.Geometry.Surface": case "OpenLayers.Geometry.Surface":
nodeType = "v:shape"; nodeType = "olv:shape";
break; break;
default: default:
break; break;
@@ -195,7 +195,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
} }
} else { } else {
if (!fill) { if (!fill) {
fill = this.createNode('v:fill', node.id + "_fill"); fill = this.createNode('olv:fill', node.id + "_fill");
} }
fill.setAttribute("opacity", style.fillOpacity); fill.setAttribute("opacity", style.fillOpacity);
@@ -236,7 +236,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
} }
} else { } else {
if (!stroke) { if (!stroke) {
stroke = this.createNode('v:stroke', node.id + "_stroke"); stroke = this.createNode('olv:stroke', node.id + "_stroke");
node.appendChild(stroke); node.appendChild(stroke);
} }
stroke.setAttribute("opacity", style.strokeOpacity); stroke.setAttribute("opacity", style.strokeOpacity);
@@ -379,7 +379,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
* {DOMElement} The main root element to which we'll add vectors * {DOMElement} The main root element to which we'll add vectors
*/ */
createRoot: function() { createRoot: function() {
return this.nodeFactory(this.container.id + "_root", "v:group"); return this.nodeFactory(this.container.id + "_root", "olv:group");
}, },
/************************************** /**************************************

18
lib/OpenLayers/Rule.js
View File

@@ -10,7 +10,7 @@
/** /**
* Class: OpenLayers.Rule * Class: OpenLayers.Rule
* This class represents a OGC Rule, as being used for rule-based SLD styling. * This class represents an SLD Rule, as being used for rule-based SLD styling.
*/ */
OpenLayers.Rule = OpenLayers.Class({ OpenLayers.Rule = OpenLayers.Class({
@@ -45,6 +45,12 @@ OpenLayers.Rule = OpenLayers.Class({
* be used. * be used.
*/ */
context: null, context: null,
/**
* Property: filter
* {<OpenLayers.Filter>} Optional filter for the rule.
*/
filter: null,
/** /**
* Property: elseFilter * Property: elseFilter
@@ -136,6 +142,16 @@ OpenLayers.Rule = OpenLayers.Class({
applies = scale < OpenLayers.Style.createLiteral( applies = scale < OpenLayers.Style.createLiteral(
this.maxScaleDenominator, context); this.maxScaleDenominator, context);
} }
// check if optional filter applies
if(applies && this.filter) {
// feature id filters get the feature, others get the context
if(this.filter.CLASS_NAME == "OpenLayers.Filter.FeatureId") {
applies = this.filter.evaluate(feature);
} else {
applies = this.filter.evaluate(context);
}
}
return applies; return applies;
}, },

104
lib/OpenLayers/Rule/Logical.js
View File

@@ -1,104 +0,0 @@
/* 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/Rule.js
*/
/**
* Class: OpenLayers.Rule.Logical
* This class represents ogc:And, ogc:Or and ogc:Not rules.
*
* Inherits from
* - <OpenLayers.Rule>
*/
OpenLayers.Rule.Logical = OpenLayers.Class(OpenLayers.Rule, {
/**
* APIProperty: children
* {Array(<OpenLayers.Rule>)} child rules for this rule
*/
rules: null,
/**
* APIProperty: type
* {String} type of logical operator. Available types are:
* - OpenLayers.Rule.Locical.AND = "&&";
* - OpenLayers.Rule.Logical.OR = "||";
* - OpenLayers.Rule.Logical.NOT = "!";
*/
type: null,
/**
* Constructor: OpenLayers.Rule.Logical
* Creates a logical rule (And, Or, Not).
*
* Parameters:
* options - {Object} An optional object with properties to set on the
* rule
*
* Returns:
* {<OpenLayers.Rule.Logical>}
*/
initialize: function(options) {
this.rules = [];
OpenLayers.Rule.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: destroy
* nullify references to prevent circular references and memory leaks
*/
destroy: function() {
for (var i=0; i<this.rules.length; i++) {
this.rules[i].destroy();
}
this.rules = null;
OpenLayers.Rule.prototype.destroy.apply(this, arguments);
},
/**
* APIMethod: evaluate
* evaluates this rule for a specific feature
*
* Parameters:
* feature - {<OpenLayers.Feature>} feature to apply the rule to.
*
* Returns:
* {boolean} true if the rule applies, false if it does not
*/
evaluate: function(feature) {
if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
return false;
}
switch(this.type) {
case OpenLayers.Rule.Logical.AND:
for (var i=0; i<this.rules.length; i++) {
if (this.rules[i].evaluate(feature) == false) {
return false;
}
}
return true;
case OpenLayers.Rule.Logical.OR:
for (var i=0; i<this.rules.length; i++) {
if (this.rules[i].evaluate(feature) == true) {
return true;
}
}
return false;
case OpenLayers.Rule.Logical.NOT:
return (!this.rules[0].evaluate(feature));
}
},
CLASS_NAME: "OpenLayers.Rule.Logical"
});
OpenLayers.Rule.Logical.AND = "&&";
OpenLayers.Rule.Logical.OR = "||";
OpenLayers.Rule.Logical.NOT = "!";

27
lib/OpenLayers/Util.js
View File

@@ -56,12 +56,24 @@ OpenLayers.Util.extend = function(destination, source) {
destination[property] = value; destination[property] = value;
} }
} }
/** /**
* IE doesn't include the toString property when iterating over an object's * IE doesn't include the toString property when iterating over an object's
* properties with the for(property in object) syntax. Explicitly check if * properties with the for(property in object) syntax. Explicitly check if
* the source has its own toString property. * the source has its own toString property.
*/ */
if(source.hasOwnProperty && source.hasOwnProperty('toString')) {
/*
* FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative
* prototype object" when calling hawOwnProperty if the source object
* is an instance of window.Event.
*/
var sourceIsEvt = typeof window.Event == "function"
&& source instanceof window.Event;
if(!sourceIsEvt
&& source.hasOwnProperty && source.hasOwnProperty('toString')) {
destination.toString = source.toString; destination.toString = source.toString;
} }
} }
@@ -510,9 +522,18 @@ OpenLayers.Util.upperCaseObject = function (object) {
* in place and returned by this function. * in place and returned by this function.
*/ */
OpenLayers.Util.applyDefaults = function (to, from) { OpenLayers.Util.applyDefaults = function (to, from) {
/*
* FF/Windows < 2.0.0.13 reports "Illegal operation on WrappedNative
* prototype object" when calling hawOwnProperty if the source object is an
* instance of window.Event.
*/
var fromIsEvt = typeof window.Event == "function"
&& from instanceof window.Event;
for (var key in from) { for (var key in from) {
if (to[key] === undefined || if (to[key] === undefined ||
(from.hasOwnProperty (!fromIsEvt && from.hasOwnProperty
&& from.hasOwnProperty(key) && !to.hasOwnProperty(key))) { && from.hasOwnProperty(key) && !to.hasOwnProperty(key))) {
to[key] = from[key]; to[key] = from[key];
} }
@@ -522,7 +543,7 @@ OpenLayers.Util.applyDefaults = function (to, from) {
* properties with the for(property in object) syntax. Explicitly check if * properties with the for(property in object) syntax. Explicitly check if
* the source has its own toString property. * the source has its own toString property.
*/ */
if(from.hasOwnProperty if(!fromIsEvt && from.hasOwnProperty
&& from.hasOwnProperty('toString') && !to.hasOwnProperty('toString')) { && from.hasOwnProperty('toString') && !to.hasOwnProperty('toString')) {
to.toString = from.toString; to.toString = from.toString;
} }

17
tests/Control/PanZoomBar.html
View File

@@ -33,6 +33,23 @@
map.addControl(control2, new OpenLayers.Pixel(100,100)); map.addControl(control2, new OpenLayers.Pixel(100,100));
t.eq( control2.div.style.top, "100px", "2nd control div is located correctly"); t.eq( control2.div.style.top, "100px", "2nd control div is located correctly");
} }
function test_Control_PanZoomBar_divClick (t) {
t.plan(2);
map = new OpenLayers.Map('map', {controls:[]});
var layer = new OpenLayers.Layer.WMS("Test Layer",
"http://octo.metacarta.com/cgi-bin/mapserv?",
{map: "/mapdata/vmap_wms.map", layers: "basic"});
map.addLayer(layer);
control = new OpenLayers.Control.PanZoomBar();
map.addControl(control);
control.divClick({'xy': {'x': 0, 'y': 50}, which: 1});
t.eq(map.zoom, 11, "zoom is correct on standard map");
map.fractionalZoom = true;
control.divClick({'xy': {'x': 0, 'y': 49}, which: 1});
t.eq(map.zoom.toFixed(3), '10.545', "zoom is correct on fractional zoom map");
}
</script> </script>
</head> </head>

21
tests/Filter.html Normal file
View File

@@ -0,0 +1,21 @@
<html>
<head>
<script src="../lib/OpenLayers.js"></script>
<script type="text/javascript">
function test_initialize(t) {
t.plan(3);
var options = {'foo': 'bar'};
var filter = new OpenLayers.Filter(options);
t.ok(filter instanceof OpenLayers.Filter,
"new OpenLayers.Filter returns object" );
t.eq(filter.foo, "bar", "constructor sets options correctly");
t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");
}
</script>
</head>
<body>
</body>
</html>

52
tests/Rule/Comparison.html → tests/Filter/Comparison.html
View File

@@ -7,41 +7,41 @@
t.plan(3); t.plan(3);
var options = {'foo': 'bar'}; var options = {'foo': 'bar'};
var rule = new OpenLayers.Rule.Comparison(options); var filter = new OpenLayers.Filter.Comparison(options);
t.ok(rule instanceof OpenLayers.Rule.Comparison, t.ok(filter instanceof OpenLayers.Filter.Comparison,
"new OpenLayers.Rule.Comparison returns object" ); "new OpenLayers.Filter.Comparison returns object" );
t.eq(rule.foo, "bar", "constructor sets options correctly"); t.eq(filter.foo, "bar", "constructor sets options correctly");
t.eq(typeof rule.evaluate, "function", "rule has an evaluate function"); t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");
} }
function test_Comparison_destroy(t) { function test_Comparison_destroy(t) {
t.plan(1); t.plan(1);
var rule = new OpenLayers.Rule.Comparison(); var filter = new OpenLayers.Filter.Comparison();
rule.destroy(); filter.destroy();
t.eq(rule.symbolizer, null, "symbolizer hash nulled properly"); t.eq(filter.symbolizer, null, "symbolizer hash nulled properly");
} }
function test_Comparison_value2regex(t) { function test_Comparison_value2regex(t) {
t.plan(2); t.plan(2);
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
property: "foo", property: "foo",
value: "*b?r\\*\\?*", value: "*b?r\\*\\?*",
type: OpenLayers.Rule.Comparison.LIKE}); type: OpenLayers.Filter.Comparison.LIKE});
rule.value2regex("*", "?", "\\"); filter.value2regex("*", "?", "\\");
t.eq(rule.value, ".*b.r\\*\\?.*", "Regular expression generated correctly."); t.eq(filter.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
rule.value = "%b.r!%!.%"; filter.value = "%b.r!%!.%";
rule.value2regex("%", ".", "!"); filter.value2regex("%", ".", "!");
t.eq(rule.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly."); t.eq(filter.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly.");
} }
function test_regex2value(t) { function test_regex2value(t) {
t.plan(8); t.plan(8);
function r2v(regex) { function r2v(regex) {
return OpenLayers.Rule.Comparison.prototype.regex2value.call( return OpenLayers.Filter.Comparison.prototype.regex2value.call(
{value: regex} {value: regex}
); );
} }
@@ -60,11 +60,11 @@
function test_Comparison_evaluate(t) { function test_Comparison_evaluate(t) {
t.plan(5); t.plan(5);
var rule = new OpenLayers.Rule.Comparison({ var filter = new OpenLayers.Filter.Comparison({
property: "area", property: "area",
lowerBoundary: 1000, lowerBoundary: 1000,
upperBoundary: 4999, upperBoundary: 4999,
type: OpenLayers.Rule.Comparison.BETWEEN}); type: OpenLayers.Filter.Comparison.BETWEEN});
var features = [ var features = [
new OpenLayers.Feature.Vector(null, { new OpenLayers.Feature.Vector(null, {
@@ -76,21 +76,21 @@
new OpenLayers.Feature.Vector(null, { new OpenLayers.Feature.Vector(null, {
area: 5000})]; area: 5000})];
// PropertyIsBetween filter: lower and upper boundary are inclusive // PropertyIsBetween filter: lower and upper boundary are inclusive
var ruleResults = { var filterResults = {
0: false, 0: false,
1: true, 1: true,
2: true, 2: true,
3: false}; 3: false};
for (var i in ruleResults) { for (var i in filterResults) {
var result = rule.evaluate(features[i]); var result = filter.evaluate(features[i].attributes);
t.eq(result, ruleResults[i], "feature "+i+ t.eq(result, filterResults[i], "feature "+i+
" evaluates to "+result.toString()+" correctly."); " evaluates to "+result.toString()+" correctly.");
} }
rule.context = { var context = {
area: 4998 area: 4998
} };
var result = rule.evaluate(); var result = filter.evaluate(context);
t.eq(result, true, "evaluation against custom rule context works."); t.eq(result, true, "evaluation against custom filter context works.");
} }
</script> </script>
</head> </head>

47
tests/Filter/FeatureId.html Normal file
View File

@@ -0,0 +1,47 @@
<html>
<head>
<script src="../../lib/OpenLayers.js"></script>
<script type="text/javascript">
function test_FeatureId_constructor(t) {
t.plan(3);
var options = {'foo': 'bar'};
var filter = new OpenLayers.Filter.FeatureId(options);
t.ok(filter instanceof OpenLayers.Filter.FeatureId,
"new OpenLayers.Filter.FeatureId returns object" );
t.eq(filter.foo, "bar", "constructor sets options correctly");
t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");
}
function test_FeatureId_destroy(t) {
t.plan(1);
var filter = new OpenLayers.Filter.FeatureId();
filter.destroy();
t.eq(filter.symbolizer, null, "symbolizer hash nulled properly");
}
function test_FeatureId_evaluate(t) {
t.plan(3);
var filter = new OpenLayers.Filter.FeatureId(
{fids: ["fid_1", "fid_3"]});
var filterResults = {
"fid_1" : true,
"fid_2" : false,
"fid_3" : true};
for (var i in filterResults) {
var feature = new OpenLayers.Feature.Vector();
feature.fid = i;
var result = filter.evaluate(feature);
t.eq(result, filterResults[i], "feature "+i+" evaluates to "+result.toString()+" correctly.");
feature.destroy();
}
}
</script>
</head>
<body>
</body>
</html>

41
tests/Filter/Logical.html Normal file
View File

@@ -0,0 +1,41 @@
<html>
<head>
<script src="../../lib/OpenLayers.js"></script>
<script type="text/javascript">
function test_Logical_constructor(t) {
t.plan(3);
var options = {'foo': 'bar'};
var filter = new OpenLayers.Filter.Logical(options);
t.ok(filter instanceof OpenLayers.Filter.Logical,
"new OpenLayers.Filter.Logical returns object" );
t.eq(filter.foo, "bar", "constructor sets options correctly");
t.eq(typeof filter.evaluate, "function", "filter has an evaluate function");
}
function test_Logical_destroy(t) {
t.plan(1);
var filter = new OpenLayers.Filter.Logical();
filter.destroy();
t.eq(filter.filters, null, "filters array nulled properly");
}
function test_Logical_evaluate(t) {
t.plan(1);
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.NOT});
filter.filters.push(new OpenLayers.Filter());
var feature = new OpenLayers.Feature.Vector();
t.eq(filter.evaluate(feature.attributes), false,
"feature evaluates to false correctly.");
}
</script>
</head>
<body>
</body>
</html>

158
tests/Format/SLD/v1_0_0.html Normal file
View File

@@ -0,0 +1,158 @@
<html>
<head>
<script src="../../../lib/OpenLayers.js"></script>
<script type="text/javascript">
var sld =
'<StyledLayerDescriptor version="1.0.0" ' +
'xmlns="http://www.opengis.net/sld" ' +
'xmlns:gml="http://www.opengis.net/gml" ' +
'xmlns:ogc="http://www.opengis.net/ogc" ' +
'xmlns:xlink="http://www.w3.org/1999/xlink" ' +
'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' +
'xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd">' +
'<NamedLayer>' +
'<Name>AAA161</Name>' +
'<UserStyle>' +
'<FeatureTypeStyle>' +
'<Rule>' +
'<Name>stortsteen</Name>' +
'<ogc:Filter>' +
'<ogc:PropertyIsEqualTo>' +
'<ogc:PropertyName>CTE</ogc:PropertyName>' +
'<ogc:Literal>V0305</ogc:Literal>' +
'</ogc:PropertyIsEqualTo>' +
'</ogc:Filter>' +
'<MaxScaleDenominator>50000</MaxScaleDenominator>' +
'<PolygonSymbolizer>' +
'<Fill>' +
'<CssParameter name="fill">#ffffff</CssParameter>' +
'</Fill>' +
'<Stroke>' +
'<CssParameter name="stroke">#000000</CssParameter>' +
'</Stroke>' +
'</PolygonSymbolizer>' +
'</Rule>' +
'<Rule>' +
'<Name>betonbekleding</Name>' +
'<ogc:Filter>' +
'<ogc:PropertyIsLessThan>' +
'<ogc:PropertyName>CTE</ogc:PropertyName>' +
'<ogc:Literal>1000</ogc:Literal>' +
'</ogc:PropertyIsLessThan>' +
'</ogc:Filter>' +
'<MaxScaleDenominator>50000</MaxScaleDenominator>' +
'<PolygonSymbolizer>' +
'<Fill>' +
'<CssParameter name="fill">#ffff00</CssParameter>' +
'</Fill>' +
'<Stroke>' +
'<CssParameter name="stroke">#0000ff</CssParameter>' +
'</Stroke>' +
'</PolygonSymbolizer>' +
'</Rule>' +
'</FeatureTypeStyle>' +
'</UserStyle>' +
'</NamedLayer>' +
'<NamedLayer>' +
'<Name>Second Layer</Name>' +
'<UserStyle>' +
'<FeatureTypeStyle>' +
'<Rule>' +
'<Name>first rule second layer</Name>' +
'<ogc:Filter>' +
'<ogc:Or>' +
'<ogc:PropertyIsBetween>' +
'<ogc:PropertyName>number</ogc:PropertyName>' +
'<ogc:LowerBoundary>' +
'<ogc:Literal>1064866676</ogc:Literal>' +
'</ogc:LowerBoundary>' +
'<ogc:UpperBoundary>' +
'<ogc:Literal>1065512599</ogc:Literal>' +
'</ogc:UpperBoundary>' +
'</ogc:PropertyIsBetween>' +
'<ogc:PropertyIsLike wildCard="*" singleChar="." escape="!">' +
'<ogc:PropertyName>cat</ogc:PropertyName>' +
'<ogc:Literal>*dog.food!*good</ogc:Literal>' +
'</ogc:PropertyIsLike>' +
'<ogc:Not>' +
'<ogc:PropertyIsLessThanOrEqualTo>' +
'<ogc:PropertyName>FOO</ogc:PropertyName>' +
'<ogc:Literal>5000</ogc:Literal>' +
'</ogc:PropertyIsLessThanOrEqualTo>' +
'</ogc:Not>' +
'</ogc:Or>' +
'</ogc:Filter>' +
'<MaxScaleDenominator>10000</MaxScaleDenominator>' +
'<PointSymbolizer>' +
'<Graphic>' +
'<Mark>' +
'<WellKnownName>star</WellKnownName>' +
'<Fill>' +
'<CssParameter name="fill">lime</CssParameter>' +
'</Fill>' +
'<Stroke>' +
'<CssParameter name="stroke">olive</CssParameter>' +
'<CssParameter name="stroke-width">2</CssParameter>' +
'</Stroke>' +
'</Mark>' +
'</Graphic>' +
'</PointSymbolizer>' +
'</Rule>' +
'</FeatureTypeStyle>' +
'</UserStyle>' +
'</NamedLayer>' +
'</StyledLayerDescriptor>';
function test_read(t) {
t.plan(6);
var parser = new OpenLayers.Format.SLD.v1_0_0();
var xml = new OpenLayers.Format.XML();
var obj = parser.read(xml.read(sld));
// test the named layer count
var count = 0;
for(var key in obj.namedLayers) {
++count;
}
t.eq(count, 2, "correct number of named layers");
var layer, style, rule;
// check the first named layer
layer = obj.namedLayers["AAA161"];
t.ok(layer, "first named layer exists");
t.ok(layer.userStyles instanceof Array, "(AAA161) layer has array of user styles");
t.eq(layer.userStyles.length, 1, "(AAA161) first layer has a single user style");
// check the first user style
style = layer.userStyles[0];
t.ok(style instanceof OpenLayers.Style, "(AAA161,0) user style is instance of OpenLayers.Style");
t.eq(style.rules.length, 2, "(AAA161,0) user style has 2 rules");
// check the first rule
// etc. I'm convinced read works, really wanted to test write (since examples don't test that)
// I'll add more tests here later.
}
function test_write(t) {
t.plan(1);
// read first - testing that write produces the SLD aboce
var parser = new OpenLayers.Format.SLD.v1_0_0();
var xml = new OpenLayers.Format.XML();
var obj = parser.read(xml.read(sld));
var node = parser.write(obj);
t.xml_eq(node, sld, "SLD correctly written");
}
</script>
</head>
<body>
</body>
</html>

18
tests/Popup/FramedCloud.html Normal file
View File

@@ -0,0 +1,18 @@
<html>
<head>
<script src="../../lib/OpenLayers.js"></script>
<script type="text/javascript">
function test_Popup_FramedCloud_setHTML(t) {
t.plan(1);
popup = new OpenLayers.Popup.FramedCloud();
popup.setContentHTML("<p></p>");
t.ok("setHTML on popup not yet added to map doesn't fail");
}
</script>
</head>
<body>
<div id="map" style="width:512px; height:256px"> </div>
</body>
</html>

47
tests/Rule/FeatureId.html
View File

@@ -1,47 +0,0 @@
<html>
<head>
<script src="../../lib/OpenLayers.js"></script>
<script type="text/javascript">
function test_FeatureId_constructor(t) {
t.plan(3);
var options = {'foo': 'bar'};
var rule = new OpenLayers.Rule.FeatureId(options);
t.ok(rule instanceof OpenLayers.Rule.FeatureId,
"new OpenLayers.Rule.FeatureId returns object" );
t.eq(rule.foo, "bar", "constructor sets options correctly");
t.eq(typeof rule.evaluate, "function", "rule has an evaluate function");
}
function test_FeatureId_destroy(t) {
t.plan(1);
var rule = new OpenLayers.Rule.FeatureId();
rule.destroy();
t.eq(rule.symbolizer, null, "symbolizer hash nulled properly");
}
function test_FeatureId_evaluate(t) {
t.plan(3);
var rule = new OpenLayers.Rule.FeatureId(
{fids: ["fid_1", "fid_3"]});
var ruleResults = {
"fid_1" : true,
"fid_2" : false,
"fid_3" : true};
for (var i in ruleResults) {
var feature = new OpenLayers.Feature.Vector();
feature.fid = i;
var result = rule.evaluate(feature);
t.eq(result, ruleResults[i], "feature "+i+" evaluates to "+result.toString()+" correctly.");
feature.destroy();
}
}
</script>
</head>
<body>
</body>
</html>

41
tests/Rule/Logical.html
View File

@@ -1,41 +0,0 @@
<html>
<head>
<script src="../../lib/OpenLayers.js"></script>
<script type="text/javascript">
function test_Logical_constructor(t) {
t.plan(3);
var options = {'foo': 'bar'};
var rule = new OpenLayers.Rule.Logical(options);
t.ok(rule instanceof OpenLayers.Rule.Logical,
"new OpenLayers.Rule.Logical returns object" );
t.eq(rule.foo, "bar", "constructor sets options correctly");
t.eq(typeof rule.evaluate, "function", "rule has an evaluate function");
}
function test_Logical_destroy(t) {
t.plan(1);
var rule = new OpenLayers.Rule.Logical();
rule.destroy();
t.eq(rule.rules, null, "rules array nulled properly");
}
function test_Logical_evaluate(t) {
t.plan(1);
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.NOT});
rule.rules.push(new OpenLayers.Rule());
var feature = new OpenLayers.Feature.Vector();
t.eq(rule.evaluate(feature), false,
"feature evaluates to false correctly.");
}
</script>
</head>
<body>
</body>
</html>

50
tests/Style.html
View File

@@ -27,20 +27,29 @@
var style = new OpenLayers.Style(baseStyle); var style = new OpenLayers.Style(baseStyle);
var rule1 = new OpenLayers.Rule.FeatureId({ var rule1 = new OpenLayers.Rule({
fids: ["1"], symbolizer: {"Point": {fillColor: "green"}},
symbolizer: {"Point": {fillColor: "green"}}, maxScaleDenominator: 500000,
maxScaleDenominator: 500000}); filter: new OpenLayers.Filter.FeatureId({
var rule2 = new OpenLayers.Rule.FeatureId({ fids: ["1"]
fids: ["1"], })
symbolizer: {"Point": {fillColor: "yellow"}}, });
minScaleDenominator: 500000, var rule2 = new OpenLayers.Rule({
maxScaleDenominator: 1000000}); symbolizer: {"Point": {fillColor: "yellow"}},
var rule3 = new OpenLayers.Rule.FeatureId({ minScaleDenominator: 500000,
fids: ["1"], maxScaleDenominator: 1000000,
symbolizer: {"Point": {fillColor: "red"}}, filter: new OpenLayers.Filter.FeatureId({
minScaleDenominator: 1000000, fids: ["1"]
maxScaleDenominator: 2500000}); })
});
var rule3 = new OpenLayers.Rule({
symbolizer: {"Point": {fillColor: "red"}},
minScaleDenominator: 1000000,
maxScaleDenominator: 2500000,
filter: new OpenLayers.Filter.FeatureId({
fids: ["1"]
})
});
var feature = new OpenLayers.Feature.Vector( var feature = new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(3,5), new OpenLayers.Geometry.Point(3,5),
@@ -119,11 +128,14 @@
function test_Style_context(t) { function test_Style_context(t) {
t.plan(1); t.plan(1);
var rule = new OpenLayers.Rule.Comparison({ var rule = new OpenLayers.Rule({
type: OpenLayers.Rule.Comparison.LESS_THAN, symbolizer: {"Point": {externalGraphic: "${img1}"}},
property: "size", filter: new OpenLayers.Filter.Comparison({
value: 11, type: OpenLayers.Filter.Comparison.LESS_THAN,
symbolizer: {"Point": {externalGraphic: "${img1}"}}}); property: "size",
value: 11
})
});
var style = new OpenLayers.Style(); var style = new OpenLayers.Style();
style.context = { style.context = {
"img1": "myImage.png" "img1": "myImage.png"

9
tests/list-tests.html
View File

@@ -29,6 +29,7 @@
<li>Format/OSM.html</li> <li>Format/OSM.html</li>
<li>Format/KML.html</li> <li>Format/KML.html</li>
<li>Format/SLD.html</li> <li>Format/SLD.html</li>
<li>Format/SLD/v1_0_0.html</li>
<li>Format/WKT.html</li> <li>Format/WKT.html</li>
<li>Format/WMC.html</li> <li>Format/WMC.html</li>
<li>Format/WMC/v1_1_0.html</li> <li>Format/WMC/v1_1_0.html</li>
@@ -40,14 +41,16 @@
<li>Popup.html</li> <li>Popup.html</li>
<li>Popup/Anchored.html</li> <li>Popup/Anchored.html</li>
<li>Popup/AnchoredBubble.html</li> <li>Popup/AnchoredBubble.html</li>
<li>Popup/FramedCloud.html</li>
<li>Feature.html</li> <li>Feature.html</li>
<li>Feature/Vector.html</li> <li>Feature/Vector.html</li>
<li>Style.html</li> <li>Style.html</li>
<li>StyleMap.html</li> <li>StyleMap.html</li>
<li>Rule.html</li> <li>Rule.html</li>
<li>Rule/Comparison.html</li> <li>Filter.html</li>
<li>Rule/FeatureId.html</li> <li>Filter/Comparison.html</li>
<li>Rule/Logical.html</li> <li>Filter/FeatureId.html</li>
<li>Filter/Logical.html</li>
<li>Events.html</li> <li>Events.html</li>
<li>Util.html</li> <li>Util.html</li>
<li>Lang.html</li> <li>Lang.html</li>