Pullup commits from trunk to 2.6 branch:

* 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
2008-04-08 01:51:04 +00:00
parent b9348dd5d5
commit 4085a2c220
29 changed files with 842 additions and 665 deletions
--- a/examples/georss-flickr.html
+++ b/examples/georss-flickr.html
@@ -31,28 +31,34 @@
            // the thumbail attribute of the rss item
            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
            // larger if the title of the rss item conatins "powder"
-            var rule = new OpenLayers.Rule.Comparison({
-                    type: OpenLayers.Rule.Comparison.LIKE,
+            var rule = new OpenLayers.Rule({
+                symbolizer: {pointRadius: 30},
+                filter: new OpenLayers.Filter.Comparison({
+                    type: OpenLayers.Filter.Comparison.LIKE,
                    property: "title",
-                    value: "*powder*",
-                    symbolizer: {"Point": {pointRadius: 30}}});
-            rule.value2regex("*");
+                    value: "*powder*"
+                })
+            });
+            rule.filter.value2regex("*");
            
            // If the above rule does not apply, use a smaller pointRadius.
            var elseRule = new OpenLayers.Rule({
-                    elseFilter: true,
-                    symbolizer: {"Point": {pointRadius: 20}}});
+                elseFilter: true,
+                symbolizer: {pointRadius: 20}
+            });
            
            style.addRules([rule, elseRule]);
            
-            markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({
-                "default": style,
-                "select": selectStyle})});
+            // Create a layer with a style map.  Giving the style map keys
+            // for "default" and "select" rendering intent.
+            markerLayer = new OpenLayers.Layer.Vector("", {
+                styleMap: new OpenLayers.StyleMap({
+                    "default": style,
+                    "select": new OpenLayers.Style({pointRadius: 35})
+                })
+            });
            map.addLayer(markerLayer);
            
            // control that will show a popup when clicking on a thumbnail
--- a/examples/spherical-mercator.html
+++ b/examples/spherical-mercator.html
@@ -121,7 +121,7 @@
            map.addControl(new OpenLayers.Control.EditingToolbar(vector));
            map.addControl(new OpenLayers.Control.Permalink());
            map.addControl(new OpenLayers.Control.MousePosition());
-            map.zoomToMaxExtent()
+            if (!map.getCenter()) {map.zoomToMaxExtent()}
        }

        function osm_getTileURL(bounds) {
--- a/examples/styles-context.html
+++ b/examples/styles-context.html
@@ -105,112 +105,4 @@
        on the context object passed to the Style constructor.</p>
    </div>
  </body>
-</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>
+</html>
--- a/lib/OpenLayers.js
+++ b/lib/OpenLayers.js
@@ -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",
--- a/lib/OpenLayers/Control/ModifyFeature.js
+++ b/lib/OpenLayers/Control/ModifyFeature.js
@@ -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;
--- a/lib/OpenLayers/Control/OverviewMap.js
+++ b/lib/OpenLayers/Control/OverviewMap.js
@@ -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,

--- a/lib/OpenLayers/Control/PanZoomBar.js
+++ b/lib/OpenLayers/Control/PanZoomBar.js
@@ -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);
    },
--- a/lib/OpenLayers/Filter.js
+++ b/lib/OpenLayers/Filter.js
@@ -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"
+});
--- a/lib/OpenLayers/Filter/Comparison.js
+++ b/lib/OpenLayers/Filter/Comparison.js
@@ -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                     = "~";
--- a/lib/OpenLayers/Filter/FeatureId.js
+++ b/lib/OpenLayers/Filter/FeatureId.js
@@ -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"
 });
