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

7
lib/OpenLayers.js
View File

@@ -183,9 +183,10 @@
"OpenLayers/Style.js",
"OpenLayers/StyleMap.js",
"OpenLayers/Rule.js",
"OpenLayers/Rule/FeatureId.js",
"OpenLayers/Rule/Logical.js",
"OpenLayers/Rule/Comparison.js",
"OpenLayers/Filter.js",
"OpenLayers/Filter/FeatureId.js",
"OpenLayers/Filter/Logical.js",
"OpenLayers/Filter/Comparison.js",
"OpenLayers/Format.js",
"OpenLayers/Format/XML.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.vertices = [];
this.virtualVertices = [];
this.styleVirtual = OpenLayers.Util.extend({},
this.virtualStyle = OpenLayers.Util.extend({},
this.layer.style || this.layer.styleMap.createSymbolizer());
this.styleVirtual.fillOpacity = 0.3;
this.styleVirtual.strokeOpacity = 0.3;
this.virtualStyle.fillOpacity = 0.3;
this.virtualStyle.strokeOpacity = 0.3;
this.deleteCodes = [46, 100];
this.mode = OpenLayers.Control.ModifyFeature.RESHAPE;
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 point = new OpenLayers.Feature.Vector(
new OpenLayers.Geometry.Point(x, y),
null, control.styleVirtual
null, control.virtualStyle
);
// set the virtual parent and intended index
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
* {<OpenLayers.Map>} A reference to the overvew map itself.
* {<OpenLayers.Map>} A reference to the overview map itself.
*/
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 top = OpenLayers.Util.pagePosition(evt.object)[1];
var levels = (y - top)/this.zoomStopHeight;
var zoom = (this.map.getNumZoomLevels() - 1) - levels;
if(this.map.fractionalZoom) {
zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1);
} else {
zoom = Math.floor(zoom);
if(!this.map.fractionalZoom) {
levels = Math.floor(levels);
}
var zoom = (this.map.getNumZoomLevels() - 1) - levels;
zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1);
this.map.zoomTo(zoom);
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. */
/**
* @requires OpenLayers/Rule.js
* @requires OpenLayers/Filter.js
*/
/**
* Class: OpenLayers.Rule.Comparison
* This class represents the comparison rules, as being used for rule-based
* SLD styling
* Class: OpenLayers.Filter.Comparison
* This class represents a comparison filter.
*
* Inherits from
* - <OpenLayers.Rule>
* - <OpenLayers.Filter>
*/
OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
OpenLayers.Filter.Comparison = OpenLayers.Class(OpenLayers.Filter, {
/**
* APIProperty: type
* {String} type: type of the comparison. This is one of
* - OpenLayers.Rule.Comparison.EQUAL_TO = "==";
* - OpenLayers.Rule.Comparison.NOT_EQUAL_TO = "!=";
* - OpenLayers.Rule.Comparison.LESS_THAN = "<";
* - OpenLayers.Rule.Comparison.GREATER_THAN = ">";
* - OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
* - OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
* - OpenLayers.Rule.Comparison.BETWEEN = "..";
* - OpenLayers.Rule.Comparison.LIKE = "~";
* - OpenLayers.Filter.Comparison.EQUAL_TO = "==";
* - OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
* - OpenLayers.Filter.Comparison.LESS_THAN = "<";
* - OpenLayers.Filter.Comparison.GREATER_THAN = ">";
* - OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
* - OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
* - OpenLayers.Filter.Comparison.BETWEEN = "..";
* - OpenLayers.Filter.Comparison.LIKE = "~";
*/
type: null,
@@ -65,7 +64,7 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
upperBoundary: null,
/**
* Constructor: OpenLayers.Rule.Comparison
* Constructor: OpenLayers.Filter.Comparison
* Creates a comparison rule.
*
* Parameters:
@@ -76,42 +75,39 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
* rule
*
* Returns:
* {<OpenLayers.Rule.Comparison>}
* {<OpenLayers.Filter.Comparison>}
*/
initialize: function(options) {
OpenLayers.Rule.prototype.initialize.apply(this, [options]);
OpenLayers.Filter.prototype.initialize.apply(this, [options]);
},
/**
* APIMethod: evaluate
* evaluates this rule for a specific context
* Evaluates this filter in a specific context. Should be implemented by
* subclasses.
*
* Parameters:
* context - {Object} context to apply the rule to.
* context - {Object} Context to use in evaluating the filter.
*
* Returns:
* {boolean} true if the rule applies, false if it does not
* {Boolean} The filter applies.
*/
evaluate: function(feature) {
if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
return false;
}
var context = this.getContext(feature);
evaluate: function(context) {
switch(this.type) {
case OpenLayers.Rule.Comparison.EQUAL_TO:
case OpenLayers.Rule.Comparison.LESS_THAN:
case OpenLayers.Rule.Comparison.GREATER_THAN:
case OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO:
case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO:
case OpenLayers.Filter.Comparison.EQUAL_TO:
case OpenLayers.Filter.Comparison.LESS_THAN:
case OpenLayers.Filter.Comparison.GREATER_THAN:
case OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO:
case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
return this.binaryCompare(context, this.property, this.value);
case OpenLayers.Rule.Comparison.BETWEEN:
case OpenLayers.Filter.Comparison.BETWEEN:
var result =
context[this.property] >= this.lowerBoundary;
result = result &&
context[this.property] <= this.upperBoundary;
return result;
case OpenLayers.Rule.Comparison.LIKE:
case OpenLayers.Filter.Comparison.LIKE:
var regexp = new RegExp(this.value,
"gi");
return regexp.test(context[this.property]);
@@ -139,7 +135,7 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
value2regex: function(wildCard, singleChar, escapeChar) {
if (wildCard == ".") {
var msg = "'.' is an unsupported wildCard character for "+
"OpenLayers.Rule.Comparison";
"OpenLayers.Filter.Comparison";
OpenLayers.Console.error(msg);
return null;
}
@@ -212,30 +208,30 @@ OpenLayers.Rule.Comparison = OpenLayers.Class(OpenLayers.Rule, {
*/
binaryCompare: function(context, property, value) {
switch (this.type) {
case OpenLayers.Rule.Comparison.EQUAL_TO:
case OpenLayers.Filter.Comparison.EQUAL_TO:
return context[property] == value;
case OpenLayers.Rule.Comparison.NOT_EQUAL_TO:
case OpenLayers.Filter.Comparison.NOT_EQUAL_TO:
return context[property] != value;
case OpenLayers.Rule.Comparison.LESS_THAN:
case OpenLayers.Filter.Comparison.LESS_THAN:
return context[property] < value;
case OpenLayers.Rule.Comparison.GREATER_THAN:
case OpenLayers.Filter.Comparison.GREATER_THAN:
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;
case OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO:
case OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO:
return context[property] >= value;
}
},
CLASS_NAME: "OpenLayers.Rule.Comparison"
CLASS_NAME: "OpenLayers.Filter.Comparison"
});
OpenLayers.Rule.Comparison.EQUAL_TO = "==";
OpenLayers.Rule.Comparison.NOT_EQUAL_TO = "!=";
OpenLayers.Rule.Comparison.LESS_THAN = "<";
OpenLayers.Rule.Comparison.GREATER_THAN = ">";
OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
OpenLayers.Rule.Comparison.BETWEEN = "..";
OpenLayers.Rule.Comparison.LIKE = "~";
OpenLayers.Filter.Comparison.EQUAL_TO = "==";
OpenLayers.Filter.Comparison.NOT_EQUAL_TO = "!=";
OpenLayers.Filter.Comparison.LESS_THAN = "<";
OpenLayers.Filter.Comparison.GREATER_THAN = ">";
OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO = "<=";
OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO = ">=";
OpenLayers.Filter.Comparison.BETWEEN = "..";
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
* This class represents a ogc:FeatureId Rule, as being used for rule-based SLD
* Class: OpenLayers.Filter.FeatureId
* This class represents a ogc:FeatureId Filter, as being used for rule-based SLD
* styling
*
* Inherits from
* - <OpenLayers.Rule>
* - <OpenLayers.Filter>
*/
OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
OpenLayers.Filter.FeatureId = OpenLayers.Class(OpenLayers.Filter, {
/**
* APIProperty: fids
@@ -25,7 +25,7 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
fids: null,
/**
* Constructor: OpenLayers.Rule.FeatureId
* Constructor: OpenLayers.Filter.FeatureId
* Creates an ogc:FeatureId rule.
*
* Parameters:
@@ -33,11 +33,11 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
* rule
*
* Returns:
* {<OpenLayers.Rule.FeatureId>}
* {<OpenLayers.Filter.FeatureId>}
*/
initialize: function(options) {
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
*/
evaluate: function(feature) {
if (!OpenLayers.Rule.prototype.evaluate.apply(this, arguments)) {
return false;
}
for (var i=0; i<this.fids.length; i++) {
var fid = feature.fid || feature.id;
if (fid == this.fids[i]) {
@@ -65,5 +62,5 @@ OpenLayers.Rule.FeatureId = OpenLayers.Class(OpenLayers.Rule, {
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.
*/
try {
if(/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
test(json)) {
if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, '@').
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

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;
},
"Rule": function(node, obj) {
// Rule elements are represented as OpenLayers.Rule instances.
// Filter elements are represented as instances of
// 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);
}
var rule = new OpenLayers.Rule();
this.readChildNodes(node, rule);
obj.rules.push(rule);
},
"ElseFilter": function(node, rule) {
@@ -283,146 +267,121 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
},
"ogc": {
"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
// 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).
var filter = {
var obj = {
fids: [],
rules: []
filters: []
};
this.readChildNodes(node, filter);
if(filter.fids.length > 0) {
rule.rules.push(new OpenLayers.Rule.FeatureId({
fids: filter.fids
}));
}
if(filter.rules.length > 0) {
rule.rules = rule.rules.concat(filter.rules);
this.readChildNodes(node, obj);
if(obj.fids.length > 0) {
rule.filter = new OpenLayers.Filter.FeatureId({
fids: obj.fids
});
} else if(obj.filters.length > 0) {
rule.filter = obj.filters[0];
}
},
"FeatureId": function(node, filter) {
"FeatureId": function(node, obj) {
var fid = node.getAttribute("fid");
if(fid) {
filter.fids.push(fid);
obj.fids.push(fid);
}
},
"And": function(node, filter) {
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.AND
"And": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.AND
});
// since FeatureId rules may be nested here, make room for them
rule.fids = [];
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);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"Or": function(node, filter) {
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.OR
"Or": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.OR
});
// since FeatureId rules may be nested here, make room for them
rule.fids = [];
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);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"Not": function(node, filter) {
var rule = new OpenLayers.Rule.Logical({
type: OpenLayers.Rule.Logical.NOT
"Not": function(node, obj) {
var filter = new OpenLayers.Filter.Logical({
type: OpenLayers.Filter.Logical.NOT
});
// since FeatureId rules may be nested here, make room for them
rule.fids = [];
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);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.EQUAL_TO
"PropertyIsEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsNotEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.NOT_EQUAL_TO
"PropertyIsNotEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLessThan": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.LESS_THAN
"PropertyIsLessThan": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsGreaterThan": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.GREATER_THAN
"PropertyIsGreaterThan": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.GREATER_THAN
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLessThanOrEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO
"PropertyIsLessThanOrEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsGreaterThanOrEqualTo": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO
"PropertyIsGreaterThanOrEqualTo": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsBetween": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.BETWEEN
"PropertyIsBetween": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.BETWEEN
});
this.readChildNodes(node, rule);
filter.rules.push(rule);
this.readChildNodes(node, filter);
obj.filters.push(filter);
},
"PropertyIsLike": function(node, filter) {
var rule = new OpenLayers.Rule.Comparison({
type: OpenLayers.Rule.Comparison.LIKE
"PropertyIsLike": function(node, obj) {
var filter = new OpenLayers.Filter.Comparison({
type: OpenLayers.Filter.Comparison.LIKE
});
this.readChildNodes(node, rule);
this.readChildNodes(node, filter);
var wildCard = node.getAttribute("wildCard");
var singleChar = node.getAttribute("singleChar");
var esc = node.getAttribute("escape");
rule.value2regex(wildCard, singleChar, esc);
filter.rules.push(rule);
filter.value2regex(wildCard, singleChar, esc);
obj.filters.push(filter);
},
"Literal": function(node, obj) {
obj.value = this.getChildValue(node);
},
"PropertyName": function(node, rule) {
rule.property = this.getChildValue(node);
"PropertyName": function(node, filter) {
filter.property = this.getChildValue(node);
},
"LowerBoundary": function(node, rule) {
rule.lowerBoundary = this.readOgcExpression(node);
"LowerBoundary": function(node, filter) {
filter.lowerBoundary = this.readOgcExpression(node);
},
"UpperBoundary": function(node, rule) {
rule.upperBoundary = this.readOgcExpression(node);
"UpperBoundary": function(node, filter) {
filter.upperBoundary = this.readOgcExpression(node);
}
}
},
@@ -682,8 +641,8 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
// add in optional filters
if(rule.elseFilter) {
this.writeNode(node, "ElseFilter");
} else if(rule.CLASS_NAME != "OpenLayers.Rule") {
this.writeNode(node, "ogc:Filter", rule);
} else if(rule.filter) {
this.writeNode(node, "ogc:Filter", rule.filter);
}
// add in scale limits
@@ -867,15 +826,15 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
}
},
"ogc": {
"Filter": function(rule) {
"Filter": function(filter) {
var node = this.createElementNSPlus("ogc:Filter");
var sub = rule.CLASS_NAME.split(".").pop();
var sub = filter.CLASS_NAME.split(".").pop();
if(sub == "FeatureId") {
for(var i=0; i<rule.fids.length; ++i) {
this.writeNode(node, "FeatureId", rule.fids[i]);
for(var i=0; i<filter.fids.length; ++i) {
this.writeNode(node, "FeatureId", filter.fids[i]);
}
} else {
this.writeNode(node, this.getFilterType(rule), rule);
this.writeNode(node, this.getFilterType(filter), filter);
}
return node;
},
@@ -884,120 +843,120 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
attributes: {fid: fid}
});
},
"And": function(rule) {
"And": function(filter) {
var node = this.createElementNSPlus("ogc:And");
var childRule;
for(var i=0; i<rule.rules.length; ++i) {
childRule = rule.rules[i];
var childFilter;
for(var i=0; i<filter.filters.length; ++i) {
childFilter = filter.filters[i];
this.writeNode(
node, this.getFilterType(childRule), childRule
node, this.getFilterType(childFilter), childFilter
);
}
return node;
},
"Or": function(rule) {
"Or": function(filter) {
var node = this.createElementNSPlus("ogc:Or");
var childRule;
for(var i=0; i<rule.rules.length; ++i) {
childRule = rule.rules[i];
var childFilter;
for(var i=0; i<filter.filters.length; ++i) {
childFilter = filter.filters[i];
this.writeNode(
node, this.getFilterType(childRule), childRule
node, this.getFilterType(childFilter), childFilter
);
}
return node;
},
"Not": function(rule) {
"Not": function(filter) {
var node = this.createElementNSPlus("ogc:Not");
var childRule = rule.rules[0];
var childFilter = filter.filters[0];
this.writeNode(
node, this.getFilterType(childRule), childRule
node, this.getFilterType(childFilter), childFilter
);
return node;
},
"PropertyIsEqualTo": function(rule) {
"PropertyIsEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsNotEqualTo": function(rule) {
"PropertyIsNotEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsLessThan": function(rule) {
"PropertyIsLessThan": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLessThan");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsGreaterThan": function(rule) {
"PropertyIsGreaterThan": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsLessThanOrEqualTo": function(rule) {
"PropertyIsLessThanOrEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsGreaterThanOrEqualTo": function(rule) {
"PropertyIsGreaterThanOrEqualTo": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "Literal", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "Literal", filter.value);
return node;
},
"PropertyIsBetween": function(rule) {
"PropertyIsBetween": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsBetween");
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "LowerBoundary", rule);
this.writeNode(node, "UpperBoundary", rule);
this.writeNode(node, "PropertyName", filter);
this.writeNode(node, "LowerBoundary", filter);
this.writeNode(node, "UpperBoundary", filter);
return node;
},
"PropertyIsLike": function(rule) {
"PropertyIsLike": function(filter) {
var node = this.createElementNSPlus("ogc:PropertyIsLike", {
attributes: {
wildCard: "*", singleChar: ".", escape: "!"
}
});
// no ogc:expression handling for now
this.writeNode(node, "PropertyName", rule);
this.writeNode(node, "PropertyName", filter);
// convert regex string to ogc string
this.writeNode(node, "Literal", {value: rule.regex2value()});
this.writeNode(node, "Literal", filter.regex2value());
return node;
},
"PropertyName": function(rule) {
"PropertyName": function(filter) {
// no ogc:expression handling for now
return this.createElementNSPlus("ogc:PropertyName", {
value: rule.property
value: filter.property
});
},
"Literal": function(rule) {
"Literal": function(value) {
// no ogc:expression handling for now
return this.createElementNSPlus("ogc:Literal", {
value: rule.value
value: value
});
},
"LowerBoundary": function(rule) {
"LowerBoundary": function(filter) {
// no ogc:expression handling for now
var node = this.createElementNSPlus("ogc:LowerBoundary");
this.writeNode(node, "Literal", rule.lowerBoundary);
this.writeNode(node, "Literal", filter.lowerBoundary);
return node;
},
"UpperBoundary": function(rule) {
"UpperBoundary": function(filter) {
// no ogc:expression handling for now
var node = this.createElementNSPlus("ogc:UpperBoundary");
this.writeNode(node, "Literal", rule.upperBoundary);
this.writeNode(node, "Literal", filter.upperBoundary);
return node;
}
}
@@ -1006,17 +965,17 @@ OpenLayers.Format.SLD.v1 = OpenLayers.Class(OpenLayers.Format.XML, {
/**
* Method: getFilterType
*/
getFilterType: function(rule) {
var filterType = this.filterMap[rule.type];
getFilterType: function(filter) {
var filterType = this.filterMap[filter.type];
if(!filterType) {
throw "SLD writing not supported for rule type: " + rule.type;
throw "SLD writing not supported for rule type: " + filter.type;
}
return filterType;
},
/**
* 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.
*/
filterMap: {

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

@@ -250,7 +250,16 @@ OpenLayers.Popup.Framed =
createBlocks: function() {
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++) {
var block = {};
@@ -283,48 +292,49 @@ OpenLayers.Popup.Framed =
* the popup's blocks in their appropropriate places.
*/
updateBlocks: function() {
if (!this.blocks) {
this.createBlocks();
}
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];
// adjust sizes
var l = positionBlock.anchor.left;
var b = positionBlock.anchor.bottom;
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
// 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 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.left = (l != null) ? l + 'px' : '';
block.div.style.bottom = (b != null) ? b + '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';
if (this.relativePosition) {
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];
// adjust sizes
var l = positionBlock.anchor.left;
var b = positionBlock.anchor.bottom;
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
// 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 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.left = (l != null) ? l + 'px' : '';
block.div.style.bottom = (b != null) ? b + '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';
}
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"

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

@@ -37,10 +37,10 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
if (!this.supported()) {
return;
}
if (!document.namespaces.v) {
document.namespaces.add("v", this.xmlns);
if (!document.namespaces.olv) {
document.namespaces.add("olv", this.xmlns);
var style = document.createStyleSheet();
style.addRule('v\\:*', "behavior: url(#default#VML); " +
style.addRule('olv\\:*', "behavior: url(#default#VML); " +
"position: absolute; display: inline-block;");
}
OpenLayers.Renderer.Elements.prototype.initialize.apply(this,
@@ -120,17 +120,17 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
var nodeType = null;
switch (geometry.CLASS_NAME) {
case "OpenLayers.Geometry.Point":
nodeType = style.externalGraphic ? "v:rect" : "v:oval";
nodeType = style.externalGraphic ? "olv:rect" : "olv:oval";
break;
case "OpenLayers.Geometry.Rectangle":
nodeType = "v:rect";
nodeType = "olv:rect";
break;
case "OpenLayers.Geometry.LineString":
case "OpenLayers.Geometry.LinearRing":
case "OpenLayers.Geometry.Polygon":
case "OpenLayers.Geometry.Curve":
case "OpenLayers.Geometry.Surface":
nodeType = "v:shape";
nodeType = "olv:shape";
break;
default:
break;
@@ -195,7 +195,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
}
} else {
if (!fill) {
fill = this.createNode('v:fill', node.id + "_fill");
fill = this.createNode('olv:fill', node.id + "_fill");
}
fill.setAttribute("opacity", style.fillOpacity);
@@ -236,7 +236,7 @@ OpenLayers.Renderer.VML = OpenLayers.Class(OpenLayers.Renderer.Elements, {
}
} else {
if (!stroke) {
stroke = this.createNode('v:stroke', node.id + "_stroke");
stroke = this.createNode('olv:stroke', node.id + "_stroke");
node.appendChild(stroke);
}
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
*/
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
* 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({
@@ -45,6 +45,12 @@ OpenLayers.Rule = OpenLayers.Class({
* be used.
*/
context: null,
/**
* Property: filter
* {<OpenLayers.Filter>} Optional filter for the rule.
*/
filter: null,
/**
* Property: elseFilter
@@ -136,6 +142,16 @@ OpenLayers.Rule = OpenLayers.Class({
applies = scale < OpenLayers.Style.createLiteral(
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;
},

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;
}
}
/**
* IE doesn't include the toString property when iterating over an object's
* properties with the for(property in object) syntax. Explicitly check if
* 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;
}
}
@@ -510,9 +522,18 @@ OpenLayers.Util.upperCaseObject = function (object) {
* in place and returned by this function.
*/
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) {
if (to[key] === undefined ||
(from.hasOwnProperty
(!fromIsEvt && from.hasOwnProperty
&& from.hasOwnProperty(key) && !to.hasOwnProperty(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
* the source has its own toString property.
*/
if(from.hasOwnProperty
if(!fromIsEvt && from.hasOwnProperty
&& from.hasOwnProperty('toString') && !to.hasOwnProperty('toString')) {
to.toString = from.toString;
}