OpenLayers OpenLayers

Changeset 6819

Show
Ignore:
Timestamp:
04/07/08 21:51:04 (9 months ago)
Author:
crschmidt
Message:

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)
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/openlayers/2.6/examples/georss-flickr.html

    r6240 r6819  
    3232            style = new OpenLayers.Style({externalGraphic: "${thumbnail}"}); 
    3333             
    34             // make the thumbnails larger when we select them 
    35             selectStyle = new OpenLayers.Style({pointRadius: 35}); 
    36              
    3734            // create a rule with a point symbolizer that will make the thumbnail 
    3835            // larger if the title of the rss item conatins "powder" 
    39             var rule = new OpenLayers.Rule.Comparison({ 
    40                     type: OpenLayers.Rule.Comparison.LIKE, 
     36            var rule = new OpenLayers.Rule({ 
     37                symbolizer: {pointRadius: 30}, 
     38                filter: new OpenLayers.Filter.Comparison({ 
     39                    type: OpenLayers.Filter.Comparison.LIKE, 
    4140                    property: "title", 
    42                     value: "*powder*", 
    43                     symbolizer: {"Point": {pointRadius: 30}}}); 
    44             rule.value2regex("*"); 
     41                    value: "*powder*" 
     42                }) 
     43            }); 
     44            rule.filter.value2regex("*"); 
    4545             
    4646            // If the above rule does not apply, use a smaller pointRadius. 
    4747            var elseRule = new OpenLayers.Rule({ 
    48                     elseFilter: true, 
    49                     symbolizer: {"Point": {pointRadius: 20}}}); 
     48                elseFilter: true, 
     49                symbolizer: {pointRadius: 20} 
     50            }); 
    5051             
    5152            style.addRules([rule, elseRule]); 
    5253             
    53             markerLayer = new OpenLayers.Layer.Vector("", {styleMap: new OpenLayers.StyleMap({ 
    54                 "default": style, 
    55                 "select": selectStyle})}); 
     54            // Create a layer with a style map.  Giving the style map keys 
     55            // for "default" and "select" rendering intent. 
     56            markerLayer = new OpenLayers.Layer.Vector("", { 
     57                styleMap: new OpenLayers.StyleMap({ 
     58                    "default": style, 
     59                    "select": new OpenLayers.Style({pointRadius: 35}) 
     60                }) 
     61            }); 
    5662            map.addLayer(markerLayer); 
    5763             

  • branches/openlayers/2.6/examples/spherical-mercator.html

    r6497 r6819  
    122122            map.addControl(new OpenLayers.Control.Permalink()); 
    123123            map.addControl(new OpenLayers.Control.MousePosition()); 
    124             map.zoomToMaxExtent() 
     124            if (!map.getCenter()) {map.zoomToMaxExtent()} 
    125125        } 
    126126 

  • branches/openlayers/2.6/examples/styles-context.html

    r6512 r6819  
    107107  </body> 
    108108</html> 
    109 <html xmlns="http://www.w3.org/1999/xhtml"> 
    110   <head> 
    111     <title>OpenLayers Vector Styles</title> 
    112     <link rel="stylesheet" href="../theme/default/style.css" type="text/css" /> 
    113     <style type="text/css"> 
    114         #map { 
    115             width: 800px; 
    116             height: 400px; 
    117             border: 1px solid black; 
    118         } 
    119     </style> 
    120     <script src="../lib/OpenLayers.js"></script> 
    121     <script type="text/javascript"> 
    122         var map; 
    123  
    124         function init(){ 
    125             map = new OpenLayers.Map('map', {maxResolution:'auto'}); 
    126             var wms = new OpenLayers.Layer.WMS( "OpenLayers WMS", 
    127                 "http://labs.metacarta.com/wms/vmap0", {layers: 'basic'} ); 
    128             map.addLayer(wms); 
    129             map.setCenter(new OpenLayers.LonLat(0, 0), 0); 
    130              
    131             // Strategy 1:  Style features based on some attribute. 
    132              
    133             // create 50 random features in the northern hemisphere 
    134             // give them a "type" attribute that will be used to style 
    135             // them by size 
    136             var features = new Array(50); 
    137             for (var i=0; i<features.length; i++) { 
    138                 features[i] = new OpenLayers.Feature.Vector( 
    139                     new OpenLayers.Geometry.Point( 
    140                         (360 * Math.random()) - 180, 90 * Math.random() 
    141                     ), { 
    142                         type: 5 + parseInt(5 * Math.random()) 
    143                     } 
    144                 ); 
    145             } 
    146              
    147             // create the layer styleMap with a simple symbolizer template 
    148             var layer1 = new OpenLayers.Layer.Vector('Points', { 
    149                 styleMap: new OpenLayers.StyleMap({ 
    150                     pointRadius: "${type}", // based on feature.attributes.type 
    151                     fillColor: "#666666" 
    152                 }) 
    153             }); 
    154             layer1.addFeatures(features); 
    155  
    156             // Strategy 2:  Style features based on something besides attributes. 
    157  
    158             // create 50 random features in the southern hemisphere 
    159             var features = new Array(50); 
    160             for (var i=0; i<features.length; i++) { 
    161                 features[i] = new OpenLayers.Feature.Vector( 
    162                     new OpenLayers.Geometry.Point( 
    163                         (360 * Math.random()) - 180, -90 * Math.random() 
    164                     ), { 
    165                         type: 5 + parseInt(5 * Math.random()) 
    166                     } 
    167                 ); 
    168             } 
    169             // create the layer styleMap by giving the default style a context 
    170             var colors = ["red", "green", "blue"]; 
    171             var context = { 
    172                 getColor: function(feature) { 
    173                     var region = parseInt((feature.geometry.x + 180) / 120); 
    174                     return colors[region]; 
    175                 }, 
    176                 getType: function(feature) { 
    177                     return feature.attributes["type"]; 
    178                 } 
    179             }; 
    180             var template = { 
    181                 pointRadius: "${getType}", // using context.getType(feature) 
    182                 fillColor: "${getColor}" // using context.getColor(feature) 
    183             }; 
    184             var style = new OpenLayers.Style(template, {context: context}); 
    185             var layer2 = new OpenLayers.Layer.Vector('Points', { 
    186                 styleMap: new OpenLayers.StyleMap(style) 
    187             }); 
    188             layer2.addFeatures(features); 
    189  
    190  
    191             map.addLayers([layer1, layer2]); 
    192         } 
    193     </script> 
    194   </head> 
    195   <body onload="init()"> 
    196     <h1 id="title">Feature Styles Example</h1> 
    197  
    198     <div id="tags"></div> 
    199  
    200     <p id="shortdesc"> 
    201         Shows how to create a feature styles. 
    202     </p> 
    203  
    204     <div id="map"></div> 
    205  
    206     <div id="docs"> 
    207         <p>Features in the northern hemisphere are styled according to their 
    208         "type" attribute.  This is accomplished with a simple template that 
    209         is evaluated with the feature attributes as context.</p> 
    210         <p>Features in the sourthern hemisphere are styled according to a 
    211         combination of their attributes and non-attribute properties.  This 
    212         is accomplished using an advanced template that calls functions 
    213         on the context object passed to the Style constructor.</p> 
    214     </div> 
    215   </body> 
    216 </html> 

  • branches/openlayers/2.6/lib/OpenLayers.js

    r6718 r6819  
    184184            "OpenLayers/StyleMap.js", 
    185185            "OpenLayers/Rule.js", 
    186             "OpenLayers/Rule/FeatureId.js", 
    187             "OpenLayers/Rule/Logical.js", 
    188             "OpenLayers/Rule/Comparison.js", 
     186            "OpenLayers/Filter.js", 
     187            "OpenLayers/Filter/FeatureId.js", 
     188            "OpenLayers/Filter/Logical.js", 
     189            "OpenLayers/Filter/Comparison.js", 
    189190            "OpenLayers/Format.js", 
    190191            "OpenLayers/Format/XML.js", 

  • branches/openlayers/2.6/lib/OpenLayers/Control/ModifyFeature.js

    r6748 r6819  
    180180        this.vertices = []; 
    181181        this.virtualVertices = []; 
    182         this.styleVirtual = OpenLayers.Util.extend({}, 
     182        this.virtualStyle = OpenLayers.Util.extend({}, 
    183183            this.layer.style || this.layer.styleMap.createSymbolizer()); 
    184         this.styleVirtual.fillOpacity = 0.3; 
    185         this.styleVirtual.strokeOpacity = 0.3; 
     184        this.virtualStyle.fillOpacity = 0.3; 
     185        this.virtualStyle.strokeOpacity = 0.3; 
    186186        this.deleteCodes = [46, 100]; 
    187187        this.mode = OpenLayers.Control.ModifyFeature.RESHAPE; 
    …… 
    565565                            var point = new OpenLayers.Feature.Vector( 
    566566                                new OpenLayers.Geometry.Point(x, y), 
    567                                 null, control.styleVirtual 
     567                                null, control.virtualStyle 
    568568                            ); 
    569569                            // set the virtual parent and intended index 

  • branches/openlayers/2.6/lib/OpenLayers/Control/OverviewMap.js

    r6727 r6819  
    2828    /** 
    2929     * APIProperty: ovmap 
    30      * {<OpenLayers.Map>} A reference to the overvew map itself. 
     30     * {<OpenLayers.Map>} A reference to the overview map itself. 
    3131     */ 
    3232    ovmap: null, 

  • branches/openlayers/2.6/lib/OpenLayers/Control/PanZoomBar.js

    r6516 r6819  
    243243        var top = OpenLayers.Util.pagePosition(evt.object)[1]; 
    244244        var levels = (y - top)/this.zoomStopHeight; 
     245        if(!this.map.fractionalZoom) { 
     246            levels = Math.floor(levels); 
     247        }     
    245248        var zoom = (this.map.getNumZoomLevels() - 1) - levels;  
    246         if(this.map.fractionalZoom) { 
    247            zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1); 
    248         } else { 
    249             zoom = Math.floor(zoom); 
    250         }     
     249        zoom = Math.min(Math.max(zoom, 0), this.map.getNumZoomLevels() - 1); 
    251250        this.map.zoomTo(zoom); 
    252251        OpenLayers.Event.stop(evt); 

  • branches/openlayers/2.6/lib/OpenLayers/Format/JSON.js

    r6430 r6819  
    9696         */ 
    9797        try { 
    98             if(/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/. 
    99                     test(json)) { 
     98            if (/^[\],:{}\s]*$/.test(json.replace(/\\["\\\/bfnrtu]/g, '@'). 
     99                                replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']'). 
     100                                replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { 
    100101 
    101102                /** 

  • branches/openlayers/2.6/lib/OpenLayers/Format/SLD/v1.js

    r6748 r6819  
    143143            }, 
    144144            "Rule": function(node, obj) { 
    145                 // Rule elements are represented as OpenLayers.Rule instances. 
    146                 // Filter elements are represented as instances of 
    147                 // OpenLayers.Rule subclasses. 
    148                 var config = { 
    149                     rules: [], 
    150                     symbolizer: {} 
    151                 }; 
    152                 this.readChildNodes(node, config); 
    153                 // Now we've either got zero or one rules (from filters) 
    154                 var rule; 
    155                 if(config.rules.length == 0) { 
    156                     delete config.rules; 
    157                     rule = new OpenLayers.Rule(config); 
    158                 } else { 
    159                     rule = config.rules[0]; 
    160                     delete config.rules; 
    161                     OpenLayers.Util.extend(rule, config); 
    162                 } 
     145                var rule = new OpenLayers.Rule(); 
     146                this.readChildNodes(node, rule); 
    163147                obj.rules.push(rule); 
    164148            }, 
    …… 
    284268        "ogc": { 
    285269            "Filter": function(node, rule) { 
    286                 // Filters correspond to subclasses of OpenLayers.Rule. 
     270                // Filters correspond to subclasses of OpenLayers.Filter. 
    287271                // Since they contain information we don't persist, we 
    288                 // create a temporary object and then pass on the rules 
     272                // create a temporary object and then pass on the filter 
    289273                // (ogc:Filter) to the parent rule (sld:Rule). 
    290                 var filter = { 
     274                var obj = { 
    291275                    fids: [], 
    292                     rules: [] 
     276                    filters: [] 
    293277                }; 
    294                 this.readChildNodes(node, filter); 
    295                 if(filter.fids.length > 0) { 
    296                     rule.rules.push(new OpenLayers.Rule.FeatureId({ 
    297                         fids: filter.fids 
    298                     })); 
    299                 } 
    300                 if(filter.rules.length > 0) { 
    301                     rule.rules = rule.rules.concat(filter.rules); 
    302                 } 
    303             }, 
    304             "FeatureId": function(node, filter) { 
     278                this.readChildNodes(node, obj); 
     279                if(obj.fids.length > 0) { 
     280                    rule.filter = new OpenLayers.Filter.FeatureId({ 
     281                        fids: obj.fids 
     282                    }); 
     283                } else if(obj.filters.length > 0) { 
     284                    rule.filter = obj.filters[0]; 
     285                } 
     286            }, 
     287            "FeatureId": function(node, obj) { 
    305288                var fid = node.getAttribute("fid"); 
    306289                if(fid) { 
    307                     filter.fids.push(fid); 
    308                 } 
    309             }, 
    310             "And": function(node, filter) { 
    311                 var rule = new OpenLayers.Rule.Logical({ 
    312                     type: OpenLayers.Rule.Logical.AND 
    313                 }); 
    314                 // since FeatureId rules may be nested here, make room for them 
    315                 rule.fids = []; 
    316                 this.readChildNodes(node, rule); 
    317                 if(rule.fids.length > 0) { 
    318                     rule.rules.push(new OpenLayers.Rule.FeatureId({ 
    319                         fids: rule.fids 
    320                     })); 
    321                 } 
    322                 delete rule.fids; 
    323                 filter.rules.push(rule); 
    324             }, 
    325             "Or": function(node, filter) { 
    326                 var rule = new OpenLayers.Rule.Logical({ 
    327                     type: OpenLayers.Rule.Logical.OR 
    328                 }); 
    329                 // since FeatureId rules may be nested here, make room for them 
    330                 rule.fids = []; 
    331                 this.readChildNodes(node, rule); 
    332                 if(rule.fids.length > 0) { 
    333                     rule.rules.push(new OpenLayers.Rule.FeatureId({ 
    334                         fids: rule.fids 
    335                     })); 
    336                 } 
    337                 delete rule.fids; 
    338                 filter.rules.push(rule); 
    339             }, 
    340             "Not": function(node, filter) { 
    341                 var rule = new OpenLayers.Rule.Logical({ 
    342                     type: OpenLayers.Rule.Logical.NOT 
    343                 }); 
    344                 // since FeatureId rules may be nested here, make room for them 
    345                 rule.fids = []; 
    346                 this.readChildNodes(node, rule); 
    347                 if(rule.fids.length > 0) { 
    348                     rule.rules.push(new OpenLayers.Rule.FeatureId({ 
    349                         fids: rule.fids 
    350                     })); 
    351                 } 
    352                 delete rule.fids; 
    353                 filter.rules.push(rule); 
    354             }, 
    355             "PropertyIsEqualTo": function(node, filter) { 
    356                 var rule = new OpenLayers.Rule.Comparison({ 
    357                     type: OpenLayers.Rule.Comparison.EQUAL_TO 
    358                 }); 
    359                 this.readChildNodes(node, rule); 
    360                 filter.rules.push(rule); 
    361             }, 
    362             "PropertyIsNotEqualTo": function(node, filter) { 
    363                 var rule = new OpenLayers.Rule.Comparison({ 
    364                     type: OpenLayers.Rule.Comparison.NOT_EQUAL_TO 
    365                 }); 
    366                 this.readChildNodes(node, rule); 
    367                 filter.rules.push(rule); 
    368             }, 
    369             "PropertyIsLessThan": function(node, filter) { 
    370                 var rule = new OpenLayers.Rule.Comparison({ 
    371                     type: OpenLayers.Rule.Comparison.LESS_THAN 
    372                 }); 
    373                 this.readChildNodes(node, rule); 
    374                 filter.rules.push(rule); 
    375             }, 
    376             "PropertyIsGreaterThan": function(node, filter) { 
    377                 var rule = new OpenLayers.Rule.Comparison({ 
    378                     type: OpenLayers.Rule.Comparison.GREATER_THAN 
    379                 }); 
    380                 this.readChildNodes(node, rule); 
    381                 filter.rules.push(rule); 
    382             }, 
    383             "PropertyIsLessThanOrEqualTo": function(node, filter) { 
    384                 var rule = new OpenLayers.Rule.Comparison({ 
    385                     type: OpenLayers.Rule.Comparison.LESS_THAN_OR_EQUAL_TO 
    386                 }); 
    387                 this.readChildNodes(node, rule); 
    388                 filter.rules.push(rule); 
    389             }, 
    390             "PropertyIsGreaterThanOrEqualTo": function(node, filter) { 
    391                 var rule = new OpenLayers.Rule.Comparison({ 
    392                     type: OpenLayers.Rule.Comparison.GREATER_THAN_OR_EQUAL_TO 
    393                 }); 
    394                 this.readChildNodes(node, rule); 
    395                 filter.rules.push(rule); 
    396             }, 
    397             "PropertyIsBetween": function(node, filter) { 
    398                 var rule = new OpenLayers.Rule.Comparison({ 
    399                     type: OpenLayers.Rule.Comparison.BETWEEN 
    400                 }); 
    401                 this.readChildNodes(node, rule); 
    402                 filter.rules.push(rule); 
    403             }, 
    404             "PropertyIsLike": function(node, filter) { 
    405                 var rule = new OpenLayers.Rule.Comparison({ 
    406                     type: OpenLayers.Rule.Comparison.LIKE 
    407                 }); 
    408                 this.readChildNodes(node, rule); 
     290                    obj.fids.push(fid); 
     291                } 
     292            }, 
     293            "And": function(node, obj) { 
     294                var filter = new OpenLayers.Filter.Logical({ 
     295                    type: OpenLayers.Filter.Logical.AND 
     296                }); 
     297                this.readChildNodes(node, filter); 
     298                obj.filters.push(filter); 
     299            }, 
     300            "Or": function(node, obj) { 
     301                var filter = new OpenLayers.Filter.Logical({ 
     302                    type: OpenLayers.Filter.Logical.OR 
     303                }); 
     304                this.readChildNodes(node, filter); 
     305                obj.filters.push(filter); 
     306            }, 
     307            "Not": function(node, obj) { 
     308                var filter = new OpenLayers.Filter.Logical({ 
     309                    type: OpenLayers.Filter.Logical.NOT 
     310                }); 
     311                this.readChildNodes(node, filter); 
     312                obj.filters.push(filter); 
     313            }, 
     314            "PropertyIsEqualTo": function(node, obj) { 
     315                var filter = new OpenLayers.Filter.Comparison({ 
     316                    type: OpenLayers.Filter.Comparison.EQUAL_TO 
     317                }); 
     318                this.readChildNodes(node, filter); 
     319                obj.filters.push(filter); 
     320            }, 
     321            "PropertyIsNotEqualTo": function(node, obj) { 
     322                var filter = new OpenLayers.Filter.Comparison({ 
     323                    type: OpenLayers.Filter.Comparison.NOT_EQUAL_TO 
     324                }); 
     325                this.readChildNodes(node, filter); 
     326                obj.filters.push(filter); 
     327            }, 
     328            "PropertyIsLessThan": function(node, obj) { 
     329                var filter = new OpenLayers.Filter.Comparison({ 
     330                    type: OpenLayers.Filter.Comparison.LESS_THAN 
     331                }); 
     332                this.readChildNodes(node, filter); 
     333                obj.filters.push(filter); 
     334            }, 
     335            "PropertyIsGreaterThan": function(node, obj) { 
     336                var filter = new OpenLayers.Filter.Comparison({ 
     337                    type: OpenLayers.Filter.Comparison.GREATER_THAN 
     338                }); 
     339                this.readChildNodes(node, filter); 
     340                obj.filters.push(filter); 
     341            }, 
     342            "PropertyIsLessThanOrEqualTo": function(node, obj) { 
     343                var filter = new OpenLayers.Filter.Comparison({ 
     344                    type: OpenLayers.Filter.Comparison.LESS_THAN_OR_EQUAL_TO 
     345                }); 
     346                this.readChildNodes(node, filter); 
     347                obj.filters.push(filter); 
     348            }, 
     349            "PropertyIsGreaterThanOrEqualTo": function(node, obj) { 
     350                var filter = new OpenLayers.Filter.Comparison({ 
     351                    type: OpenLayers.Filter.Comparison.GREATER_THAN_OR_EQUAL_TO 
     352                }); 
     353                this.readChildNodes(node, filter); 
     354                obj.filters.push(filter); 
     355            }, 
     356            "PropertyIsBetween": function(node, obj) { 
     357                var filter = new OpenLayers.Filter.Comparison({ 
     358                    type: OpenLayers.Filter.Comparison.BETWEEN 
     359                }); 
     360                this.readChildNodes(node, filter); 
     361                obj.filters.push(filter); 
     362            }, 
     363            "PropertyIsLike": function(node, obj) { 
     364                var filter = new OpenLayers.Filter.Comparison({ 
     365                    type: OpenLayers.Filter.Comparison.LIKE 
     366                }); 
     367                this.readChildNodes(node, filter); 
    409368                var wildCard = node.getAttribute("wildCard"); 
    410369                var singleChar = node.getAttribute("singleChar"); 
    411370                var esc = node.getAttribute("escape"); 
    412                 rule.value2regex(wildCard, singleChar, esc); 
    413                 filter.rules.push(rule); 
     371                filter.value2regex(wildCard, singleChar, esc); 
     372                obj.filters.push(filter); 
    414373            }, 
    415374            "Literal": function(node, obj) { 
    416375                obj.value = this.getChildValue(node); 
    417376            }, 
    418             "PropertyName": function(node, rule) { 
    419                 rule.property = this.getChildValue(node); 
    420             }, 
    421             "LowerBoundary": function(node, rule) { 
    422                 rule.lowerBoundary = this.readOgcExpression(node); 
    423             }, 
    424             "UpperBoundary": function(node, rule) { 
    425                 rule.upperBoundary = this.readOgcExpression(node); 
     377            "PropertyName": function(node, filter) { 
     378                filter.property = this.getChildValue(node); 
     379            }, 
     380            "LowerBoundary": function(node, filter) { 
     381                filter.lowerBoundary = this.readOgcExpression(node); 
     382            }, 
     383            "UpperBoundary": function(node, filter) { 
     384                filter.upperBoundary = this.readOgcExpression(node); 
    426385            } 
    427386        } 
    …… 
    683642                if(rule.elseFilter) { 
    684643                    this.writeNode(node, "ElseFilter"); 
    685                 } else if(rule.CLASS_NAME != "OpenLayers.Rule") { 
    686                     this.writeNode(node, "ogc:Filter", rule); 
     644                } else if(rule.filter) { 
     645                    this.writeNode(node, "ogc:Filter", rule.filter); 
    687646                } 
    688647                 
    …… 
    868827        }, 
    869828        "ogc": { 
    870             "Filter": function(rule) { 
     829            "Filter": function(filter) { 
    871830                var node = this.createElementNSPlus("ogc:Filter"); 
    872                 var sub = rule.CLASS_NAME.split(".").pop(); 
     831                var sub = filter.CLASS_NAME.split(".").pop(); 
    873832                if(sub == "FeatureId") { 
    874                     for(var i=0; i<rule.fids.length; ++i) { 
    875                         this.writeNode(node, "FeatureId", rule.fids[i]); 
     833                    for(var i=0; i<filter.fids.length; ++i) { 
     834                        this.writeNode(node, "FeatureId", filter.fids[i]); 
    876835                    } 
    877836                } else { 
    878                     this.writeNode(node, this.getFilterType(rule), rule); 
     837                    this.writeNode(node, this.getFilterType(filter), filter); 
    879838                } 
    880839                return node; 
    …… 
    885844                }); 
    886845            }, 
    887             "And": function(rule) { 
     846            "And": function(filter) { 
    888847                var node = this.createElementNSPlus("ogc:And"); 
    889                 var childRule; 
    890                 for(var i=0; i<rule.rules.length; ++i) { 
    891                     childRule = rule.rules[i]; 
     848                var childFilter; 
     849                for(var i=0; i<filter.filters.length; ++i) { 
     850                    childFilter = filter.filters[i]; 
    892851                    this.writeNode( 
    893                         node, this.getFilterType(childRule), childRule 
     852                        node, this.getFilterType(childFilter), childFilter 
    894853                    ); 
    895854                } 
    896855                return node; 
    897856            }, 
    898             "Or": function(rule) { 
     857            "Or": function(filter) { 
    899858                var node = this.createElementNSPlus("ogc:Or"); 
    900                 var childRule; 
    901                 for(var i=0; i<rule.rules.length; ++i) { 
    902                     childRule = rule.rules[i]; 
     859                var childFilter; 
     860                for(var i=0; i<filter.filters.length; ++i) { 
     861                    childFilter = filter.filters[i]; 
    903862                    this.writeNode( 
    904                         node, this.getFilterType(childRule), childRule 
     863                        node, this.getFilterType(childFilter), childFilter 
    905864                    ); 
    906865                } 
    907866                return node; 
    908867            }, 
    909             "Not": function(rule) { 
     868            "Not": function(filter) { 
    910869                var node = this.createElementNSPlus("ogc:Not"); 
    911                 var childRule = rule.rules[0]; 
     870                var childFilter = filter.filters[0]; 
    912871                this.writeNode( 
    913                     node, this.getFilterType(childRule), childRule 
     872                    node, this.getFilterType(childFilter), childFilter 
    914873                ); 
    915874                return node; 
    916875            }, 
    917             "PropertyIsEqualTo": function(rule) { 
     876            "PropertyIsEqualTo": function(filter) { 
    918877                var node = this.createElementNSPlus("ogc:PropertyIsEqualTo"); 
    919878                // no ogc:expression handling for now 
    920                 this.writeNode(node, "PropertyName", rule); 
    921                 this.writeNode(node, "Literal", rule); 
    922                 return node; 
    923             }, 
    924             "PropertyIsNotEqualTo": function(rule) { 
     879                this.writeNode(node, "PropertyName", filter); 
     880                this.writeNode(node, "Literal", filter.value); 
     881                return node; 
     882            }, 
     883            "PropertyIsNotEqualTo": function(filter) { 
    925884                var node = this.createElementNSPlus("ogc:PropertyIsNotEqualTo"); 
    926885                // no ogc:expression handling for now 
    927                 this.writeNode(node, "PropertyName", rule); 
    928                 this.writeNode(node, "Literal", rule); 
    929                 return node; 
    930             }, 
    931             "PropertyIsLessThan": function(rule) { 
     886                this.writeNode(node, "PropertyName", filter); 
     887                this.writeNode(node, "Literal", filter.value); 
     888                return node; 
     889            }, 
     890            "PropertyIsLessThan": function(filter) { 
    932891                var node = this.createElementNSPlus("ogc:PropertyIsLessThan"); 
    933892                // no ogc:expression handling for now 
    934                 this.writeNode(node, "PropertyName", rule); 
    935                 this.writeNode(node, "Literal", rule);                 
    936                 return node; 
    937             }, 
    938             "PropertyIsGreaterThan": function(rule) { 
     893                this.writeNode(node, "PropertyName", filter); 
     894                this.writeNode(node, "Literal", filter.value);                 
     895                return node; 
     896            }, 
     897            "PropertyIsGreaterThan": function(filter) { 
    939898                var node = this.createElementNSPlus("ogc:PropertyIsGreaterThan"); 
    940899                // no ogc:expression handling for now 
    941                 this.writeNode(node, "PropertyName", rule); 
    942                 this.writeNode(node, "Literal", rule); 
    943                 return node; 
    944             }, 
    945             "PropertyIsLessThanOrEqualTo": function(rule) { 
     900                this.writeNode(node, "PropertyName", filter); 
     901                this.writeNode(node, "Literal", filter.value); 
     902                return node; 
     903            }, 
     904            "PropertyIsLessThanOrEqualTo": function(filter) { 
    946905                var node = this.createElementNSPlus("ogc:PropertyIsLessThanOrEqualTo"); 
    947906                // no ogc:expression handling for now 
    948                 this.writeNode(node, "PropertyName", rule); 
    949                 this.writeNode(node, "Literal", rule); 
    950                 return node; 
    951             }, 
    952             "PropertyIsGreaterThanOrEqualTo": function(rule) { 
     907                this.writeNode(node, "PropertyName", filter); 
     908                this.writeNode(node, "Literal", filter.value); 
     909                return node; 
     910            }, 
     911            "PropertyIsGreaterThanOrEqualTo": function(filter) { 
    953912                var node = this.createElementNSPlus("ogc:PropertyIsGreaterThanOrEqualTo"); 
    954913                // no ogc:expression handling for now 
    955                 this.writeNode(node, "PropertyName", rule); 
    956                 this.writeNode(node, "Literal", rule); 
    957                 return node; 
    958             }, 
    959             "PropertyIsBetween": function(rule) { 
     914                this.writeNode(node, "PropertyName", filter); 
     915                this.writeNode(node, "Literal", filter.value); 
     916                return node; 
     917            }, 
     918            "PropertyIsBetween": function(filter) { 
    960919                var node = this.createElementNSPlus("ogc:PropertyIsBetween"); 
    961920                // no ogc:expression handling for now 
    962                 this.writeNode(node, "PropertyName", rule); 
    963                 this.writeNode(node, "LowerBoundary", rule); 
    964                 this.writeNode(node, "UpperBoundary", rule); 
    965                 return node; 
    966             }, 
    967             "PropertyIsLike": function(rule) { 
     921                this.writeNode(node, "PropertyName", filter); 
     922                this.writeNode(node, "LowerBoundary", filter); 
     923                this.writeNode(node, "UpperBoundary", filter); 
     924                return node; 
     925            }, 
     926            "PropertyIsLike": function(filter) { 
    968927                var node = this.createElementNSPlus("ogc:PropertyIsLike", { 
    969928                    attributes: { 
    …… 
    972931                }); 
    973932                // no ogc:expression handling for now 
    974                 this.writeNode(node, "PropertyName", rule); 
     933                this.writeNode(node, "PropertyName", filter); 
    975934                // convert regex string to ogc string 
    976                 this.writeNode(node, "Literal", {value: rule.regex2value()}); 
    977                 return node; 
    978             }, 
    979             "PropertyName": function(rule) { 
     935                this.writeNode(node, "Literal", filter.regex2value()); 
     936                return node; 
     937            }, 
     938            "PropertyName": function(filter) { 
    980939                // no ogc:expression handling for now 
    981940                return this.createElementNSPlus("ogc:PropertyName", { 
    982                     value: rule.property 
    983                 }); 
    984             }, 
    985             "Literal": function(rule) { 
     941                    value: filter.property 
     942                }); 
     943            }, 
     944            "Literal": function(value) { 
    986945                // no ogc:expression handling for now 
    987946                return this.createElementNSPlus("ogc:Literal", { 
    988                     value: rule.value 
    989                 }); 
    990             }, 
    991             "LowerBoundary": function(rule) { 
     947                    value: value 
     948                }); 
     949            }, 
     950            "LowerBoundary": function(filter) { 
    992951