--- a/lib/OpenLayers/Filter/Logical.js
+++ b/lib/OpenLayers/Filter/Logical.js
@@ -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 = "!";
--- a/lib/OpenLayers/Format/JSON.js
+++ b/lib/OpenLayers/Format/JSON.js
@@ -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
--- a/lib/OpenLayers/Format/SLD/v1.js
+++ b/lib/OpenLayers/Format/SLD/v1.js
@@ -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: {
--- a/lib/OpenLayers/Popup/Framed.js
+++ b/lib/OpenLayers/Popup/Framed.js
@@ -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"
--- a/lib/OpenLayers/Renderer/VML.js
+++ b/lib/OpenLayers/Renderer/VML.js
@@ -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");
    },

    /**************************************
--- a/lib/OpenLayers/Rule.js
+++ b/lib/OpenLayers/Rule.js
@@ -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;
    },
--- a/lib/OpenLayers/Rule/Logical.js
+++ b/lib/OpenLayers/Rule/Logical.js
@@ -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 = "!";
--- a/lib/OpenLayers/Util.js
+++ b/lib/OpenLayers/Util.js
@@ -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;
    }
--- a/tests/Control/PanZoomBar.html
+++ b/tests/Control/PanZoomBar.html
@@ -33,6 +33,23 @@
        map.addControl(control2, new OpenLayers.Pixel(100,100));
        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>
 </head>
--- a/tests/Filter.html
+++ b/tests/Filter.html
@@ -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> 
--- a/tests/Filter/Comparison.html
+++ b/tests/Filter/Comparison.html
@@ -7,41 +7,41 @@
        t.plan(3); 
         
        var options = {'foo': 'bar'}; 
-        var rule = new OpenLayers.Rule.Comparison(options); 
-        t.ok(rule instanceof OpenLayers.Rule.Comparison, 
-             "new OpenLayers.Rule.Comparison returns object" ); 
-        t.eq(rule.foo, "bar", "constructor sets options correctly"); 
-        t.eq(typeof rule.evaluate, "function", "rule has an evaluate function"); 
+        var filter = new OpenLayers.Filter.Comparison(options); 
+        t.ok(filter instanceof OpenLayers.Filter.Comparison, 
+             "new OpenLayers.Filter.Comparison returns object" ); 
+        t.eq(filter.foo, "bar", "constructor sets options correctly"); 
+        t.eq(typeof filter.evaluate, "function", "filter has an evaluate function"); 
    }

    function test_Comparison_destroy(t) {
        t.plan(1);
        
-        var rule = new OpenLayers.Rule.Comparison();
-        rule.destroy();
-        t.eq(rule.symbolizer, null, "symbolizer hash nulled properly");
+        var filter = new OpenLayers.Filter.Comparison();
+        filter.destroy();
+        t.eq(filter.symbolizer, null, "symbolizer hash nulled properly");
    }
    
    function test_Comparison_value2regex(t) {
        t.plan(2);
        
-        var rule = new OpenLayers.Rule.Comparison({
+        var filter = new OpenLayers.Filter.Comparison({
                property: "foo",
                value: "*b?r\\*\\?*",
-                type: OpenLayers.Rule.Comparison.LIKE});
-        rule.value2regex("*", "?", "\\");
-        t.eq(rule.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
+                type: OpenLayers.Filter.Comparison.LIKE});
+        filter.value2regex("*", "?", "\\");
+        t.eq(filter.value, ".*b.r\\*\\?.*", "Regular expression generated correctly.");
        
-        rule.value = "%b.r!%!.%";
-        rule.value2regex("%", ".", "!");
-        t.eq(rule.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly.");
+        filter.value = "%b.r!%!.%";
+        filter.value2regex("%", ".", "!");
+        t.eq(filter.value, ".*b.r\\%\\..*", "Regular expression with different wildcard and escape chars generated correctly.");
    }
    
    function test_regex2value(t) {
        t.plan(8);
        
        function r2v(regex) {
-            return OpenLayers.Rule.Comparison.prototype.regex2value.call(
+            return OpenLayers.Filter.Comparison.prototype.regex2value.call(
                {value: regex}
            );
        }
@@ -60,11 +60,11 @@
    function test_Comparison_evaluate(t) {
        t.plan(5);
        
-        var rule = new OpenLayers.Rule.Comparison({
+        var filter = new OpenLayers.Filter.Comparison({
                property: "area",
                lowerBoundary: 1000,
                upperBoundary: 4999,
-                type: OpenLayers.Rule.Comparison.BETWEEN});
+                type: OpenLayers.Filter.Comparison.BETWEEN});

        var features = [
                new OpenLayers.Feature.Vector(null, {
@@ -76,21 +76,21 @@
                new OpenLayers.Feature.Vector(null, {
                        area: 5000})];
        // PropertyIsBetween filter: lower and upper boundary are inclusive
-        var ruleResults = {
+        var filterResults = {
                0: false,
                1: true,
                2: true,
                3: false};
-        for (var i in ruleResults) {
-            var result = rule.evaluate(features[i]);
-            t.eq(result, ruleResults[i], "feature "+i+
+        for (var i in filterResults) {
+            var result = filter.evaluate(features[i].attributes);
+            t.eq(result, filterResults[i], "feature "+i+
                    " evaluates to "+result.toString()+" correctly.");
        }
-        rule.context = {
+        var context = {
            area: 4998
-        }
-        var result = rule.evaluate();
-        t.eq(result, true, "evaluation against custom rule context works.");
+        };
+        var result = filter.evaluate(context);
+        t.eq(result, true, "evaluation against custom filter context works.");
    }
    </script> 
 </head> 
--- a/tests/Filter/FeatureId.html
+++ b/tests/Filter/FeatureId.html
@@ -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> 
--- a/tests/Filter/Logical.html
+++ b/tests/Filter/Logical.html
@@ -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> 
--- a/tests/Format/SLD/v1_0_0.html
+++ b/tests/Format/SLD/v1_0_0.html
@@ -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> 
--- a/tests/Popup/FramedCloud.html
+++ b/tests/Popup/FramedCloud.html
@@ -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>
--- a/tests/Rule/FeatureId.html
+++ b/tests/Rule/FeatureId.html
@@ -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> 
--- a/tests/Rule/Logical.html
+++ b/tests/Rule/Logical.html
@@ -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> 
--- a/tests/Style.html
+++ b/tests/Style.html
@@ -27,20 +27,29 @@
        
        var style = new OpenLayers.Style(baseStyle);
        
-        var rule1 = new OpenLayers.Rule.FeatureId({
-                fids: ["1"],
-                symbolizer: {"Point": {fillColor: "green"}},
-                maxScaleDenominator: 500000});
-        var rule2 = new OpenLayers.Rule.FeatureId({
-                fids: ["1"],
-                symbolizer: {"Point": {fillColor: "yellow"}},
-                minScaleDenominator: 500000,
-                maxScaleDenominator: 1000000});
-        var rule3 = new OpenLayers.Rule.FeatureId({
-                fids: ["1"],
-                symbolizer: {"Point": {fillColor: "red"}},
-                minScaleDenominator: 1000000,
-                maxScaleDenominator: 2500000});
+        var rule1 = new OpenLayers.Rule({
+            symbolizer: {"Point": {fillColor: "green"}},
+            maxScaleDenominator: 500000,
+            filter: new OpenLayers.Filter.FeatureId({
+                fids: ["1"]
+            })
+        });
+        var rule2 = new OpenLayers.Rule({
+            symbolizer: {"Point": {fillColor: "yellow"}},
+            minScaleDenominator: 500000,
+            maxScaleDenominator: 1000000,
+            filter: new OpenLayers.Filter.FeatureId({
+                fids: ["1"]
+            })
+        });
+        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(
                new OpenLayers.Geometry.Point(3,5),
@@ -119,11 +128,14 @@
    
    function test_Style_context(t) {
        t.plan(1);
-        var rule = new OpenLayers.Rule.Comparison({
-            type: OpenLayers.Rule.Comparison.LESS_THAN,
-            property: "size",
-            value: 11,
-            symbolizer: {"Point": {externalGraphic: "${img1}"}}});
+        var rule = new OpenLayers.Rule({
+            symbolizer: {"Point": {externalGraphic: "${img1}"}},
+            filter: new OpenLayers.Filter.Comparison({
+                type: OpenLayers.Filter.Comparison.LESS_THAN,
+                property: "size",
+                value: 11
+            })
+        });
        var style = new OpenLayers.Style();
        style.context = {
            "img1": "myImage.png"
--- a/tests/list-tests.html
+++ b/tests/list-tests.html
@@ -29,6 +29,7 @@
    <li>Format/OSM.html</li>
    <li>Format/KML.html</li>
    <li>Format/SLD.html</li>
+    <li>Format/SLD/v1_0_0.html</li>
    <li>Format/WKT.html</li>
    <li>Format/WMC.html</li>
    <li>Format/WMC/v1_1_0.html</li>
@@ -40,14 +41,16 @@
    <li>Popup.html</li>
    <li>Popup/Anchored.html</li>
    <li>Popup/AnchoredBubble.html</li>
+    <li>Popup/FramedCloud.html</li>
    <li>Feature.html</li>
    <li>Feature/Vector.html</li>
    <li>Style.html</li>
    <li>StyleMap.html</li>
    <li>Rule.html</li>
-    <li>Rule/Comparison.html</li>
-    <li>Rule/FeatureId.html</li>
-    <li>Rule/Logical.html</li>
+    <li>Filter.html</li>
+    <li>Filter/Comparison.html</li>
+    <li>Filter/FeatureId.html</li>
+    <li>Filter/Logical.html</li>
    <li>Events.html</li>
    <li>Util.html</li>
    <li>Lang.html</li>